git.iko.soy/crush
on main help sign in
Refactor commands (#1847)
7a2769cKujtim Hoxha
internal/commands/commands.gonew file+213
compare with main
unifiedsplit
@@ -0,0 +1,213 @@
1+package commands
2+
3+import (
4+ "io/fs"
5+ "os"
6+ "path/filepath"
7+ "regexp"
8+ "strings"
9+
10+ "github.com/charmbracelet/crush/internal/agent/tools/mcp"
11+ "github.com/charmbracelet/crush/internal/config"
12+ "github.com/charmbracelet/crush/internal/home"
13+)
14+
15+var namedArgPattern = regexp.MustCompile(`\$([A-Z][A-Z0-9_]*)`)
16+
17+const (
18+ userCommandPrefix = "user:"
19+ projectCommandPrefix = "project:"
20+)
21+
22+// Argument represents a command argument with its name and required status.
23+type Argument struct {
24+ Name string
25+ Required bool
26+}
27+
28+// MCPCustomCommand represents a custom command loaded from an MCP server.
29+type MCPCustomCommand struct {
30+ ID string
31+ Name string
32+ Client string
33+ Arguments []Argument
34+}
35+
36+// CustomCommand represents a user-defined custom command loaded from markdown files.
37+type CustomCommand struct {
38+ ID string
39+ Name string
40+ Content string
41+ Arguments []Argument
42+}
43+
44+type commandSource struct {
45+ path string
46+ prefix string
47+}
48+
49+// LoadCustomCommands loads custom commands from multiple sources including
50+// XDG config directory, home directory, and project directory.
51+func LoadCustomCommands(cfg *config.Config) ([]CustomCommand, error) {
52+ return loadAll(buildCommandSources(cfg))
53+}
54+
55+// LoadMCPCustomCommands loads custom commands from available MCP servers.
56+func LoadMCPCustomCommands() ([]MCPCustomCommand, error) {
57+ var commands []MCPCustomCommand
58+ for mcpName, prompts := range mcp.Prompts() {
59+ for _, prompt := range prompts {
60+ key := mcpName + ":" + prompt.Name
61+ var args []Argument
62+ for _, arg := range prompt.Arguments {
63+ args = append(args, Argument{Name: arg.Name, Required: arg.Required})
64+ }
65+
66+ commands = append(commands, MCPCustomCommand{
67+ ID: key,
68+ Name: prompt.Name,
69+ Client: mcpName,
70+ Arguments: args,
71+ })
72+ }
73+ }
74+ return commands, nil
75+}
76+
77+func buildCommandSources(cfg *config.Config) []commandSource {
78+ var sources []commandSource
79+
80+ // XDG config directory
81+ if dir := getXDGCommandsDir(); dir != "" {
82+ sources = append(sources, commandSource{
83+ path: dir,
84+ prefix: userCommandPrefix,
85+ })
86+ }
87+
88+ // Home directory
89+ if home := home.Dir(); home != "" {
90+ sources = append(sources, commandSource{
91+ path: filepath.Join(home, ".crush", "commands"),
92+ prefix: userCommandPrefix,
93+ })
94+ }
95+
96+ // Project directory
97+ sources = append(sources, commandSource{
98+ path: filepath.Join(cfg.Options.DataDirectory, "commands"),
99+ prefix: projectCommandPrefix,
100+ })
101+
102+ return sources
103+}
104+
105+func loadAll(sources []commandSource) ([]CustomCommand, error) {
106+ var commands []CustomCommand
107+
108+ for _, source := range sources {
109+ if cmds, err := loadFromSource(source); err == nil {
110+ commands = append(commands, cmds...)
111+ }
112+ }
113+
114+ return commands, nil
115+}
116+
117+func loadFromSource(source commandSource) ([]CustomCommand, error) {
118+ if err := ensureDir(source.path); err != nil {
119+ return nil, err
120+ }
121+
122+ var commands []CustomCommand
123+
124+ err := filepath.WalkDir(source.path, func(path string, d fs.DirEntry, err error) error {
125+ if err != nil || d.IsDir() || !isMarkdownFile(d.Name()) {
126+ return err
127+ }
128+
129+ cmd, err := loadCommand(path, source.path, source.prefix)
130+ if err != nil {
131+ return nil // Skip invalid files
132+ }
133+
134+ commands = append(commands, cmd)
135+ return nil
136+ })
137+
138+ return commands, err
139+}
140+
141+func loadCommand(path, baseDir, prefix string) (CustomCommand, error) {
142+ content, err := os.ReadFile(path)
143+ if err != nil {
144+ return CustomCommand{}, err
145+ }
146+
147+ id := buildCommandID(path, baseDir, prefix)
148+
149+ return CustomCommand{
150+ ID: id,
151+ Name: id,
152+ Content: string(content),
153+ Arguments: extractArgNames(string(content)),
154+ }, nil
155+}
156+
157+func extractArgNames(content string) []Argument {
158+ matches := namedArgPattern.FindAllStringSubmatch(content, -1)
159+ if len(matches) == 0 {
160+ return nil
161+ }
162+
163+ seen := make(map[string]bool)
164+ var args []Argument
165+
166+ for _, match := range matches {
167+ arg := match[1]
168+ if !seen[arg] {
169+ seen[arg] = true
170+ // for normal custom commands, all args are required
171+ args = append(args, Argument{Name: arg, Required: true})
172+ }
173+ }
174+
175+ return args
176+}
177+
178+func buildCommandID(path, baseDir, prefix string) string {
179+ relPath, _ := filepath.Rel(baseDir, path)
180+ parts := strings.Split(relPath, string(filepath.Separator))
181+
182+ // Remove .md extension from last part
183+ if len(parts) > 0 {
184+ lastIdx := len(parts) - 1
185+ parts[lastIdx] = strings.TrimSuffix(parts[lastIdx], filepath.Ext(parts[lastIdx]))
186+ }
187+
188+ return prefix + strings.Join(parts, ":")
189+}
190+
191+func getXDGCommandsDir() string {
192+ xdgHome := os.Getenv("XDG_CONFIG_HOME")
193+ if xdgHome == "" {
194+ if home := home.Dir(); home != "" {
195+ xdgHome = filepath.Join(home, ".config")
196+ }
197+ }
198+ if xdgHome != "" {
199+ return filepath.Join(xdgHome, "crush", "commands")
200+ }
201+ return ""
202+}
203+
204+func ensureDir(path string) error {
205+ if _, err := os.Stat(path); os.IsNotExist(err) {
206+ return os.MkdirAll(path, 0o755)
207+ }
208+ return nil
209+}
210+
211+func isMarkdownFile(name string) bool {
212+ return strings.HasSuffix(strings.ToLower(name), ".md")
213+}
internal/ui/dialog/actions.go+20
@@ -3,6 +3,7 @@ package dialog
3import (
3import (
4 tea "charm.land/bubbletea/v2"
4 tea "charm.land/bubbletea/v2"
5 "github.com/charmbracelet/catwalk/pkg/catwalk"
5 "github.com/charmbracelet/catwalk/pkg/catwalk"
6+ "github.com/charmbracelet/crush/internal/commands"
6 "github.com/charmbracelet/crush/internal/config"
7 "github.com/charmbracelet/crush/internal/config"
7 "github.com/charmbracelet/crush/internal/permission"
8 "github.com/charmbracelet/crush/internal/permission"
8 "github.com/charmbracelet/crush/internal/session"
9 "github.com/charmbracelet/crush/internal/session"
@@ -39,6 +40,8 @@ type (
39 ActionToggleThinking struct{}
40 ActionToggleThinking struct{}
40 ActionExternalEditor struct{}
41 ActionExternalEditor struct{}
41 ActionToggleYoloMode struct{}
42 ActionToggleYoloMode struct{}
43+ // ActionInitializeProject is a message to initialize a project.
44+ ActionInitializeProject struct{}
42 ActionSummarize struct {
45 ActionSummarize struct {
43 SessionID string
46 SessionID string
44 }
47 }
@@ -46,6 +49,23 @@ type (
46 Permission permission.PermissionRequest
49 Permission permission.PermissionRequest
47 Action PermissionAction
50 Action PermissionAction
48 }
51 }
52+ // ActionRunCustomCommand is a message to run a custom command.
53+ ActionRunCustomCommand struct {
54+ CommandID string
55+ // Used when running a user-defined command
56+ Content string
57+ // Used when running a prompt from MCP
58+ Client string
59+ }
60+ // ActionOpenCustomCommandArgumentsDialog is a message to open the custom command arguments dialog.
61+ ActionOpenCustomCommandArgumentsDialog struct {
62+ CommandID string
63+ // Used when running a user-defined command
64+ Content string
65+ // Used when running a prompt from MCP
66+ Client string
67+ Arguments []commands.Argument
68+ }
49)
69)
50
70
51// Messages for API key input dialog.
71// Messages for API key input dialog.
internal/ui/dialog/commands.go+177−209
@@ -1,9 +1,7 @@
1package dialog
1package dialog
2
2
3import (
3import (
4− "fmt"
5 "os"
4 "os"
6− "slices"
7 "strings"
5 "strings"
8
6
9 "charm.land/bubbles/v2/help"
7 "charm.land/bubbles/v2/help"
@@ -12,15 +10,11 @@ import (
12 tea "charm.land/bubbletea/v2"
10 tea "charm.land/bubbletea/v2"
13 "charm.land/lipgloss/v2"
11 "charm.land/lipgloss/v2"
14 "github.com/charmbracelet/catwalk/pkg/catwalk"
12 "github.com/charmbracelet/catwalk/pkg/catwalk"
15− "github.com/charmbracelet/crush/internal/agent"
13+ "github.com/charmbracelet/crush/internal/commands"
16 "github.com/charmbracelet/crush/internal/config"
14 "github.com/charmbracelet/crush/internal/config"
17− "github.com/charmbracelet/crush/internal/csync"
18− "github.com/charmbracelet/crush/internal/ui/chat"
19 "github.com/charmbracelet/crush/internal/ui/common"
15 "github.com/charmbracelet/crush/internal/ui/common"
20 "github.com/charmbracelet/crush/internal/ui/list"
16 "github.com/charmbracelet/crush/internal/ui/list"
21 "github.com/charmbracelet/crush/internal/ui/styles"
17 "github.com/charmbracelet/crush/internal/ui/styles"
22− "github.com/charmbracelet/crush/internal/uicmd"
23− "github.com/charmbracelet/crush/internal/uiutil"
24 uv "github.com/charmbracelet/ultraviolet"
18 uv "github.com/charmbracelet/ultraviolet"
25 "github.com/charmbracelet/x/ansi"
19 "github.com/charmbracelet/x/ansi"
26)
20)
@@ -28,6 +22,20 @@ import (
28// CommandsID is the identifier for the commands dialog.
22// CommandsID is the identifier for the commands dialog.
29const CommandsID = "commands"
23const CommandsID = "commands"
30
24
25+// CommandType represents the type of commands being displayed.
26+type CommandType uint
27+
28+// String returns the string representation of the CommandType.
29+func (c CommandType) String() string { return []string{"System", "User", "MCP"}[c] }
30+
31+const sidebarCompactModeBreakpoint = 120
32+
33+const (
34+ SystemCommands CommandType = iota
35+ UserCommands
36+ MCPPrompts
37+)
38+
31// Commands represents a dialog that shows available commands.
39// Commands represents a dialog that shows available commands.
32type Commands struct {
40type Commands struct {
33 com *common.Common
41 com *common.Common
@@ -37,39 +45,33 @@ type Commands struct {
37 Next,
45 Next,
38 Previous,
46 Previous,
39 Tab,
47 Tab,
48+ ShiftTab,
40 Close key.Binding
49 Close key.Binding
41 }
50 }
42
51
43− sessionID string // can be empty for non-session-specific commands
52+ sessionID string // can be empty for non-session-specific commands
44− selected uicmd.CommandType
53+ selected CommandType
45− userCmds []uicmd.Command
46− mcpPrompts *csync.Slice[uicmd.Command]
47
54
48 help help.Model
55 help help.Model
49 input textinput.Model
56 input textinput.Model
50 list *list.FilterableList
57 list *list.FilterableList
51
58
52− width int
59+ windowWidth int
60+
61+ customCommands []commands.CustomCommand
62+ mcpCustomCommands []commands.MCPCustomCommand
53}
63}
54
64
55var _ Dialog = (*Commands)(nil)
65var _ Dialog = (*Commands)(nil)
56
66
57// NewCommands creates a new commands dialog.
67// NewCommands creates a new commands dialog.
58−func NewCommands(com *common.Common, sessionID string) (*Commands, error) {
68+func NewCommands(com *common.Common, sessionID string, customCommands []commands.CustomCommand, mcpCustomCommands []commands.MCPCustomCommand) (*Commands, error) {
59− commands, err := uicmd.LoadCustomCommandsFromConfig(com.Config())
60− if err != nil {
61− return nil, err
62− }
63−
64− mcpPrompts := csync.NewSlice[uicmd.Command]()
65− mcpPrompts.SetSlice(uicmd.LoadMCPPrompts())
66−
67 c := &Commands{
69 c := &Commands{
68− com: com,
70+ com: com,
69− userCmds: commands,
70− selected: uicmd.SystemCommands,
71+ selected: SystemCommands,
71− mcpPrompts: mcpPrompts,
72+ sessionID: sessionID,
72− sessionID: sessionID,
73+ customCommands: customCommands,
74+ mcpCustomCommands: mcpCustomCommands,
73 }
75 }
74
76
75 help := help.New()
77 help := help.New()
@@ -96,7 +98,7 @@ func NewCommands(com *common.Common, sessionID string) (*Commands, error) {
96 key.WithHelp("↑/↓", "choose"),
98 key.WithHelp("↑/↓", "choose"),
97 )
99 )
98 c.keyMap.Next = key.NewBinding(
100 c.keyMap.Next = key.NewBinding(
99− key.WithKeys("down", "ctrl+n"),
101+ key.WithKeys("down"),
100 key.WithHelp("↓", "next item"),
102 key.WithHelp("↓", "next item"),
101 )
103 )
102 c.keyMap.Previous = key.NewBinding(
104 c.keyMap.Previous = key.NewBinding(
@@ -107,12 +109,16 @@ func NewCommands(com *common.Common, sessionID string) (*Commands, error) {
107 key.WithKeys("tab"),
109 key.WithKeys("tab"),
108 key.WithHelp("tab", "switch selection"),
110 key.WithHelp("tab", "switch selection"),
109 )
111 )
112+ c.keyMap.ShiftTab = key.NewBinding(
113+ key.WithKeys("shift+tab"),
114+ key.WithHelp("shift+tab", "switch selection prev"),
115+ )
110 closeKey := CloseKey
116 closeKey := CloseKey
111 closeKey.SetHelp("esc", "cancel")
117 closeKey.SetHelp("esc", "cancel")
112 c.keyMap.Close = closeKey
118 c.keyMap.Close = closeKey
113
119
114 // Set initial commands
120 // Set initial commands
115− c.setCommandType(c.selected)
121+ c.setCommandItems(c.selected)
116
122
117 return c, nil
123 return c, nil
118}
124}
@@ -150,20 +156,28 @@ func (c *Commands) HandleMsg(msg tea.Msg) Action {
150 case key.Matches(msg, c.keyMap.Select):
156 case key.Matches(msg, c.keyMap.Select):
151 if selectedItem := c.list.SelectedItem(); selectedItem != nil {
157 if selectedItem := c.list.SelectedItem(); selectedItem != nil {
152 if item, ok := selectedItem.(*CommandItem); ok && item != nil {
158 if item, ok := selectedItem.(*CommandItem); ok && item != nil {
153− // TODO: Please unravel this mess later and the Command
154− // Handler design.
155− if cmd := item.Cmd.Handler(item.Cmd); cmd != nil { // Huh??
156− return cmd()
159+ return item.Action()
157− }
158 }
160 }
159 }
161 }
160 case key.Matches(msg, c.keyMap.Tab):
162 case key.Matches(msg, c.keyMap.Tab):
161− if len(c.userCmds) > 0 || c.mcpPrompts.Len() > 0 {
163+ if len(c.customCommands) > 0 || len(c.mcpCustomCommands) > 0 {
162 c.selected = c.nextCommandType()
164 c.selected = c.nextCommandType()
163− c.setCommandType(c.selected)
165+ c.setCommandItems(c.selected)
166+ }
167+ case key.Matches(msg, c.keyMap.ShiftTab):
168+ if len(c.customCommands) > 0 || len(c.mcpCustomCommands) > 0 {
169+ c.selected = c.previousCommandType()
170+ c.setCommandItems(c.selected)
164 }
171 }
165 default:
172 default:
166 var cmd tea.Cmd
173 var cmd tea.Cmd
174+ for _, item := range c.list.VisibleItems() {
175+ if item, ok := item.(*CommandItem); ok && item != nil {
176+ if msg.String() == item.Shortcut() {
177+ return item.Action()
178+ }
179+ }
180+ }
167 c.input, cmd = c.input.Update(msg)
181 c.input, cmd = c.input.Update(msg)
168 value := c.input.Value()
182 value := c.input.Value()
169 c.list.SetFilter(value)
183 c.list.SetFilter(value)
@@ -175,28 +189,18 @@ func (c *Commands) HandleMsg(msg tea.Msg) Action {
175 return nil
189 return nil
176}
190}
177
191
178−// ReloadMCPPrompts reloads the MCP prompts.
179−func (c *Commands) ReloadMCPPrompts() tea.Cmd {
180− c.mcpPrompts.SetSlice(uicmd.LoadMCPPrompts())
181− // If we're currently viewing MCP prompts, refresh the list
182− if c.selected == uicmd.MCPPrompts {
183− c.setCommandType(uicmd.MCPPrompts)
184− }
185− return nil
186−}
187−
188// Cursor returns the cursor position relative to the dialog.
192// Cursor returns the cursor position relative to the dialog.
189func (c *Commands) Cursor() *tea.Cursor {
193func (c *Commands) Cursor() *tea.Cursor {
190 return InputCursor(c.com.Styles, c.input.Cursor())
194 return InputCursor(c.com.Styles, c.input.Cursor())
191}
195}
192
196
193// commandsRadioView generates the command type selector radio buttons.
197// commandsRadioView generates the command type selector radio buttons.
194−func commandsRadioView(sty *styles.Styles, selected uicmd.CommandType, hasUserCmds bool, hasMCPPrompts bool) string {
198+func commandsRadioView(sty *styles.Styles, selected CommandType, hasUserCmds bool, hasMCPPrompts bool) string {
195 if !hasUserCmds && !hasMCPPrompts {
199 if !hasUserCmds && !hasMCPPrompts {
196 return ""
200 return ""
197 }
201 }
198
202
199− selectedFn := func(t uicmd.CommandType) string {
203+ selectedFn := func(t CommandType) string {
200 if t == selected {
204 if t == selected {
201 return sty.RadioOn.Padding(0, 1).Render() + sty.HalfMuted.Render(t.String())
205 return sty.RadioOn.Padding(0, 1).Render() + sty.HalfMuted.Render(t.String())
202 }
206 }
@@ -204,14 +208,14 @@ func commandsRadioView(sty *styles.Styles, selected uicmd.CommandType, hasUserCm
204 }
208 }
205
209
206 parts := []string{
210 parts := []string{
207− selectedFn(uicmd.SystemCommands),
211+ selectedFn(SystemCommands),
208 }
212 }
209
213
210 if hasUserCmds {
214 if hasUserCmds {
211− parts = append(parts, selectedFn(uicmd.UserCommands))
215+ parts = append(parts, selectedFn(UserCommands))
212 }
216 }
213 if hasMCPPrompts {
217 if hasMCPPrompts {
214− parts = append(parts, selectedFn(uicmd.MCPPrompts))
218+ parts = append(parts, selectedFn(MCPPrompts))
215 }
219 }
216
220
217 return strings.Join(parts, " ")
221 return strings.Join(parts, " ")
@@ -222,7 +226,12 @@ func (c *Commands) Draw(scr uv.Screen, area uv.Rectangle) *tea.Cursor {
222 t := c.com.Styles
226 t := c.com.Styles
223 width := max(0, min(defaultDialogMaxWidth, area.Dx()))
227 width := max(0, min(defaultDialogMaxWidth, area.Dx()))
224 height := max(0, min(defaultDialogHeight, area.Dy()))
228 height := max(0, min(defaultDialogHeight, area.Dy()))
225− c.width = width
229+ if area.Dx() != c.windowWidth && c.selected == SystemCommands {
230+ // since some items in the list depend on width (e.g. toggle sidebar command),
231+ // we need to reset the command items when width changes
232+ c.setCommandItems(c.selected)
233+ }
234+ c.windowWidth = area.Dx()
226 innerWidth := width - c.com.Styles.Dialog.View.GetHorizontalFrameSize()
235 innerWidth := width - c.com.Styles.Dialog.View.GetHorizontalFrameSize()
227 heightOffset := t.Dialog.Title.GetVerticalFrameSize() + titleContentHeight +
236 heightOffset := t.Dialog.Title.GetVerticalFrameSize() + titleContentHeight +
228 t.Dialog.InputPrompt.GetVerticalFrameSize() + inputContentHeight +
237 t.Dialog.InputPrompt.GetVerticalFrameSize() + inputContentHeight +
@@ -233,7 +242,7 @@ func (c *Commands) Draw(scr uv.Screen, area uv.Rectangle) *tea.Cursor {
233 c.list.SetSize(innerWidth, height-heightOffset)
242 c.list.SetSize(innerWidth, height-heightOffset)
234 c.help.SetWidth(innerWidth)
243 c.help.SetWidth(innerWidth)
235
244
236− radio := commandsRadioView(t, c.selected, len(c.userCmds) > 0, c.mcpPrompts.Len() > 0)
245+ radio := commandsRadioView(t, c.selected, len(c.customCommands) > 0, len(c.mcpCustomCommands) > 0)
237 titleStyle := t.Dialog.Title
246 titleStyle := t.Dialog.Title
238 dialogStyle := t.Dialog.View.Width(width)
247 dialogStyle := t.Dialog.View.Width(width)
239 headerOffset := lipgloss.Width(radio) + titleStyle.GetHorizontalFrameSize() + dialogStyle.GetHorizontalFrameSize()
248 headerOffset := lipgloss.Width(radio) + titleStyle.GetHorizontalFrameSize() + dialogStyle.GetHorizontalFrameSize()
@@ -265,99 +274,116 @@ func (c *Commands) FullHelp() [][]key.Binding {
265 }
274 }
266}
275}
267
276
277+// nextCommandType returns the next command type in the cycle.
268−func (c *Commands) nextCommandType() uicmd.CommandType {
278+func (c *Commands) nextCommandType() CommandType {
269 switch c.selected {
279 switch c.selected {
270− case uicmd.SystemCommands:
280+ case SystemCommands:
271− if len(c.userCmds) > 0 {
281+ if len(c.customCommands) > 0 {
272− return uicmd.UserCommands
282+ return UserCommands
273 }
283 }
274− if c.mcpPrompts.Len() > 0 {
284+ if len(c.mcpCustomCommands) > 0 {
275− return uicmd.MCPPrompts
285+ return MCPPrompts
276 }
286 }
277 fallthrough
287 fallthrough
278− case uicmd.UserCommands:
288+ case UserCommands:
279− if c.mcpPrompts.Len() > 0 {
289+ if len(c.mcpCustomCommands) > 0 {
280− return uicmd.MCPPrompts
290+ return MCPPrompts
281 }
291 }
282 fallthrough
292 fallthrough
283− case uicmd.MCPPrompts:
293+ case MCPPrompts:
284− return uicmd.SystemCommands
294+ return SystemCommands
285 default:
295 default:
286− return uicmd.SystemCommands
296+ return SystemCommands
287 }
297 }
288}
298}
289
299
300+// previousCommandType returns the previous command type in the cycle.
290−func (c *Commands) setCommandType(commandType uicmd.CommandType) {
301+func (c *Commands) previousCommandType() CommandType {
291− c.selected = commandType
292−
293− var commands []uicmd.Command
294 switch c.selected {
302 switch c.selected {
295− case uicmd.SystemCommands:
303+ case SystemCommands:
296− commands = c.defaultCommands()
304+ if len(c.mcpCustomCommands) > 0 {
305+ return MCPPrompts
306+ }
307+ if len(c.customCommands) > 0 {
308+ return UserCommands
309+ }
310+ return SystemCommands
297− case uicmd.UserCommands:
311+ case UserCommands:
298− commands = c.userCmds
312+ return SystemCommands
299− case uicmd.MCPPrompts:
313+ case MCPPrompts:
300− commands = slices.Collect(c.mcpPrompts.Seq())
314+ if len(c.customCommands) > 0 {
315+ return UserCommands
316+ }
317+ return SystemCommands
318+ default:
319+ return SystemCommands
301 }
320 }
321+}
322+
323+// setCommandItems sets the command items based on the specified command type.
324+func (c *Commands) setCommandItems(commandType CommandType) {
325+ c.selected = commandType
302
326
303 commandItems := []list.FilterableItem{}
327 commandItems := []list.FilterableItem{}
328+ switch c.selected {
329+ case SystemCommands:
330+ for _, cmd := range c.defaultCommands() {
331+ commandItems = append(commandItems, cmd)
332+ }
333+ case UserCommands:
304− for _, cmd := range commands {
334+ for _, cmd := range c.customCommands {
335+ var action Action
336+ if len(cmd.Arguments) > 0 {
337+ action = ActionOpenCustomCommandArgumentsDialog{
338+ CommandID: cmd.ID,
339+ Content: cmd.Content,
340+ Arguments: cmd.Arguments,
341+ }
342+ } else {
343+ action = ActionRunCustomCommand{
344+ CommandID: cmd.ID,
345+ Content: cmd.Content,
346+ }
347+ }
348+ commandItems = append(commandItems, NewCommandItem(c.com.Styles, "custom_"+cmd.ID, cmd.Name, "", action))
349+ }
350+ case MCPPrompts:
351+ for _, cmd := range c.mcpCustomCommands {
352+ var action Action
353+ if len(cmd.Arguments) > 0 {
354+ action = ActionOpenCustomCommandArgumentsDialog{
355+ CommandID: cmd.ID,
356+ Client: cmd.Client,
357+ Arguments: cmd.Arguments,
358+ }
359+ } else {
360+ action = ActionRunCustomCommand{
361+ CommandID: cmd.ID,
362+ Client: cmd.Client,
363+ }
364+ }
305− commandItems = append(commandItems, NewCommandItem(c.com.Styles, cmd))
365+ commandItems = append(commandItems, NewCommandItem(c.com.Styles, "mcp_"+cmd.ID, cmd.Name, "", action))
366+ }
306 }
367 }
307
368
308 c.list.SetItems(commandItems...)
369 c.list.SetItems(commandItems...)
309− c.list.SetSelected(0)
310 c.list.SetFilter("")
370 c.list.SetFilter("")
311 c.list.ScrollToTop()
371 c.list.ScrollToTop()
312 c.list.SetSelected(0)
372 c.list.SetSelected(0)
313 c.input.SetValue("")
373 c.input.SetValue("")
314}
374}
315
375
316−// TODO: Rethink this
376+// defaultCommands returns the list of default system commands.
317−func (c *Commands) defaultCommands() []uicmd.Command {
377+func (c *Commands) defaultCommands() []*CommandItem {
318− commands := []uicmd.Command{
378+ commands := []*CommandItem{
319− {
379+ NewCommandItem(c.com.Styles, "new_session", "New Session", "ctrl+n", ActionNewSession{}),
320− ID: "new_session",
321− Title: "New Session",
322− Description: "start a new session",
323− Shortcut: "ctrl+n",
324− Handler: func(cmd uicmd.Command) tea.Cmd {
325− return uiutil.CmdHandler(ActionNewSession{})
326− },
327− },
328− {
329− ID: "switch_session",
330− Title: "Switch Session",
331− Description: "Switch to a different session",
332− Shortcut: "ctrl+s",
333− Handler: func(cmd uicmd.Command) tea.Cmd {
334− return uiutil.CmdHandler(ActionOpenDialog{SessionsID})
380+ NewCommandItem(c.com.Styles, "switch_session", "Switch Session", "ctrl+s", ActionOpenDialog{SessionsID}),
335− },
381+ NewCommandItem(c.com.Styles, "switch_model", "Switch Model", "ctrl+l", ActionOpenDialog{ModelsID}),
336− },
337− {
338− ID: "switch_model",
339− Title: "Switch Model",
340− Description: "Switch to a different model",
341− // FIXME: The shortcut might get updated if enhanced keyboard is supported.
342− Shortcut: "ctrl+l",
343− Handler: func(cmd uicmd.Command) tea.Cmd {
344− return uiutil.CmdHandler(ActionOpenDialog{ModelsID})
345− },
346− },
347 }
382 }
348
383
349 // Only show compact command if there's an active session
384 // Only show compact command if there's an active session
350 if c.sessionID != "" {
385 if c.sessionID != "" {
351− commands = append(commands, uicmd.Command{
386+ commands = append(commands, NewCommandItem(c.com.Styles, "summarize", "Summarize Session", "", ActionSummarize{SessionID: c.sessionID}))
352− ID: "Summarize",
353− Title: "Summarize Session",
354− Description: "Summarize the current session and create a new one with the summary",
355− Handler: func(cmd uicmd.Command) tea.Cmd {
356− return uiutil.CmdHandler(ActionSummarize{
357− SessionID: c.sessionID,
358− })
359− },
360− })
361 }
387 }
362
388
363 // Add reasoning toggle for models that support it
389 // Add reasoning toggle for models that support it
@@ -374,116 +400,58 @@ func (c *Commands) defaultCommands() []uicmd.Command {
374 if selectedModel.Think {
400 if selectedModel.Think {
375 status = "Disable"
401 status = "Disable"
376 }
402 }
377− commands = append(commands, uicmd.Command{
403+ commands = append(commands, NewCommandItem(c.com.Styles, "toggle_thinking", status+" Thinking Mode", "", ActionToggleThinking{}))
378− ID: "toggle_thinking",
379− Title: status + " Thinking Mode",
380− Description: "Toggle model thinking for reasoning-capable models",
381− Handler: func(cmd uicmd.Command) tea.Cmd {
382− return uiutil.CmdHandler(ActionToggleThinking{})
383− },
384− })
385 }
404 }
386
405
387 // OpenAI models: reasoning effort dialog
406 // OpenAI models: reasoning effort dialog
388 if len(model.ReasoningLevels) > 0 {
407 if len(model.ReasoningLevels) > 0 {
389− commands = append(commands, uicmd.Command{
408+ commands = append(commands, NewCommandItem(c.com.Styles, "select_reasoning_effort", "Select Reasoning Effort", "", ActionOpenDialog{
390− ID: "select_reasoning_effort",
391− Title: "Select Reasoning Effort",
392− Description: "Choose reasoning effort level (low/medium/high)",
393− Handler: func(cmd uicmd.Command) tea.Cmd {
394− return uiutil.CmdHandler(ActionOpenDialog{
395− // TODO: Pass reasoning dialog id
409+ // TODO: Pass in the reasoning effort dialog id
396− })
397− },
398− })
410+ }))
399 }
411 }
400 }
412 }
401 }
413 }
402− // Only show toggle compact mode command if window width is larger than compact breakpoint (90)
414+ // Only show toggle compact mode command if window width is larger than compact breakpoint (120)
403− // TODO: Get. Rid. Of. Magic. Numbers!
415+ if c.windowWidth > sidebarCompactModeBreakpoint && c.sessionID != "" {
404− if c.width > 120 && c.sessionID != "" {
416+ commands = append(commands, NewCommandItem(c.com.Styles, "toggle_sidebar", "Toggle Sidebar", "", ActionToggleCompactMode{}))
405− commands = append(commands, uicmd.Command{
406− ID: "toggle_sidebar",
407− Title: "Toggle Sidebar",
408− Description: "Toggle between compact and normal layout",
409− Handler: func(cmd uicmd.Command) tea.Cmd {
410− return uiutil.CmdHandler(ActionToggleCompactMode{})
411− },
412− })
413 }
417 }
414 if c.sessionID != "" {
418 if c.sessionID != "" {
415 cfg := c.com.Config()
419 cfg := c.com.Config()
416 agentCfg := cfg.Agents[config.AgentCoder]
420 agentCfg := cfg.Agents[config.AgentCoder]
417 model := cfg.GetModelByType(agentCfg.Model)
421 model := cfg.GetModelByType(agentCfg.Model)
418 if model != nil && model.SupportsImages {
422 if model != nil && model.SupportsImages {
419− commands = append(commands, uicmd.Command{
423+ commands = append(commands, NewCommandItem(c.com.Styles, "file_picker", "Open File Picker", "ctrl+f", ActionOpenDialog{
420− ID: "file_picker",
421− Title: "Open File Picker",
422− Shortcut: "ctrl+f",
423− Description: "Open file picker",
424− Handler: func(cmd uicmd.Command) tea.Cmd {
425− return uiutil.CmdHandler(ActionOpenDialog{
426− // TODO: Pass file picker dialog id
424+ // TODO: Pass in the file picker dialog id
427− })
428− },
429− })
425+ }))
430 }
426 }
431 }
427 }
432
428
433 // Add external editor command if $EDITOR is available
429 // Add external editor command if $EDITOR is available
434 // TODO: Use [tea.EnvMsg] to get environment variable instead of os.Getenv
430 // TODO: Use [tea.EnvMsg] to get environment variable instead of os.Getenv
435 if os.Getenv("EDITOR") != "" {
431 if os.Getenv("EDITOR") != "" {
436− commands = append(commands, uicmd.Command{
432+ commands = append(commands, NewCommandItem(c.com.Styles, "open_external_editor", "Open External Editor", "ctrl+o", ActionExternalEditor{}))
437− ID: "open_external_editor",
438− Title: "Open External Editor",
439− Shortcut: "ctrl+o",
440− Description: "Open external editor to compose message",
441− Handler: func(cmd uicmd.Command) tea.Cmd {
442− return uiutil.CmdHandler(ActionExternalEditor{})
443− },
444− })
445 }
433 }
446
434
447− return append(commands, []uicmd.Command{
435+ return append(commands,
448− {
436+ NewCommandItem(c.com.Styles, "toggle_yolo", "Toggle Yolo Mode", "", ActionToggleYoloMode{}),
449− ID: "toggle_yolo",
437+ NewCommandItem(c.com.Styles, "toggle_help", "Toggle Help", "ctrl+g", ActionToggleHelp{}),
450− Title: "Toggle Yolo Mode",
438+ NewCommandItem(c.com.Styles, "init", "Initialize Project", "", ActionInitializeProject{}),
451− Description: "Toggle yolo mode",
439+ NewCommandItem(c.com.Styles, "quit", "Quit", "ctrl+c", tea.QuitMsg{}),
452− Handler: func(cmd uicmd.Command) tea.Cmd {
440+ )
453− return uiutil.CmdHandler(ActionToggleYoloMode{})
454− },
455− },
456− {
457− ID: "toggle_help",
458− Title: "Toggle Help",
459− Shortcut: "ctrl+g",
460− Description: "Toggle help",
461− Handler: func(cmd uicmd.Command) tea.Cmd {
462− return uiutil.CmdHandler(ActionToggleHelp{})
463− },
464− },
465− {
466− ID: "init",
467− Title: "Initialize Project",
468− Description: fmt.Sprintf("Create/Update the %s memory file", config.Get().Options.InitializeAs),
469− Handler: func(cmd uicmd.Command) tea.Cmd {
470− initPrompt, err := agent.InitializePrompt(*c.com.Config())
471− if err != nil {
472− return uiutil.ReportError(err)
473− }
474− return uiutil.CmdHandler(chat.SendMsg{
475− Text: initPrompt,
476− })
477− },
478− },
479− {
480− ID: "quit",
481− Title: "Quit",
482− Description: "Quit",
483− Shortcut: "ctrl+c",
484− Handler: func(cmd uicmd.Command) tea.Cmd {
485− return uiutil.CmdHandler(tea.QuitMsg{})
486− },
441+}
487− },
442+
488− }...)
443+// SetCustomCommands sets the custom commands and refreshes the view if user commands are currently displayed.
444+func (c *Commands) SetCustomCommands(customCommands []commands.CustomCommand) {
445+ c.customCommands = customCommands
446+ if c.selected == UserCommands {
447+ c.setCommandItems(c.selected)
448+ }
449+}
450+
451+// SetMCPCustomCommands sets the MCP custom commands and refreshes the view if MCP prompts are currently displayed.
452+func (c *Commands) SetMCPCustomCommands(mcpCustomCommands []commands.MCPCustomCommand) {
453+ c.mcpCustomCommands = mcpCustomCommands
454+ if c.selected == MCPPrompts {
455+ c.setCommandItems(c.selected)
456+ }
489}
457}
internal/ui/dialog/commands_item.go+27−12
@@ -2,37 +2,42 @@ package dialog
2
2
3import (
3import (
4 "github.com/charmbracelet/crush/internal/ui/styles"
4 "github.com/charmbracelet/crush/internal/ui/styles"
5− "github.com/charmbracelet/crush/internal/uicmd"
6 "github.com/sahilm/fuzzy"
5 "github.com/sahilm/fuzzy"
7)
6)
8
7
9// CommandItem wraps a uicmd.Command to implement the ListItem interface.
8// CommandItem wraps a uicmd.Command to implement the ListItem interface.
10type CommandItem struct {
9type CommandItem struct {
11− Cmd uicmd.Command
10+ id string
11+ title string
12+ shortcut string
13+ action Action
12− t *styles.Styles
14+ t *styles.Styles
13− m fuzzy.Match
15+ m fuzzy.Match
14− cache map[int]string
16+ cache map[int]string
15− focused bool
17+ focused bool
16}
18}
17
19
18var _ ListItem = &CommandItem{}
20var _ ListItem = &CommandItem{}
19
21
20// NewCommandItem creates a new CommandItem.
22// NewCommandItem creates a new CommandItem.
21−func NewCommandItem(t *styles.Styles, cmd uicmd.Command) *CommandItem {
23+func NewCommandItem(t *styles.Styles, id, title, shortcut string, action Action) *CommandItem {
22 return &CommandItem{
24 return &CommandItem{
23− Cmd: cmd,
25+ id: id,
24− t: t,
26+ t: t,
27+ title: title,
28+ shortcut: shortcut,
29+ action: action,
25 }
30 }
26}
31}
27
32
28// Filter implements ListItem.
33// Filter implements ListItem.
29func (c *CommandItem) Filter() string {
34func (c *CommandItem) Filter() string {
30− return c.Cmd.Title
35+ return c.title
31}
36}
32
37
33// ID implements ListItem.
38// ID implements ListItem.
34func (c *CommandItem) ID() string {
39func (c *CommandItem) ID() string {
35− return c.Cmd.ID
40+ return c.id
36}
41}
37
42
38// SetFocused implements ListItem.
43// SetFocused implements ListItem.
@@ -49,7 +54,17 @@ func (c *CommandItem) SetMatch(m fuzzy.Match) {
49 c.m = m
54 c.m = m
50}
55}
51
56
57+// Action returns the action associated with the command item.
58+func (c *CommandItem) Action() Action {
59+ return c.action
60+}
61+
62+// Shortcut returns the shortcut associated with the command item.
63+func (c *CommandItem) Shortcut() string {
64+ return c.shortcut
65+}
66+
52// Render implements ListItem.
67// Render implements ListItem.
53func (c *CommandItem) Render(width int) string {
68func (c *CommandItem) Render(width int) string {
54− return renderItem(c.t, c.Cmd.Title, c.Cmd.Shortcut, c.focused, width, c.cache, &c.m)
69+ return renderItem(c.t, c.title, c.shortcut, c.focused, width, c.cache, &c.m)
55}
70}
internal/ui/model/ui.go+85−12
@@ -5,6 +5,7 @@ import (
5 "errors"
5 "errors"
6 "fmt"
6 "fmt"
7 "image"
7 "image"
8+ "log/slog"
8 "math/rand"
9 "math/rand"
9 "net/http"
10 "net/http"
10 "os"
11 "os"
@@ -23,6 +24,7 @@ import (
23 "github.com/charmbracelet/catwalk/pkg/catwalk"
24 "github.com/charmbracelet/catwalk/pkg/catwalk"
24 "github.com/charmbracelet/crush/internal/agent/tools/mcp"
25 "github.com/charmbracelet/crush/internal/agent/tools/mcp"
25 "github.com/charmbracelet/crush/internal/app"
26 "github.com/charmbracelet/crush/internal/app"
27+ "github.com/charmbracelet/crush/internal/commands"
26 "github.com/charmbracelet/crush/internal/config"
28 "github.com/charmbracelet/crush/internal/config"
27 "github.com/charmbracelet/crush/internal/filetracker"
29 "github.com/charmbracelet/crush/internal/filetracker"
28 "github.com/charmbracelet/crush/internal/history"
30 "github.com/charmbracelet/crush/internal/history"
@@ -76,7 +78,18 @@ type openEditorMsg struct {
76 Text string
78 Text string
77}
79}
78
80
81+type (
82+ // cancelTimerExpiredMsg is sent when the cancel timer expires.
79−type cancelTimerExpiredMsg struct{}
83+ cancelTimerExpiredMsg struct{}
84+ // userCommandsLoadedMsg is sent when user commands are loaded.
85+ userCommandsLoadedMsg struct {
86+ Commands []commands.CustomCommand
87+ }
88+ // mcpCustomCommandsLoadedMsg is sent when mcp prompts are loaded.
89+ mcpCustomCommandsLoadedMsg struct {
90+ Prompts []commands.MCPCustomCommand
91+ }
92+)
80
93
81// UI represents the main user interface model.
94// UI represents the main user interface model.
82type UI struct {
95type UI struct {
@@ -144,6 +157,10 @@ type UI struct {
144
157
145 // sidebarLogo keeps a cached version of the sidebar sidebarLogo.
158 // sidebarLogo keeps a cached version of the sidebar sidebarLogo.
146 sidebarLogo string
159 sidebarLogo string
160+
161+ // custom commands & mcp commands
162+ customCommands []commands.CustomCommand
163+ mcpCustomCommands []commands.MCPCustomCommand
147}
164}
148
165
149// New creates a new instance of the [UI] model.
166// New creates a new instance of the [UI] model.
@@ -225,9 +242,37 @@ func (m *UI) Init() tea.Cmd {
225 if m.QueryVersion {
242 if m.QueryVersion {
226 cmds = append(cmds, tea.RequestTerminalVersion)
243 cmds = append(cmds, tea.RequestTerminalVersion)
227 }
244 }
245+ // load the user commands async
246+ cmds = append(cmds, m.loadCustomCommands())
228 return tea.Batch(cmds...)
247 return tea.Batch(cmds...)
229}
248}
230
249
250+// loadCustomCommands loads the custom commands asynchronously.
251+func (m *UI) loadCustomCommands() tea.Cmd {
252+ return func() tea.Msg {
253+ customCommands, err := commands.LoadCustomCommands(m.com.Config())
254+ if err != nil {
255+ slog.Error("failed to load custom commands", "error", err)
256+ }
257+ return userCommandsLoadedMsg{Commands: customCommands}
258+ }
259+}
260+
261+// loadMCPrompts loads the MCP prompts asynchronously.
262+func (m *UI) loadMCPrompts() tea.Cmd {
263+ return func() tea.Msg {
264+ prompts, err := commands.LoadMCPCustomCommands()
265+ if err != nil {
266+ slog.Error("failed to load mcp prompts", "error", err)
267+ }
268+ if prompts == nil {
269+ // flag them as loaded even if there is none or an error
270+ prompts = []commands.MCPCustomCommand{}
271+ }
272+ return mcpCustomCommandsLoadedMsg{Prompts: prompts}
273+ }
274+}
275+
231// Update handles updates to the UI model.
276// Update handles updates to the UI model.
232func (m *UI) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
277func (m *UI) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
233 var cmds []tea.Cmd
278 var cmds []tea.Cmd
@@ -250,6 +295,29 @@ func (m *UI) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
250 cmds = append(cmds, cmd)
295 cmds = append(cmds, cmd)
251 }
296 }
252
297
298+ case userCommandsLoadedMsg:
299+ m.customCommands = msg.Commands
300+ dia := m.dialog.Dialog(dialog.CommandsID)
301+ if dia == nil {
302+ break
303+ }
304+
305+ commands, ok := dia.(*dialog.Commands)
306+ if ok {
307+ commands.SetCustomCommands(m.customCommands)
308+ }
309+ case mcpCustomCommandsLoadedMsg:
310+ m.mcpCustomCommands = msg.Prompts
311+ dia := m.dialog.Dialog(dialog.CommandsID)
312+ if dia == nil {
313+ break
314+ }
315+
316+ commands, ok := dia.(*dialog.Commands)
317+ if ok {
318+ commands.SetMCPCustomCommands(m.mcpCustomCommands)
319+ }
320+
253 case pubsub.Event[message.Message]:
321 case pubsub.Event[message.Message]:
254 // Check if this is a child session message for an agent tool.
322 // Check if this is a child session message for an agent tool.
255 if m.session == nil {
323 if m.session == nil {
@@ -274,18 +342,16 @@ func (m *UI) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
274 m.lspStates = app.GetLSPStates()
342 m.lspStates = app.GetLSPStates()
275 case pubsub.Event[mcp.Event]:
343 case pubsub.Event[mcp.Event]:
276 m.mcpStates = mcp.GetStates()
344 m.mcpStates = mcp.GetStates()
277− if msg.Type == pubsub.UpdatedEvent && m.dialog.ContainsDialog(dialog.CommandsID) {
345+ // check if all mcps are initialized
278− dia := m.dialog.Dialog(dialog.CommandsID)
346+ initialized := true
279− if dia == nil {
347+ for _, state := range m.mcpStates {
348+ if state.State == mcp.StateStarting {
349+ initialized = false
280 break
350 break
281 }
351 }
282−
352+ }
283− commands, ok := dia.(*dialog.Commands)
353+ if initialized && m.mcpCustomCommands == nil {
284− if ok {
285− if cmd := commands.ReloadMCPPrompts(); cmd != nil {
286− cmds = append(cmds, cmd)
354+ cmds = append(cmds, m.loadMCPrompts())
287− }
288− }
289 }
355 }
290 case pubsub.Event[permission.PermissionRequest]:
356 case pubsub.Event[permission.PermissionRequest]:
291 if cmd := m.openPermissionsDialog(msg.Payload); cmd != nil {
357 if cmd := m.openPermissionsDialog(msg.Payload); cmd != nil {
@@ -776,6 +842,13 @@ func (m *UI) handleDialogMsg(msg tea.Msg) tea.Cmd {
776 m.dialog.CloseDialog(dialog.CommandsID)
842 m.dialog.CloseDialog(dialog.CommandsID)
777 case dialog.ActionQuit:
843 case dialog.ActionQuit:
778 cmds = append(cmds, tea.Quit)
844 cmds = append(cmds, tea.Quit)
845+ case dialog.ActionInitializeProject:
846+ if m.com.App.AgentCoordinator != nil && m.com.App.AgentCoordinator.IsBusy() {
847+ cmds = append(cmds, uiutil.ReportWarn("Agent is busy, please wait before summarizing session..."))
848+ break
849+ }
850+ cmds = append(cmds, m.initializeProject())
851+
779 case dialog.ActionSelectModel:
852 case dialog.ActionSelectModel:
780 if m.com.App.AgentCoordinator.IsBusy() {
853 if m.com.App.AgentCoordinator.IsBusy() {
781 cmds = append(cmds, uiutil.ReportWarn("Agent is busy, please wait..."))
854 cmds = append(cmds, uiutil.ReportWarn("Agent is busy, please wait..."))
@@ -2001,7 +2074,7 @@ func (m *UI) openCommandsDialog() tea.Cmd {
2001 sessionID = m.session.ID
2074 sessionID = m.session.ID
2002 }
2075 }
2003
2076
2004− commands, err := dialog.NewCommands(m.com, sessionID)
2077+ commands, err := dialog.NewCommands(m.com, sessionID, m.customCommands, m.mcpCustomCommands)
2005 if err != nil {
2078 if err != nil {
2006 return uiutil.ReportError(err)
2079 return uiutil.ReportError(err)
2007 }
2080 }
internal/uicmd/uicmd.go+1
@@ -1,6 +1,7 @@
1// Package uicmd provides functionality to load and handle custom commands
1// Package uicmd provides functionality to load and handle custom commands
2// from markdown files and MCP prompts.
2// from markdown files and MCP prompts.
3// TODO: Move this into internal/ui after refactoring.
3// TODO: Move this into internal/ui after refactoring.
4+// TODO: DELETE when we delete the old tui
4package uicmd
5package uicmd
5
6
6import (
7import (