xonecas.io
62159
Sy

symb / files

symb / internal / tui / update_modals.go

8.9 KB
1package tui
2
3import (
4	"context"
5	"strings"
6
7	tea "charm.land/bubbletea/v2"
8	"github.com/rs/zerolog/log"
9	"github.com/xonecas/symb/internal/filesearch"
10	"github.com/xonecas/symb/internal/provider"
11	"github.com/xonecas/symb/internal/tui/modal"
12)
13
14func (m *Model) openFileModal() {
15	searchFn := func(query string) []modal.Item {
16		if query == "" {
17			return nil
18		}
19		results, err := m.searcher.Search(context.Background(), filesearch.Options{
20			Pattern:       query,
21			ContentSearch: false,
22			MaxResults:    50,
23		})
24		if err != nil {
25			return nil
26		}
27		items := make([]modal.Item, len(results))
28		for i, r := range results {
29			items[i] = modal.Item{Name: r.Path}
30		}
31		return items
32	}
33	md := modal.New(searchFn, "File: ", modal.Colors{
34		Fg:     palette.Fg,
35		Bg:     palette.Bg,
36		Dim:    palette.Dim,
37		SelFg:  palette.Bg,
38		SelBg:  palette.Fg,
39		Border: palette.Border,
40	})
41	md.WidthPct = 80
42
43	m.fileModal = &md
44}
45
46func (m *Model) openKeybindsModal() {
47	items := []modal.Item{
48		{Name: "ctrl+h", Desc: "keybinds"},
49		{Name: "@", Desc: "file search"},
50		{Name: "ctrl+m", Desc: "switch model"},
51		{Name: "ctrl+shift+c", Desc: "copy selection"},
52		{Name: "ctrl+shift+v", Desc: "paste"},
53		{Name: "ctrl+c", Desc: "quit"},
54		{Name: "esc", Desc: "cancel/blur"},
55		{Name: "enter", Desc: "send message"},
56		{Name: "shift+enter", Desc: "newline in input"},
57		{Name: "tab", Desc: "indent"},
58		{Name: "backspace", Desc: "delete backward"},
59		{Name: "delete", Desc: "delete forward"},
60		{Name: "up/down/left/right", Desc: "move cursor"},
61		{Name: "shift+arrows", Desc: "extend selection"},
62		{Name: "home/end/ctrl+a/ctrl+e", Desc: "line start/end"},
63		{Name: "pgup/pgdown", Desc: "page scroll"},
64		{Name: "shift+pgup/shift+pgdown", Desc: "extend selection by page"},
65		{Name: "ctrl+home/ctrl+end", Desc: "file start/end"},
66	}
67	searchFn := func(query string) []modal.Item {
68		if query == "" {
69			return items
70		}
71		q := strings.ToLower(query)
72		var filtered []modal.Item
73		for _, item := range items {
74			name := strings.ToLower(item.Name)
75			desc := strings.ToLower(item.Desc)
76			if strings.Contains(name, q) || strings.Contains(desc, q) {
77				filtered = append(filtered, item)
78			}
79		}
80		return filtered
81	}
82	md := modal.New(searchFn, "Keys: ", modal.Colors{
83		Fg:     palette.Fg,
84		Bg:     palette.Bg,
85		Dim:    palette.Dim,
86		SelFg:  palette.Bg,
87		SelBg:  palette.Fg,
88		Border: palette.Border,
89	})
90	md.WidthPct = 60
91	m.keybindsModal = &md
92}
93
94func (m *Model) updateKeybindsModal(msg tea.Msg) (Model, tea.Cmd, bool) {
95	if m.keybindsModal == nil {
96		return *m, nil, false
97	}
98	action, cmd := m.keybindsModal.HandleMsg(msg)
99	switch action.(type) {
100	case modal.ActionClose:
101		m.keybindsModal = nil
102		return *m, nil, true
103	case modal.ActionSelect:
104		return *m, nil, true
105	}
106	if cmd != nil {
107		return *m, cmd, true
108	}
109	switch msg.(type) {
110	case tea.KeyPressMsg, tea.MouseMsg:
111		return *m, nil, true
112	}
113	return *m, nil, false
114}
115
116func (m *Model) updateFileModal(msg tea.Msg) (Model, tea.Cmd, bool) {
117	if m.fileModal == nil {
118		return *m, nil, false
119	}
120	action, cmd := m.fileModal.HandleMsg(msg)
121	switch a := action.(type) {
122	case modal.ActionClose:
123		m.fileModal = nil
124		m.atOffset = 0
125		return *m, nil, true
126	case modal.ActionSelect:
127		m.fileModal = nil
128		m.atOffset = 0
129		m.agentInput.InsertText(a.Item.Name)
130		m.agentInput.Focus()
131		return *m, nil, true
132	}
133	if cmd != nil {
134		return *m, cmd, true
135	}
136	switch msg.(type) {
137	case tea.KeyPressMsg, tea.MouseMsg:
138		return *m, nil, true
139	}
140	return *m, nil, false
141}
142
143func (m *Model) fetchModelsCmd() tea.Cmd {
144	// If we have a cache, open the modal immediately with cached data and
145	// kick off a background refresh at the same time.
146	if len(m.cachedModels) > 0 {
147		cached := m.cachedModels
148		registry := m.registry
149		providerOpts := m.providerOpts
150		return tea.Batch(
151			func() tea.Msg { return modelsFetchedMsg{models: cached} },
152			func() tea.Msg {
153				log.Info().Msg("fetchModelsCmd: background refresh of all providers")
154				models := registry.ListAllModels(context.Background(), providerOpts)
155				log.Info().Int("count", len(models)).Msg("fetchModelsCmd: background refresh done")
156				return modelsFetchedMsg{models: models}
157			},
158		)
159	}
160	registry := m.registry
161	providerOpts := m.providerOpts
162	return func() tea.Msg {
163		log.Info().Msg("fetchModelsCmd: fetching all providers")
164		models := registry.ListAllModels(context.Background(), providerOpts)
165		log.Info().Int("count", len(models)).Msg("fetchModelsCmd: all providers returned")
166		return modelsFetchedMsg{models: models}
167	}
168}
169
170func (m *Model) openModelsModal(models []provider.TaggedModel) {
171	items := make([]modal.Item, len(models))
172	for i, pm := range models {
173		desc := pm.ProviderName
174		if pm.Model.ParamSize != "" {
175			desc += " · " + pm.Model.ParamSize
176		}
177		if pm.Model.QuantLevel != "" {
178			desc += " · " + pm.Model.QuantLevel
179		}
180		items[i] = modal.Item{Name: pm.ProviderName + "/" + pm.Model.Name, Desc: desc}
181	}
182	searchFn := func(query string) []modal.Item {
183		if query == "" {
184			return items
185		}
186		q := strings.ToLower(query)
187		var filtered []modal.Item
188		for _, item := range items {
189			name := strings.ToLower(item.Name)
190			desc := strings.ToLower(item.Desc)
191			if strings.Contains(name, q) || strings.Contains(desc, q) {
192				filtered = append(filtered, item)
193			}
194		}
195		return filtered
196	}
197	md := modal.New(searchFn, "Model: ", modal.Colors{
198		Fg:     palette.Fg,
199		Bg:     palette.Bg,
200		Dim:    palette.Dim,
201		SelFg:  palette.Bg,
202		SelBg:  palette.Fg,
203		Border: palette.Border,
204	})
205	md.WidthPct = 60
206	m.modelsModal = &md
207}
208
209func (m *Model) updateModelsModal(msg tea.Msg) (Model, tea.Cmd, bool) {
210	if m.modelsModal == nil {
211		return *m, nil, false
212	}
213	action, cmd := m.modelsModal.HandleMsg(msg)
214	switch a := action.(type) {
215	case modal.ActionClose:
216		m.modelsModal = nil
217		return *m, nil, true
218	case modal.ActionSelect:
219		m.modelsModal = nil
220		return *m, m.switchModelCmd(a.Item.Name), true
221	}
222	if cmd != nil {
223		return *m, cmd, true
224	}
225	switch msg.(type) {
226	case tea.KeyPressMsg, tea.MouseMsg:
227		return *m, nil, true
228	}
229	return *m, nil, false
230}
231
232// switchModelCmd accepts a selection of the form "providerName/modelName" as
233// produced by openModelsModal, or a bare model name (falls back to the current
234// provider config name for backwards compatibility).
235func (m *Model) switchModelCmd(selection string) tea.Cmd {
236	registry := m.registry
237	currentProviderConfigName := m.providerConfigName
238	providerOpts := m.providerOpts
239	oldProv := m.provider
240
241	// Parse "providerName/modelName". Use SplitN so model names containing
242	// additional slashes (e.g. "org/repo/model") are preserved intact.
243	providerConfigName := currentProviderConfigName
244	modelName := selection
245	if parts := strings.SplitN(selection, "/", 2); len(parts) == 2 {
246		providerConfigName = parts[0]
247		modelName = parts[1]
248	}
249
250	return func() tea.Msg {
251		if registry == nil {
252			return modelSwitchedMsg{err: provider.ErrProviderNotFound}
253		}
254		log.Info().Str("provider", providerConfigName).Str("model", modelName).Msg("switchModelCmd")
255		newProv, err := registry.Create(providerConfigName, modelName, providerOpts)
256		if err != nil {
257			return modelSwitchedMsg{err: err}
258		}
259		if oldProv != nil {
260			oldProv.Close()
261		}
262		return modelSwitchedMsg{modelName: modelName, providerName: providerConfigName, prov: newProv}
263	}
264}
265
266func (m *Model) openToolViewModal(title, content string) {
267	tv := modal.NewToolView(title, content, modal.Colors{
268		Fg:     palette.Fg,
269		Bg:     palette.Bg,
270		Dim:    palette.Dim,
271		SelFg:  palette.Bg,
272		SelBg:  palette.Fg,
273		Border: palette.Border,
274	})
275	m.toolViewModal = &tv
276}
277
278func (m *Model) updateToolViewModal(msg tea.Msg) (Model, tea.Cmd, bool) {
279	if m.toolViewModal == nil {
280		return *m, nil, false
281	}
282	action, cmd := m.toolViewModal.HandleMsg(msg)
283	switch action.(type) {
284	case modal.ActionClose:
285		m.toolViewModal = nil
286		return *m, nil, true
287	}
288	if cmd != nil {
289		return *m, cmd, true
290	}
291	switch msg.(type) {
292	case tea.KeyPressMsg, tea.MouseMsg:
293		return *m, nil, true
294	}
295	return *m, nil, false
296}
297
298func (m *Model) handleModelsFetched(msg modelsFetchedMsg) tea.Model {
299	if msg.err != nil {
300		log.Error().Err(msg.err).Msg("handleModelsFetched error")
301		m.lastNetError = "Failed to list models: " + msg.err.Error()
302		return m
303	}
304	if len(msg.models) == 0 {
305		log.Warn().Msg("handleModelsFetched: no models")
306		m.lastNetError = "No models available"
307		return m
308	}
309	// Update cache whenever we receive a fresh (non-empty) list.
310	m.cachedModels = msg.models
311	// Don't clobber an already-open modal (background refresh case).
312	if m.modelsModal != nil {
313		return m
314	}
315	log.Info().Int("count", len(msg.models)).Msg("handleModelsFetched opening modal")
316	m.openModelsModal(msg.models)
317	return m
318}
319
320func (m *Model) handleModelSwitched(msg modelSwitchedMsg) tea.Model {
321	if msg.err != nil {
322		m.lastNetError = "Failed to switch model: " + msg.err.Error()
323		return m
324	}
325	m.provider = msg.prov
326	if m.sharedProvider != nil {
327		prov := msg.prov
328		m.sharedProvider.Store(&prov)
329	}
330	m.currentModelName = msg.modelName
331	if msg.providerName != "" {
332		m.providerConfigName = msg.providerName
333	}
334	return m
335}