1package dialog
2
3import (
4 "os"
5 "strings"
6
7 "charm.land/bubbles/v2/help"
8 "charm.land/bubbles/v2/key"
9 "charm.land/bubbles/v2/spinner"
10 "charm.land/bubbles/v2/textinput"
11 tea "charm.land/bubbletea/v2"
12 "github.com/charmbracelet/catwalk/pkg/catwalk"
13 "github.com/charmbracelet/crush/internal/agent/hyper"
14 "github.com/charmbracelet/crush/internal/commands"
15 "github.com/charmbracelet/crush/internal/config"
16 "github.com/charmbracelet/crush/internal/ui/common"
17 "github.com/charmbracelet/crush/internal/ui/list"
18 "github.com/charmbracelet/crush/internal/ui/styles"
19 uv "github.com/charmbracelet/ultraviolet"
20)
21
22// CommandsID is the identifier for the commands dialog.
23const CommandsID = "commands"
24
25// CommandType represents the type of commands being displayed.
26type CommandType uint
27
28// String returns the string representation of the CommandType.
29func (c CommandType) String() string { return []string{"System", "User", "MCP"}[c] }
30
31const (
32 sidebarCompactModeBreakpoint = 120
33 defaultCommandsDialogMaxWidth = 70
34)
35
36const (
37 SystemCommands CommandType = iota
38 UserCommands
39 MCPPrompts
40)
41
42// Commands represents a dialog that shows available commands.
43type Commands struct {
44 com *common.Common
45 keyMap struct {
46 Select,
47 UpDown,
48 Next,
49 Previous,
50 Tab,
51 ShiftTab,
52 Close key.Binding
53 }
54
55 sessionID string // can be empty for non-session-specific commands
56 selected CommandType
57
58 spinner spinner.Model
59 loading bool
60
61 help help.Model
62 input textinput.Model
63 list *list.FilterableList
64
65 windowWidth int
66
67 customCommands []commands.CustomCommand
68 mcpPrompts []commands.MCPPrompt
69}
70
71var _ Dialog = (*Commands)(nil)
72
73// NewCommands creates a new commands dialog.
74func NewCommands(com *common.Common, sessionID string, customCommands []commands.CustomCommand, mcpPrompts []commands.MCPPrompt) (*Commands, error) {
75 c := &Commands{
76 com: com,
77 selected: SystemCommands,
78 sessionID: sessionID,
79 customCommands: customCommands,
80 mcpPrompts: mcpPrompts,
81 }
82
83 help := help.New()
84 help.Styles = com.Styles.DialogHelpStyles()
85
86 c.help = help
87
88 c.list = list.NewFilterableList()
89 c.list.Focus()
90 c.list.SetSelected(0)
91
92 c.input = textinput.New()
93 c.input.SetVirtualCursor(false)
94 c.input.Placeholder = "Type to filter"
95 c.input.SetStyles(com.Styles.TextInput)
96 c.input.Focus()
97
98 c.keyMap.Select = key.NewBinding(
99 key.WithKeys("enter", "ctrl+y"),
100 key.WithHelp("enter", "confirm"),
101 )
102 c.keyMap.UpDown = key.NewBinding(
103 key.WithKeys("up", "down"),
104 key.WithHelp("↑/↓", "choose"),
105 )
106 c.keyMap.Next = key.NewBinding(
107 key.WithKeys("down"),
108 key.WithHelp("↓", "next item"),
109 )
110 c.keyMap.Previous = key.NewBinding(
111 key.WithKeys("up", "ctrl+p"),
112 key.WithHelp("↑", "previous item"),
113 )
114 c.keyMap.Tab = key.NewBinding(
115 key.WithKeys("tab"),
116 key.WithHelp("tab", "switch selection"),
117 )
118 c.keyMap.ShiftTab = key.NewBinding(
119 key.WithKeys("shift+tab"),
120 key.WithHelp("shift+tab", "switch selection prev"),
121 )
122 closeKey := CloseKey
123 closeKey.SetHelp("esc", "cancel")
124 c.keyMap.Close = closeKey
125
126 // Set initial commands
127 c.setCommandItems(c.selected)
128
129 s := spinner.New()
130 s.Spinner = spinner.Dot
131 s.Style = com.Styles.Dialog.Spinner
132 c.spinner = s
133
134 return c, nil
135}
136
137// ID implements Dialog.
138func (c *Commands) ID() string {
139 return CommandsID
140}
141
142// HandleMsg implements [Dialog].
143func (c *Commands) HandleMsg(msg tea.Msg) Action {
144 switch msg := msg.(type) {
145 case spinner.TickMsg:
146 if c.loading {
147 var cmd tea.Cmd
148 c.spinner, cmd = c.spinner.Update(msg)
149 return ActionCmd{Cmd: cmd}
150 }
151 case tea.KeyPressMsg:
152 switch {
153 case key.Matches(msg, c.keyMap.Close):
154 return ActionClose{}
155 case key.Matches(msg, c.keyMap.Previous):
156 c.list.Focus()
157 if c.list.IsSelectedFirst() {
158 c.list.SelectLast()
159 c.list.ScrollToBottom()
160 break
161 }
162 c.list.SelectPrev()
163 c.list.ScrollToSelected()
164 case key.Matches(msg, c.keyMap.Next):
165 c.list.Focus()
166 if c.list.IsSelectedLast() {
167 c.list.SelectFirst()
168 c.list.ScrollToTop()
169 break
170 }
171 c.list.SelectNext()
172 c.list.ScrollToSelected()
173 case key.Matches(msg, c.keyMap.Select):
174 if selectedItem := c.list.SelectedItem(); selectedItem != nil {
175 if item, ok := selectedItem.(*CommandItem); ok && item != nil {
176 return item.Action()
177 }
178 }
179 case key.Matches(msg, c.keyMap.Tab):
180 if len(c.customCommands) > 0 || len(c.mcpPrompts) > 0 {
181 c.selected = c.nextCommandType()
182 c.setCommandItems(c.selected)
183 }
184 case key.Matches(msg, c.keyMap.ShiftTab):
185 if len(c.customCommands) > 0 || len(c.mcpPrompts) > 0 {
186 c.selected = c.previousCommandType()
187 c.setCommandItems(c.selected)
188 }
189 default:
190 var cmd tea.Cmd
191 for _, item := range c.list.VisibleItems() {
192 if item, ok := item.(*CommandItem); ok && item != nil {
193 if msg.String() == item.Shortcut() {
194 return item.Action()
195 }
196 }
197 }
198 c.input, cmd = c.input.Update(msg)
199 value := c.input.Value()
200 c.list.SetFilter(value)
201 c.list.ScrollToTop()
202 c.list.SetSelected(0)
203 return ActionCmd{cmd}
204 }
205 }
206 return nil
207}
208
209// Cursor returns the cursor position relative to the dialog.
210func (c *Commands) Cursor() *tea.Cursor {
211 return InputCursor(c.com.Styles, c.input.Cursor())
212}
213
214// commandsRadioView generates the command type selector radio buttons.
215func commandsRadioView(sty *styles.Styles, selected CommandType, hasUserCmds bool, hasMCPPrompts bool) string {
216 if !hasUserCmds && !hasMCPPrompts {
217 return ""
218 }
219
220 selectedFn := func(t CommandType) string {
221 if t == selected {
222 return sty.RadioOn.Padding(0, 1).Render() + sty.HalfMuted.Render(t.String())
223 }
224 return sty.RadioOff.Padding(0, 1).Render() + sty.HalfMuted.Render(t.String())
225 }
226
227 parts := []string{
228 selectedFn(SystemCommands),
229 }
230
231 if hasUserCmds {
232 parts = append(parts, selectedFn(UserCommands))
233 }
234 if hasMCPPrompts {
235 parts = append(parts, selectedFn(MCPPrompts))
236 }
237
238 return strings.Join(parts, " ")
239}
240
241// Draw implements [Dialog].
242func (c *Commands) Draw(scr uv.Screen, area uv.Rectangle) *tea.Cursor {
243 t := c.com.Styles
244 width := max(0, min(defaultCommandsDialogMaxWidth, area.Dx()))
245 height := max(0, min(defaultDialogHeight, area.Dy()))
246 if area.Dx() != c.windowWidth && c.selected == SystemCommands {
247 c.windowWidth = area.Dx()
248 // since some items in the list depend on width (e.g. toggle sidebar command),
249 // we need to reset the command items when width changes
250 c.setCommandItems(c.selected)
251 }
252
253 innerWidth := width - c.com.Styles.Dialog.View.GetHorizontalFrameSize()
254 heightOffset := t.Dialog.Title.GetVerticalFrameSize() + titleContentHeight +
255 t.Dialog.InputPrompt.GetVerticalFrameSize() + inputContentHeight +
256 t.Dialog.HelpView.GetVerticalFrameSize() +
257 t.Dialog.View.GetVerticalFrameSize()
258
259 c.input.SetWidth(innerWidth - t.Dialog.InputPrompt.GetHorizontalFrameSize() - 1) // (1) cursor padding
260
261 listHeight := min(height-heightOffset, c.list.Len())
262 c.list.SetSize(innerWidth, listHeight)
263 c.help.SetWidth(innerWidth)
264
265 rc := NewRenderContext(t, width)
266 rc.Title = "Commands"
267 rc.TitleInfo = commandsRadioView(t, c.selected, len(c.customCommands) > 0, len(c.mcpPrompts) > 0)
268 inputView := t.Dialog.InputPrompt.Render(c.input.View())
269 rc.AddPart(inputView)
270 listView := t.Dialog.List.Height(c.list.Height()).Render(c.list.Render())
271 rc.AddPart(listView)
272 rc.Help = c.help.View(c)
273
274 if c.loading {
275 rc.Help = c.spinner.View() + " Generating Prompt..."
276 }
277
278 view := rc.Render()
279
280 cur := c.Cursor()
281 DrawCenterCursor(scr, area, view, cur)
282 return cur
283}
284
285// ShortHelp implements [help.KeyMap].
286func (c *Commands) ShortHelp() []key.Binding {
287 return []key.Binding{
288 c.keyMap.Tab,
289 c.keyMap.UpDown,
290 c.keyMap.Select,
291 c.keyMap.Close,
292 }
293}
294
295// FullHelp implements [help.KeyMap].
296func (c *Commands) FullHelp() [][]key.Binding {
297 return [][]key.Binding{
298 {c.keyMap.Select, c.keyMap.Next, c.keyMap.Previous, c.keyMap.Tab},
299 {c.keyMap.Close},
300 }
301}
302
303// nextCommandType returns the next command type in the cycle.
304func (c *Commands) nextCommandType() CommandType {
305 switch c.selected {
306 case SystemCommands:
307 if len(c.customCommands) > 0 {
308 return UserCommands
309 }
310 if len(c.mcpPrompts) > 0 {
311 return MCPPrompts
312 }
313 fallthrough
314 case UserCommands:
315 if len(c.mcpPrompts) > 0 {
316 return MCPPrompts
317 }
318 fallthrough
319 case MCPPrompts:
320 return SystemCommands
321 default:
322 return SystemCommands
323 }
324}
325
326// previousCommandType returns the previous command type in the cycle.
327func (c *Commands) previousCommandType() CommandType {
328 switch c.selected {
329 case SystemCommands:
330 if len(c.mcpPrompts) > 0 {
331 return MCPPrompts
332 }
333 if len(c.customCommands) > 0 {
334 return UserCommands
335 }
336 return SystemCommands
337 case UserCommands:
338 return SystemCommands
339 case MCPPrompts:
340 if len(c.customCommands) > 0 {
341 return UserCommands
342 }
343 return SystemCommands
344 default:
345 return SystemCommands
346 }
347}
348
349// setCommandItems sets the command items based on the specified command type.
350func (c *Commands) setCommandItems(commandType CommandType) {
351 c.selected = commandType
352
353 commandItems := []list.FilterableItem{}
354 switch c.selected {
355 case SystemCommands:
356 for _, cmd := range c.defaultCommands() {
357 commandItems = append(commandItems, cmd)
358 }
359 case UserCommands:
360 for _, cmd := range c.customCommands {
361 action := ActionRunCustomCommand{
362 Content: cmd.Content,
363 Arguments: cmd.Arguments,
364 }
365 commandItems = append(commandItems, NewCommandItem(c.com.Styles, "custom_"+cmd.ID, cmd.Name, "", action))
366 }
367 case MCPPrompts:
368 for _, cmd := range c.mcpPrompts {
369 action := ActionRunMCPPrompt{
370 Title: cmd.Title,
371 Description: cmd.Description,
372 PromptID: cmd.PromptID,
373 ClientID: cmd.ClientID,
374 Arguments: cmd.Arguments,
375 }
376 commandItems = append(commandItems, NewCommandItem(c.com.Styles, "mcp_"+cmd.ID, cmd.PromptID, "", action))
377 }
378 }
379
380 c.list.SetItems(commandItems...)
381 c.list.SetFilter("")
382 c.list.ScrollToTop()
383 c.list.SetSelected(0)
384 c.input.SetValue("")
385}
386
387// defaultCommands returns the list of default system commands.
388func (c *Commands) defaultCommands() []*CommandItem {
389 commands := []*CommandItem{
390 NewCommandItem(c.com.Styles, "new_session", "New Session", "ctrl+n", ActionNewSession{}),
391 NewCommandItem(c.com.Styles, "switch_session", "Switch Session", "ctrl+s", ActionOpenDialog{SessionsID}),
392 NewCommandItem(c.com.Styles, "switch_model", "Switch Model", "ctrl+l", ActionOpenDialog{ModelsID}),
393 }
394
395 // Only show compact command if there's an active session
396 if c.sessionID != "" {
397 commands = append(commands, NewCommandItem(c.com.Styles, "summarize", "Summarize Session", "", ActionSummarize{SessionID: c.sessionID}))
398 }
399
400 // Add reasoning toggle for models that support it
401 cfg := c.com.Config()
402 if agentCfg, ok := cfg.Agents[config.AgentCoder]; ok {
403 providerCfg := cfg.GetProviderForModel(agentCfg.Model)
404 model := cfg.GetModelByType(agentCfg.Model)
405 if providerCfg != nil && model != nil && model.CanReason {
406 selectedModel := cfg.Models[agentCfg.Model]
407
408 // Anthropic models: thinking toggle
409 if providerCfg.Type == catwalk.TypeAnthropic || providerCfg.Type == catwalk.Type(hyper.Name) {
410 status := "Enable"
411 if selectedModel.Think {
412 status = "Disable"
413 }
414 commands = append(commands, NewCommandItem(c.com.Styles, "toggle_thinking", status+" Thinking Mode", "", ActionToggleThinking{}))
415 }
416
417 // OpenAI models: reasoning effort dialog
418 if len(model.ReasoningLevels) > 0 {
419 commands = append(commands, NewCommandItem(c.com.Styles, "select_reasoning_effort", "Select Reasoning Effort", "", ActionOpenDialog{
420 DialogID: ReasoningID,
421 }))
422 }
423 }
424 }
425 // Only show toggle compact mode command if window width is larger than compact breakpoint (120)
426 if c.windowWidth > sidebarCompactModeBreakpoint && c.sessionID != "" {
427 commands = append(commands, NewCommandItem(c.com.Styles, "toggle_sidebar", "Toggle Sidebar", "", ActionToggleCompactMode{}))
428 }
429 if c.sessionID != "" {
430 cfg := c.com.Config()
431 agentCfg := cfg.Agents[config.AgentCoder]
432 model := cfg.GetModelByType(agentCfg.Model)
433 if model != nil && model.SupportsImages {
434 commands = append(commands, NewCommandItem(c.com.Styles, "file_picker", "Open File Picker", "ctrl+f", ActionOpenDialog{
435 // TODO: Pass in the file picker dialog id
436 }))
437 }
438 }
439
440 // Add external editor command if $EDITOR is available
441 // TODO: Use [tea.EnvMsg] to get environment variable instead of os.Getenv
442 if os.Getenv("EDITOR") != "" {
443 commands = append(commands, NewCommandItem(c.com.Styles, "open_external_editor", "Open External Editor", "ctrl+o", ActionExternalEditor{}))
444 }
445
446 return append(commands,
447 NewCommandItem(c.com.Styles, "toggle_yolo", "Toggle Yolo Mode", "", ActionToggleYoloMode{}),
448 NewCommandItem(c.com.Styles, "toggle_help", "Toggle Help", "ctrl+g", ActionToggleHelp{}),
449 NewCommandItem(c.com.Styles, "init", "Initialize Project", "", ActionInitializeProject{}),
450 NewCommandItem(c.com.Styles, "quit", "Quit", "ctrl+c", tea.QuitMsg{}),
451 )
452}
453
454// SetCustomCommands sets the custom commands and refreshes the view if user commands are currently displayed.
455func (c *Commands) SetCustomCommands(customCommands []commands.CustomCommand) {
456 c.customCommands = customCommands
457 if c.selected == UserCommands {
458 c.setCommandItems(c.selected)
459 }
460}
461
462// SetMCPPrompts sets the MCP prompts and refreshes the view if MCP prompts are currently displayed.
463func (c *Commands) SetMCPPrompts(mcpPrompts []commands.MCPPrompt) {
464 c.mcpPrompts = mcpPrompts
465 if c.selected == MCPPrompts {
466 c.setCommandItems(c.selected)
467 }
468}
469
470// StartLoading implements [LoadingDialog].
471func (a *Commands) StartLoading() tea.Cmd {
472 if a.loading {
473 return nil
474 }
475 a.loading = true
476 return a.spinner.Tick
477}
478
479// StopLoading implements [LoadingDialog].
480func (a *Commands) StopLoading() {
481 a.loading = false
482}