1package tui
2
3import (
4 "context"
5 "fmt"
6 "math/rand"
7 "strings"
8 "time"
9
10 "github.com/charmbracelet/bubbles/v2/key"
11 tea "github.com/charmbracelet/bubbletea/v2"
12 "github.com/charmbracelet/crush/internal/app"
13 "github.com/charmbracelet/crush/internal/config"
14 "github.com/charmbracelet/crush/internal/event"
15 "github.com/charmbracelet/crush/internal/llm/agent"
16 "github.com/charmbracelet/crush/internal/permission"
17 "github.com/charmbracelet/crush/internal/pubsub"
18 cmpChat "github.com/charmbracelet/crush/internal/tui/components/chat"
19 "github.com/charmbracelet/crush/internal/tui/components/chat/splash"
20 "github.com/charmbracelet/crush/internal/tui/components/completions"
21 "github.com/charmbracelet/crush/internal/tui/components/core"
22 "github.com/charmbracelet/crush/internal/tui/components/core/layout"
23 "github.com/charmbracelet/crush/internal/tui/components/core/status"
24 "github.com/charmbracelet/crush/internal/tui/components/dialogs"
25 "github.com/charmbracelet/crush/internal/tui/components/dialogs/commands"
26 "github.com/charmbracelet/crush/internal/tui/components/dialogs/compact"
27 "github.com/charmbracelet/crush/internal/tui/components/dialogs/filepicker"
28 "github.com/charmbracelet/crush/internal/tui/components/dialogs/models"
29 "github.com/charmbracelet/crush/internal/tui/components/dialogs/permissions"
30 "github.com/charmbracelet/crush/internal/tui/components/dialogs/quit"
31 "github.com/charmbracelet/crush/internal/tui/components/dialogs/sessions"
32 "github.com/charmbracelet/crush/internal/tui/page"
33 "github.com/charmbracelet/crush/internal/tui/page/chat"
34 "github.com/charmbracelet/crush/internal/tui/styles"
35 "github.com/charmbracelet/crush/internal/tui/util"
36 "github.com/charmbracelet/lipgloss/v2"
37 "golang.org/x/text/cases"
38 "golang.org/x/text/language"
39)
40
41var lastMouseEvent time.Time
42
43func MouseEventFilter(m tea.Model, msg tea.Msg) tea.Msg {
44 switch msg.(type) {
45 case tea.MouseWheelMsg, tea.MouseMotionMsg:
46 now := time.Now()
47 // trackpad is sending too many requests
48 if now.Sub(lastMouseEvent) < 15*time.Millisecond {
49 return nil
50 }
51 lastMouseEvent = now
52 }
53 return msg
54}
55
56// appModel represents the main application model that manages pages, dialogs, and UI state.
57type appModel struct {
58 wWidth, wHeight int // Window dimensions
59 width, height int
60 keyMap KeyMap
61
62 currentPage page.PageID
63 previousPage page.PageID
64 pages map[page.PageID]util.Model
65 loadedPages map[page.PageID]bool
66
67 // Status
68 status status.StatusCmp
69 showingFullHelp bool
70
71 app *app.App
72
73 dialog dialogs.DialogCmp
74 completions completions.Completions
75 isConfigured bool
76
77 // Chat Page Specific
78 selectedSessionID string // The ID of the currently selected session
79}
80
81// Init initializes the application model and returns initial commands.
82func (a appModel) Init() tea.Cmd {
83 item, ok := a.pages[a.currentPage]
84 if !ok {
85 return nil
86 }
87
88 var cmds []tea.Cmd
89 cmd := item.Init()
90 cmds = append(cmds, cmd)
91 a.loadedPages[a.currentPage] = true
92
93 cmd = a.status.Init()
94 cmds = append(cmds, cmd)
95
96 cmds = append(cmds, tea.EnableMouseAllMotion)
97
98 return tea.Batch(cmds...)
99}
100
101// Update handles incoming messages and updates the application state.
102func (a *appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
103 var cmds []tea.Cmd
104 var cmd tea.Cmd
105 a.isConfigured = config.HasInitialDataConfig()
106
107 switch msg := msg.(type) {
108 case tea.KeyboardEnhancementsMsg:
109 for id, page := range a.pages {
110 m, pageCmd := page.Update(msg)
111 if model, ok := m.(util.Model); ok {
112 a.pages[id] = model
113 }
114
115 if pageCmd != nil {
116 cmds = append(cmds, pageCmd)
117 }
118 }
119 return a, tea.Batch(cmds...)
120 case tea.WindowSizeMsg:
121 a.wWidth, a.wHeight = msg.Width, msg.Height
122 a.completions.Update(msg)
123 return a, a.handleWindowResize(msg.Width, msg.Height)
124
125 // Completions messages
126 case completions.OpenCompletionsMsg, completions.FilterCompletionsMsg,
127 completions.CloseCompletionsMsg, completions.RepositionCompletionsMsg:
128 u, completionCmd := a.completions.Update(msg)
129 if model, ok := u.(completions.Completions); ok {
130 a.completions = model
131 }
132
133 return a, completionCmd
134
135 // Dialog messages
136 case dialogs.OpenDialogMsg, dialogs.CloseDialogMsg:
137 u, completionCmd := a.completions.Update(completions.CloseCompletionsMsg{})
138 a.completions = u.(completions.Completions)
139 u, dialogCmd := a.dialog.Update(msg)
140 a.dialog = u.(dialogs.DialogCmp)
141 return a, tea.Batch(completionCmd, dialogCmd)
142 case commands.ShowArgumentsDialogMsg:
143 var args []commands.Argument
144 for _, arg := range msg.ArgNames {
145 args = append(args, commands.Argument{
146 Name: arg,
147 Title: cases.Title(language.English).String(arg),
148 Required: true,
149 })
150 }
151 return a, util.CmdHandler(
152 dialogs.OpenDialogMsg{
153 Model: commands.NewCommandArgumentsDialog(
154 msg.CommandID,
155 msg.CommandID,
156 msg.CommandID,
157 msg.Description,
158 args,
159 func(args map[string]string) tea.Cmd {
160 return func() tea.Msg {
161 content := msg.Content
162 for _, name := range msg.ArgNames {
163 value := args[name]
164 placeholder := "$" + name
165 content = strings.ReplaceAll(content, placeholder, value)
166 }
167 return commands.CommandRunCustomMsg{
168 Content: content,
169 }
170 }
171 },
172 ),
173 },
174 )
175 case commands.ShowMCPPromptArgumentsDialogMsg:
176 args := make([]commands.Argument, 0, len(msg.Prompt.Arguments))
177 for _, arg := range msg.Prompt.Arguments {
178 args = append(args, commands.Argument(*arg))
179 }
180 dialog := commands.NewCommandArgumentsDialog(
181 msg.Prompt.Name,
182 msg.Prompt.Title,
183 msg.Prompt.Name,
184 msg.Prompt.Description,
185 args,
186 msg.OnSubmit,
187 )
188 return a, util.CmdHandler(
189 dialogs.OpenDialogMsg{
190 Model: dialog,
191 },
192 )
193 // Page change messages
194 case page.PageChangeMsg:
195 return a, a.moveToPage(msg.ID)
196
197 // Status Messages
198 case util.InfoMsg, util.ClearStatusMsg:
199 s, statusCmd := a.status.Update(msg)
200 a.status = s.(status.StatusCmp)
201 cmds = append(cmds, statusCmd)
202 return a, tea.Batch(cmds...)
203
204 // Session
205 case cmpChat.SessionSelectedMsg:
206 a.selectedSessionID = msg.ID
207 case cmpChat.SessionClearedMsg:
208 a.selectedSessionID = ""
209 // Commands
210 case commands.SwitchSessionsMsg:
211 return a, func() tea.Msg {
212 allSessions, _ := a.app.Sessions.List(context.Background())
213 return dialogs.OpenDialogMsg{
214 Model: sessions.NewSessionDialogCmp(allSessions, a.selectedSessionID),
215 }
216 }
217
218 case commands.SwitchModelMsg:
219 return a, util.CmdHandler(
220 dialogs.OpenDialogMsg{
221 Model: models.NewModelDialogCmp(),
222 },
223 )
224 // Compact
225 case commands.CompactMsg:
226 return a, util.CmdHandler(dialogs.OpenDialogMsg{
227 Model: compact.NewCompactDialogCmp(a.app.CoderAgent, msg.SessionID, true),
228 })
229 case commands.QuitMsg:
230 return a, util.CmdHandler(dialogs.OpenDialogMsg{
231 Model: quit.NewQuitDialog(),
232 })
233 case commands.ToggleYoloModeMsg:
234 a.app.Permissions.SetSkipRequests(!a.app.Permissions.SkipRequests())
235 case commands.ToggleHelpMsg:
236 a.status.ToggleFullHelp()
237 a.showingFullHelp = !a.showingFullHelp
238 return a, a.handleWindowResize(a.wWidth, a.wHeight)
239 // Model Switch
240 case models.ModelSelectedMsg:
241 if a.app.CoderAgent.IsBusy() {
242 return a, util.ReportWarn("Agent is busy, please wait...")
243 }
244
245 config.Get().UpdatePreferredModel(msg.ModelType, msg.Model)
246
247 // Update the agent with the new model/provider configuration
248 if err := a.app.UpdateAgentModel(); err != nil {
249 return a, util.ReportError(fmt.Errorf("model changed to %s but failed to update agent: %v", msg.Model.Model, err))
250 }
251
252 modelTypeName := "large"
253 if msg.ModelType == config.SelectedModelTypeSmall {
254 modelTypeName = "small"
255 }
256 return a, util.ReportInfo(fmt.Sprintf("%s model changed to %s", modelTypeName, msg.Model.Model))
257
258 // File Picker
259 case commands.OpenFilePickerMsg:
260 event.FilePickerOpened()
261
262 if a.dialog.ActiveDialogID() == filepicker.FilePickerID {
263 // If the commands dialog is already open, close it
264 return a, util.CmdHandler(dialogs.CloseDialogMsg{})
265 }
266 return a, util.CmdHandler(dialogs.OpenDialogMsg{
267 Model: filepicker.NewFilePickerCmp(a.app.Config().WorkingDir()),
268 })
269 // Permissions
270 case pubsub.Event[permission.PermissionNotification]:
271 item, ok := a.pages[a.currentPage]
272 if !ok {
273 return a, nil
274 }
275
276 // Forward to view.
277 updated, itemCmd := item.Update(msg)
278 if model, ok := updated.(util.Model); ok {
279 a.pages[a.currentPage] = model
280 }
281
282 return a, itemCmd
283 case pubsub.Event[permission.PermissionRequest]:
284 return a, util.CmdHandler(dialogs.OpenDialogMsg{
285 Model: permissions.NewPermissionDialogCmp(msg.Payload, &permissions.Options{
286 DiffMode: config.Get().Options.TUI.DiffMode,
287 }),
288 })
289 case permissions.PermissionResponseMsg:
290 switch msg.Action {
291 case permissions.PermissionAllow:
292 a.app.Permissions.Grant(msg.Permission)
293 case permissions.PermissionAllowForSession:
294 a.app.Permissions.GrantPersistent(msg.Permission)
295 case permissions.PermissionDeny:
296 a.app.Permissions.Deny(msg.Permission)
297 }
298 return a, nil
299 // Agent Events
300 case pubsub.Event[agent.AgentEvent]:
301 payload := msg.Payload
302
303 // Forward agent events to dialogs
304 if a.dialog.HasDialogs() && a.dialog.ActiveDialogID() == compact.CompactDialogID {
305 u, dialogCmd := a.dialog.Update(payload)
306 if model, ok := u.(dialogs.DialogCmp); ok {
307 a.dialog = model
308 }
309
310 cmds = append(cmds, dialogCmd)
311 }
312
313 // Handle auto-compact logic
314 if payload.Done && payload.Type == agent.AgentEventTypeResponse && a.selectedSessionID != "" {
315 // Get current session to check token usage
316 session, err := a.app.Sessions.Get(context.Background(), a.selectedSessionID)
317 if err == nil {
318 model := a.app.CoderAgent.Model()
319 contextWindow := model.ContextWindow
320 tokens := session.CompletionTokens + session.PromptTokens
321 if (tokens >= int64(float64(contextWindow)*0.95)) && !config.Get().Options.DisableAutoSummarize { // Show compact confirmation dialog
322 cmds = append(cmds, util.CmdHandler(dialogs.OpenDialogMsg{
323 Model: compact.NewCompactDialogCmp(a.app.CoderAgent, a.selectedSessionID, false),
324 }))
325 }
326 }
327 }
328
329 return a, tea.Batch(cmds...)
330 case splash.OnboardingCompleteMsg:
331 item, ok := a.pages[a.currentPage]
332 if !ok {
333 return a, nil
334 }
335
336 a.isConfigured = config.HasInitialDataConfig()
337 updated, pageCmd := item.Update(msg)
338 if model, ok := updated.(util.Model); ok {
339 a.pages[a.currentPage] = model
340 }
341
342 cmds = append(cmds, pageCmd)
343 return a, tea.Batch(cmds...)
344
345 case tea.KeyPressMsg:
346 return a, a.handleKeyPressMsg(msg)
347
348 case tea.MouseWheelMsg:
349 if a.dialog.HasDialogs() {
350 u, dialogCmd := a.dialog.Update(msg)
351 a.dialog = u.(dialogs.DialogCmp)
352 cmds = append(cmds, dialogCmd)
353 } else {
354 item, ok := a.pages[a.currentPage]
355 if !ok {
356 return a, nil
357 }
358
359 updated, pageCmd := item.Update(msg)
360 if model, ok := updated.(util.Model); ok {
361 a.pages[a.currentPage] = model
362 }
363
364 cmds = append(cmds, pageCmd)
365 }
366 return a, tea.Batch(cmds...)
367 case tea.PasteMsg:
368 if a.dialog.HasDialogs() {
369 u, dialogCmd := a.dialog.Update(msg)
370 if model, ok := u.(dialogs.DialogCmp); ok {
371 a.dialog = model
372 }
373
374 cmds = append(cmds, dialogCmd)
375 } else {
376 item, ok := a.pages[a.currentPage]
377 if !ok {
378 return a, nil
379 }
380
381 updated, pageCmd := item.Update(msg)
382 if model, ok := updated.(util.Model); ok {
383 a.pages[a.currentPage] = model
384 }
385
386 cmds = append(cmds, pageCmd)
387 }
388 return a, tea.Batch(cmds...)
389 }
390 s, _ := a.status.Update(msg)
391 a.status = s.(status.StatusCmp)
392
393 item, ok := a.pages[a.currentPage]
394 if !ok {
395 return a, nil
396 }
397
398 updated, cmd := item.Update(msg)
399 if model, ok := updated.(util.Model); ok {
400 a.pages[a.currentPage] = model
401 }
402
403 if a.dialog.HasDialogs() {
404 u, dialogCmd := a.dialog.Update(msg)
405 if model, ok := u.(dialogs.DialogCmp); ok {
406 a.dialog = model
407 }
408
409 cmds = append(cmds, dialogCmd)
410 }
411 cmds = append(cmds, cmd)
412 return a, tea.Batch(cmds...)
413}
414
415// handleWindowResize processes window resize events and updates all components.
416func (a *appModel) handleWindowResize(width, height int) tea.Cmd {
417 var cmds []tea.Cmd
418
419 // TODO: clean up these magic numbers.
420 if a.showingFullHelp {
421 height -= 5
422 } else {
423 height -= 2
424 }
425
426 a.width, a.height = width, height
427 // Update status bar
428 s, cmd := a.status.Update(tea.WindowSizeMsg{Width: width, Height: height})
429 if model, ok := s.(status.StatusCmp); ok {
430 a.status = model
431 }
432 cmds = append(cmds, cmd)
433
434 // Update the current view.
435 for p, page := range a.pages {
436 updated, pageCmd := page.Update(tea.WindowSizeMsg{Width: width, Height: height})
437 if model, ok := updated.(util.Model); ok {
438 a.pages[p] = model
439 }
440
441 cmds = append(cmds, pageCmd)
442 }
443
444 // Update the dialogs
445 dialog, cmd := a.dialog.Update(tea.WindowSizeMsg{Width: width, Height: height})
446 if model, ok := dialog.(dialogs.DialogCmp); ok {
447 a.dialog = model
448 }
449
450 cmds = append(cmds, cmd)
451
452 return tea.Batch(cmds...)
453}
454
455// handleKeyPressMsg processes keyboard input and routes to appropriate handlers.
456func (a *appModel) handleKeyPressMsg(msg tea.KeyPressMsg) tea.Cmd {
457 // Check this first as the user should be able to quit no matter what.
458 if key.Matches(msg, a.keyMap.Quit) {
459 if a.dialog.ActiveDialogID() == quit.QuitDialogID {
460 return tea.Quit
461 }
462 return util.CmdHandler(dialogs.OpenDialogMsg{
463 Model: quit.NewQuitDialog(),
464 })
465 }
466
467 if a.completions.Open() {
468 // completions
469 keyMap := a.completions.KeyMap()
470 switch {
471 case key.Matches(msg, keyMap.Up), key.Matches(msg, keyMap.Down),
472 key.Matches(msg, keyMap.Select), key.Matches(msg, keyMap.Cancel),
473 key.Matches(msg, keyMap.UpInsert), key.Matches(msg, keyMap.DownInsert):
474 u, cmd := a.completions.Update(msg)
475 a.completions = u.(completions.Completions)
476 return cmd
477 }
478 }
479 if a.dialog.HasDialogs() {
480 u, dialogCmd := a.dialog.Update(msg)
481 a.dialog = u.(dialogs.DialogCmp)
482 return dialogCmd
483 }
484 switch {
485 // help
486 case key.Matches(msg, a.keyMap.Help):
487 a.status.ToggleFullHelp()
488 a.showingFullHelp = !a.showingFullHelp
489 return a.handleWindowResize(a.wWidth, a.wHeight)
490 // dialogs
491 case key.Matches(msg, a.keyMap.Commands):
492 // if the app is not configured show no commands
493 if !a.isConfigured {
494 return nil
495 }
496 if a.dialog.ActiveDialogID() == commands.CommandsDialogID {
497 return util.CmdHandler(dialogs.CloseDialogMsg{})
498 }
499 if a.dialog.HasDialogs() {
500 return nil
501 }
502 return util.CmdHandler(dialogs.OpenDialogMsg{
503 Model: commands.NewCommandDialog(a.selectedSessionID),
504 })
505 case key.Matches(msg, a.keyMap.Sessions):
506 // if the app is not configured show no sessions
507 if !a.isConfigured {
508 return nil
509 }
510 if a.dialog.ActiveDialogID() == sessions.SessionsDialogID {
511 return util.CmdHandler(dialogs.CloseDialogMsg{})
512 }
513 if a.dialog.HasDialogs() && a.dialog.ActiveDialogID() != commands.CommandsDialogID {
514 return nil
515 }
516 var cmds []tea.Cmd
517 if a.dialog.ActiveDialogID() == commands.CommandsDialogID {
518 // If the commands dialog is open, close it first
519 cmds = append(cmds, util.CmdHandler(dialogs.CloseDialogMsg{}))
520 }
521 cmds = append(cmds,
522 func() tea.Msg {
523 allSessions, _ := a.app.Sessions.List(context.Background())
524 return dialogs.OpenDialogMsg{
525 Model: sessions.NewSessionDialogCmp(allSessions, a.selectedSessionID),
526 }
527 },
528 )
529 return tea.Sequence(cmds...)
530 case key.Matches(msg, a.keyMap.Suspend):
531 if a.app.CoderAgent != nil && a.app.CoderAgent.IsBusy() {
532 return util.ReportWarn("Agent is busy, please wait...")
533 }
534 return tea.Suspend
535 default:
536 item, ok := a.pages[a.currentPage]
537 if !ok {
538 return nil
539 }
540
541 updated, cmd := item.Update(msg)
542 if model, ok := updated.(util.Model); ok {
543 a.pages[a.currentPage] = model
544 }
545 return cmd
546 }
547}
548
549// moveToPage handles navigation between different pages in the application.
550func (a *appModel) moveToPage(pageID page.PageID) tea.Cmd {
551 if a.app.CoderAgent.IsBusy() {
552 // TODO: maybe remove this : For now we don't move to any page if the agent is busy
553 return util.ReportWarn("Agent is busy, please wait...")
554 }
555
556 var cmds []tea.Cmd
557 if _, ok := a.loadedPages[pageID]; !ok {
558 cmd := a.pages[pageID].Init()
559 cmds = append(cmds, cmd)
560 a.loadedPages[pageID] = true
561 }
562 a.previousPage = a.currentPage
563 a.currentPage = pageID
564 if sizable, ok := a.pages[a.currentPage].(layout.Sizeable); ok {
565 cmd := sizable.SetSize(a.width, a.height)
566 cmds = append(cmds, cmd)
567 }
568
569 return tea.Batch(cmds...)
570}
571
572// View renders the complete application interface including pages, dialogs, and overlays.
573func (a *appModel) View() tea.View {
574 var view tea.View
575 t := styles.CurrentTheme()
576 view.BackgroundColor = t.BgBase
577 if a.wWidth < 25 || a.wHeight < 15 {
578 view.Layer = lipgloss.NewCanvas(
579 lipgloss.NewLayer(
580 t.S().Base.Width(a.wWidth).Height(a.wHeight).
581 Align(lipgloss.Center, lipgloss.Center).
582 Render(
583 t.S().Base.
584 Padding(1, 4).
585 Foreground(t.White).
586 BorderStyle(lipgloss.RoundedBorder()).
587 BorderForeground(t.Primary).
588 Render("Window too small!"),
589 ),
590 ),
591 )
592 return view
593 }
594
595 page := a.pages[a.currentPage]
596 if withHelp, ok := page.(core.KeyMapHelp); ok {
597 a.status.SetKeyMap(withHelp.Help())
598 }
599 pageView := page.View()
600 components := []string{
601 pageView,
602 }
603 components = append(components, a.status.View())
604
605 appView := lipgloss.JoinVertical(lipgloss.Top, components...)
606 layers := []*lipgloss.Layer{
607 lipgloss.NewLayer(appView),
608 }
609 if a.dialog.HasDialogs() {
610 layers = append(
611 layers,
612 a.dialog.GetLayers()...,
613 )
614 }
615
616 var cursor *tea.Cursor
617 if v, ok := page.(util.Cursor); ok {
618 cursor = v.Cursor()
619 // Hide the cursor if it's positioned outside the textarea
620 statusHeight := a.height - strings.Count(pageView, "\n") + 1
621 if cursor != nil && cursor.Y+statusHeight+chat.EditorHeight-2 <= a.height { // 2 for the top and bottom app padding
622 cursor = nil
623 }
624 }
625 activeView := a.dialog.ActiveModel()
626 if activeView != nil {
627 cursor = nil // Reset cursor if a dialog is active unless it implements util.Cursor
628 if v, ok := activeView.(util.Cursor); ok {
629 cursor = v.Cursor()
630 }
631 }
632
633 if a.completions.Open() && cursor != nil {
634 cmp := a.completions.View()
635 x, y := a.completions.Position()
636 layers = append(
637 layers,
638 lipgloss.NewLayer(cmp).X(x).Y(y),
639 )
640 }
641
642 canvas := lipgloss.NewCanvas(
643 layers...,
644 )
645
646 view.Layer = canvas
647 view.Cursor = cursor
648 view.ProgressBar = tea.NewProgressBar(tea.ProgressBarNone, 0)
649 if a.app.CoderAgent.IsBusy() {
650 // use a random percentage to prevent the ghostty from hiding it after
651 // a timeout.
652 view.ProgressBar = tea.NewProgressBar(tea.ProgressBarIndeterminate, rand.Intn(100))
653 }
654 return view
655}
656
657// New creates and initializes a new TUI application model.
658func New(app *app.App) tea.Model {
659 chatPage := chat.New(app)
660 keyMap := DefaultKeyMap()
661 keyMap.pageBindings = chatPage.Bindings()
662
663 model := &appModel{
664 currentPage: chat.ChatPageID,
665 app: app,
666 status: status.NewStatusCmp(),
667 loadedPages: make(map[page.PageID]bool),
668 keyMap: keyMap,
669
670 pages: map[page.PageID]util.Model{
671 chat.ChatPageID: chatPage,
672 },
673
674 dialog: dialogs.NewDialogCmp(),
675 completions: completions.New(),
676 }
677
678 return model
679}