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 msg.OnSubmit,
160 ),
161 },
162 )
163 case commands.ShowMCPPromptArgumentsDialogMsg:
164 args := make([]commands.Argument, 0, len(msg.Prompt.Arguments))
165 for _, arg := range msg.Prompt.Arguments {
166 args = append(args, commands.Argument(*arg))
167 }
168 dialog := commands.NewCommandArgumentsDialog(
169 msg.Prompt.Name,
170 msg.Prompt.Title,
171 msg.Prompt.Name,
172 msg.Prompt.Description,
173 args,
174 msg.OnSubmit,
175 )
176 return a, util.CmdHandler(
177 dialogs.OpenDialogMsg{
178 Model: dialog,
179 },
180 )
181 // Page change messages
182 case page.PageChangeMsg:
183 return a, a.moveToPage(msg.ID)
184
185 // Status Messages
186 case util.InfoMsg, util.ClearStatusMsg:
187 s, statusCmd := a.status.Update(msg)
188 a.status = s.(status.StatusCmp)
189 cmds = append(cmds, statusCmd)
190 return a, tea.Batch(cmds...)
191
192 // Session
193 case cmpChat.SessionSelectedMsg:
194 a.selectedSessionID = msg.ID
195 case cmpChat.SessionClearedMsg:
196 a.selectedSessionID = ""
197 // Commands
198 case commands.SwitchSessionsMsg:
199 return a, func() tea.Msg {
200 allSessions, _ := a.app.Sessions.List(context.Background())
201 return dialogs.OpenDialogMsg{
202 Model: sessions.NewSessionDialogCmp(allSessions, a.selectedSessionID),
203 }
204 }
205
206 case commands.SwitchModelMsg:
207 return a, util.CmdHandler(
208 dialogs.OpenDialogMsg{
209 Model: models.NewModelDialogCmp(),
210 },
211 )
212 // Compact
213 case commands.CompactMsg:
214 return a, util.CmdHandler(dialogs.OpenDialogMsg{
215 Model: compact.NewCompactDialogCmp(a.app.CoderAgent, msg.SessionID, true),
216 })
217 case commands.QuitMsg:
218 return a, util.CmdHandler(dialogs.OpenDialogMsg{
219 Model: quit.NewQuitDialog(),
220 })
221 case commands.ToggleYoloModeMsg:
222 a.app.Permissions.SetSkipRequests(!a.app.Permissions.SkipRequests())
223 case commands.ToggleHelpMsg:
224 a.status.ToggleFullHelp()
225 a.showingFullHelp = !a.showingFullHelp
226 return a, a.handleWindowResize(a.wWidth, a.wHeight)
227 // Model Switch
228 case models.ModelSelectedMsg:
229 if a.app.CoderAgent.IsBusy() {
230 return a, util.ReportWarn("Agent is busy, please wait...")
231 }
232
233 config.Get().UpdatePreferredModel(msg.ModelType, msg.Model)
234
235 // Update the agent with the new model/provider configuration
236 if err := a.app.UpdateAgentModel(); err != nil {
237 return a, util.ReportError(fmt.Errorf("model changed to %s but failed to update agent: %v", msg.Model.Model, err))
238 }
239
240 modelTypeName := "large"
241 if msg.ModelType == config.SelectedModelTypeSmall {
242 modelTypeName = "small"
243 }
244 return a, util.ReportInfo(fmt.Sprintf("%s model changed to %s", modelTypeName, msg.Model.Model))
245
246 // File Picker
247 case commands.OpenFilePickerMsg:
248 event.FilePickerOpened()
249
250 if a.dialog.ActiveDialogID() == filepicker.FilePickerID {
251 // If the commands dialog is already open, close it
252 return a, util.CmdHandler(dialogs.CloseDialogMsg{})
253 }
254 return a, util.CmdHandler(dialogs.OpenDialogMsg{
255 Model: filepicker.NewFilePickerCmp(a.app.Config().WorkingDir()),
256 })
257 // Permissions
258 case pubsub.Event[permission.PermissionNotification]:
259 item, ok := a.pages[a.currentPage]
260 if !ok {
261 return a, nil
262 }
263
264 // Forward to view.
265 updated, itemCmd := item.Update(msg)
266 if model, ok := updated.(util.Model); ok {
267 a.pages[a.currentPage] = model
268 }
269
270 return a, itemCmd
271 case pubsub.Event[permission.PermissionRequest]:
272 return a, util.CmdHandler(dialogs.OpenDialogMsg{
273 Model: permissions.NewPermissionDialogCmp(msg.Payload, &permissions.Options{
274 DiffMode: config.Get().Options.TUI.DiffMode,
275 }),
276 })
277 case permissions.PermissionResponseMsg:
278 switch msg.Action {
279 case permissions.PermissionAllow:
280 a.app.Permissions.Grant(msg.Permission)
281 case permissions.PermissionAllowForSession:
282 a.app.Permissions.GrantPersistent(msg.Permission)
283 case permissions.PermissionDeny:
284 a.app.Permissions.Deny(msg.Permission)
285 }
286 return a, nil
287 // Agent Events
288 case pubsub.Event[agent.AgentEvent]:
289 payload := msg.Payload
290
291 // Forward agent events to dialogs
292 if a.dialog.HasDialogs() && a.dialog.ActiveDialogID() == compact.CompactDialogID {
293 u, dialogCmd := a.dialog.Update(payload)
294 if model, ok := u.(dialogs.DialogCmp); ok {
295 a.dialog = model
296 }
297
298 cmds = append(cmds, dialogCmd)
299 }
300
301 // Handle auto-compact logic
302 if payload.Done && payload.Type == agent.AgentEventTypeResponse && a.selectedSessionID != "" {
303 // Get current session to check token usage
304 session, err := a.app.Sessions.Get(context.Background(), a.selectedSessionID)
305 if err == nil {
306 model := a.app.CoderAgent.Model()
307 contextWindow := model.ContextWindow
308 tokens := session.CompletionTokens + session.PromptTokens
309 if (tokens >= int64(float64(contextWindow)*0.95)) && !config.Get().Options.DisableAutoSummarize { // Show compact confirmation dialog
310 cmds = append(cmds, util.CmdHandler(dialogs.OpenDialogMsg{
311 Model: compact.NewCompactDialogCmp(a.app.CoderAgent, a.selectedSessionID, false),
312 }))
313 }
314 }
315 }
316
317 return a, tea.Batch(cmds...)
318 case splash.OnboardingCompleteMsg:
319 item, ok := a.pages[a.currentPage]
320 if !ok {
321 return a, nil
322 }
323
324 a.isConfigured = config.HasInitialDataConfig()
325 updated, pageCmd := item.Update(msg)
326 if model, ok := updated.(util.Model); ok {
327 a.pages[a.currentPage] = model
328 }
329
330 cmds = append(cmds, pageCmd)
331 return a, tea.Batch(cmds...)
332
333 case tea.KeyPressMsg:
334 return a, a.handleKeyPressMsg(msg)
335
336 case tea.MouseWheelMsg:
337 if a.dialog.HasDialogs() {
338 u, dialogCmd := a.dialog.Update(msg)
339 a.dialog = u.(dialogs.DialogCmp)
340 cmds = append(cmds, dialogCmd)
341 } else {
342 item, ok := a.pages[a.currentPage]
343 if !ok {
344 return a, nil
345 }
346
347 updated, pageCmd := item.Update(msg)
348 if model, ok := updated.(util.Model); ok {
349 a.pages[a.currentPage] = model
350 }
351
352 cmds = append(cmds, pageCmd)
353 }
354 return a, tea.Batch(cmds...)
355 case tea.PasteMsg:
356 if a.dialog.HasDialogs() {
357 u, dialogCmd := a.dialog.Update(msg)
358 if model, ok := u.(dialogs.DialogCmp); ok {
359 a.dialog = model
360 }
361
362 cmds = append(cmds, dialogCmd)
363 } else {
364 item, ok := a.pages[a.currentPage]
365 if !ok {
366 return a, nil
367 }
368
369 updated, pageCmd := item.Update(msg)
370 if model, ok := updated.(util.Model); ok {
371 a.pages[a.currentPage] = model
372 }
373
374 cmds = append(cmds, pageCmd)
375 }
376 return a, tea.Batch(cmds...)
377 }
378 s, _ := a.status.Update(msg)
379 a.status = s.(status.StatusCmp)
380
381 item, ok := a.pages[a.currentPage]
382 if !ok {
383 return a, nil
384 }
385
386 updated, cmd := item.Update(msg)
387 if model, ok := updated.(util.Model); ok {
388 a.pages[a.currentPage] = model
389 }
390
391 if a.dialog.HasDialogs() {
392 u, dialogCmd := a.dialog.Update(msg)
393 if model, ok := u.(dialogs.DialogCmp); ok {
394 a.dialog = model
395 }
396
397 cmds = append(cmds, dialogCmd)
398 }
399 cmds = append(cmds, cmd)
400 return a, tea.Batch(cmds...)
401}
402
403// handleWindowResize processes window resize events and updates all components.
404func (a *appModel) handleWindowResize(width, height int) tea.Cmd {
405 var cmds []tea.Cmd
406
407 // TODO: clean up these magic numbers.
408 if a.showingFullHelp {
409 height -= 5
410 } else {
411 height -= 2
412 }
413
414 a.width, a.height = width, height
415 // Update status bar
416 s, cmd := a.status.Update(tea.WindowSizeMsg{Width: width, Height: height})
417 if model, ok := s.(status.StatusCmp); ok {
418 a.status = model
419 }
420 cmds = append(cmds, cmd)
421
422 // Update the current view.
423 for p, page := range a.pages {
424 updated, pageCmd := page.Update(tea.WindowSizeMsg{Width: width, Height: height})
425 if model, ok := updated.(util.Model); ok {
426 a.pages[p] = model
427 }
428
429 cmds = append(cmds, pageCmd)
430 }
431
432 // Update the dialogs
433 dialog, cmd := a.dialog.Update(tea.WindowSizeMsg{Width: width, Height: height})
434 if model, ok := dialog.(dialogs.DialogCmp); ok {
435 a.dialog = model
436 }
437
438 cmds = append(cmds, cmd)
439
440 return tea.Batch(cmds...)
441}
442
443// handleKeyPressMsg processes keyboard input and routes to appropriate handlers.
444func (a *appModel) handleKeyPressMsg(msg tea.KeyPressMsg) tea.Cmd {
445 // Check this first as the user should be able to quit no matter what.
446 if key.Matches(msg, a.keyMap.Quit) {
447 if a.dialog.ActiveDialogID() == quit.QuitDialogID {
448 return tea.Quit
449 }
450 return util.CmdHandler(dialogs.OpenDialogMsg{
451 Model: quit.NewQuitDialog(),
452 })
453 }
454
455 if a.completions.Open() {
456 // completions
457 keyMap := a.completions.KeyMap()
458 switch {
459 case key.Matches(msg, keyMap.Up), key.Matches(msg, keyMap.Down),
460 key.Matches(msg, keyMap.Select), key.Matches(msg, keyMap.Cancel),
461 key.Matches(msg, keyMap.UpInsert), key.Matches(msg, keyMap.DownInsert):
462 u, cmd := a.completions.Update(msg)
463 a.completions = u.(completions.Completions)
464 return cmd
465 }
466 }
467 if a.dialog.HasDialogs() {
468 u, dialogCmd := a.dialog.Update(msg)
469 a.dialog = u.(dialogs.DialogCmp)
470 return dialogCmd
471 }
472 switch {
473 // help
474 case key.Matches(msg, a.keyMap.Help):
475 a.status.ToggleFullHelp()
476 a.showingFullHelp = !a.showingFullHelp
477 return a.handleWindowResize(a.wWidth, a.wHeight)
478 // dialogs
479 case key.Matches(msg, a.keyMap.Commands):
480 // if the app is not configured show no commands
481 if !a.isConfigured {
482 return nil
483 }
484 if a.dialog.ActiveDialogID() == commands.CommandsDialogID {
485 return util.CmdHandler(dialogs.CloseDialogMsg{})
486 }
487 if a.dialog.HasDialogs() {
488 return nil
489 }
490 return util.CmdHandler(dialogs.OpenDialogMsg{
491 Model: commands.NewCommandDialog(a.selectedSessionID),
492 })
493 case key.Matches(msg, a.keyMap.Sessions):
494 // if the app is not configured show no sessions
495 if !a.isConfigured {
496 return nil
497 }
498 if a.dialog.ActiveDialogID() == sessions.SessionsDialogID {
499 return util.CmdHandler(dialogs.CloseDialogMsg{})
500 }
501 if a.dialog.HasDialogs() && a.dialog.ActiveDialogID() != commands.CommandsDialogID {
502 return nil
503 }
504 var cmds []tea.Cmd
505 if a.dialog.ActiveDialogID() == commands.CommandsDialogID {
506 // If the commands dialog is open, close it first
507 cmds = append(cmds, util.CmdHandler(dialogs.CloseDialogMsg{}))
508 }
509 cmds = append(cmds,
510 func() tea.Msg {
511 allSessions, _ := a.app.Sessions.List(context.Background())
512 return dialogs.OpenDialogMsg{
513 Model: sessions.NewSessionDialogCmp(allSessions, a.selectedSessionID),
514 }
515 },
516 )
517 return tea.Sequence(cmds...)
518 case key.Matches(msg, a.keyMap.Suspend):
519 if a.app.CoderAgent != nil && a.app.CoderAgent.IsBusy() {
520 return util.ReportWarn("Agent is busy, please wait...")
521 }
522 return tea.Suspend
523 default:
524 item, ok := a.pages[a.currentPage]
525 if !ok {
526 return nil
527 }
528
529 updated, cmd := item.Update(msg)
530 if model, ok := updated.(util.Model); ok {
531 a.pages[a.currentPage] = model
532 }
533 return cmd
534 }
535}
536
537// moveToPage handles navigation between different pages in the application.
538func (a *appModel) moveToPage(pageID page.PageID) tea.Cmd {
539 if a.app.CoderAgent.IsBusy() {
540 // TODO: maybe remove this : For now we don't move to any page if the agent is busy
541 return util.ReportWarn("Agent is busy, please wait...")
542 }
543
544 var cmds []tea.Cmd
545 if _, ok := a.loadedPages[pageID]; !ok {
546 cmd := a.pages[pageID].Init()
547 cmds = append(cmds, cmd)
548 a.loadedPages[pageID] = true
549 }
550 a.previousPage = a.currentPage
551 a.currentPage = pageID
552 if sizable, ok := a.pages[a.currentPage].(layout.Sizeable); ok {
553 cmd := sizable.SetSize(a.width, a.height)
554 cmds = append(cmds, cmd)
555 }
556
557 return tea.Batch(cmds...)
558}
559
560// View renders the complete application interface including pages, dialogs, and overlays.
561func (a *appModel) View() tea.View {
562 var view tea.View
563 t := styles.CurrentTheme()
564 view.BackgroundColor = t.BgBase
565 if a.wWidth < 25 || a.wHeight < 15 {
566 view.Layer = lipgloss.NewCanvas(
567 lipgloss.NewLayer(
568 t.S().Base.Width(a.wWidth).Height(a.wHeight).
569 Align(lipgloss.Center, lipgloss.Center).
570 Render(
571 t.S().Base.
572 Padding(1, 4).
573 Foreground(t.White).
574 BorderStyle(lipgloss.RoundedBorder()).
575 BorderForeground(t.Primary).
576 Render("Window too small!"),
577 ),
578 ),
579 )
580 return view
581 }
582
583 page := a.pages[a.currentPage]
584 if withHelp, ok := page.(core.KeyMapHelp); ok {
585 a.status.SetKeyMap(withHelp.Help())
586 }
587 pageView := page.View()
588 components := []string{
589 pageView,
590 }
591 components = append(components, a.status.View())
592
593 appView := lipgloss.JoinVertical(lipgloss.Top, components...)
594 layers := []*lipgloss.Layer{
595 lipgloss.NewLayer(appView),
596 }
597 if a.dialog.HasDialogs() {
598 layers = append(
599 layers,
600 a.dialog.GetLayers()...,
601 )
602 }
603
604 var cursor *tea.Cursor
605 if v, ok := page.(util.Cursor); ok {
606 cursor = v.Cursor()
607 // Hide the cursor if it's positioned outside the textarea
608 statusHeight := a.height - strings.Count(pageView, "\n") + 1
609 if cursor != nil && cursor.Y+statusHeight+chat.EditorHeight-2 <= a.height { // 2 for the top and bottom app padding
610 cursor = nil
611 }
612 }
613 activeView := a.dialog.ActiveModel()
614 if activeView != nil {
615 cursor = nil // Reset cursor if a dialog is active unless it implements util.Cursor
616 if v, ok := activeView.(util.Cursor); ok {
617 cursor = v.Cursor()
618 }
619 }
620
621 if a.completions.Open() && cursor != nil {
622 cmp := a.completions.View()
623 x, y := a.completions.Position()
624 layers = append(
625 layers,
626 lipgloss.NewLayer(cmp).X(x).Y(y),
627 )
628 }
629
630 canvas := lipgloss.NewCanvas(
631 layers...,
632 )
633
634 view.Layer = canvas
635 view.Cursor = cursor
636 view.ProgressBar = tea.NewProgressBar(tea.ProgressBarNone, 0)
637 if a.app.CoderAgent.IsBusy() {
638 // use a random percentage to prevent the ghostty from hiding it after
639 // a timeout.
640 view.ProgressBar = tea.NewProgressBar(tea.ProgressBarIndeterminate, rand.Intn(100))
641 }
642 return view
643}
644
645// New creates and initializes a new TUI application model.
646func New(app *app.App) tea.Model {
647 chatPage := chat.New(app)
648 keyMap := DefaultKeyMap()
649 keyMap.pageBindings = chatPage.Bindings()
650
651 model := &appModel{
652 currentPage: chat.ChatPageID,
653 app: app,
654 status: status.NewStatusCmp(),
655 loadedPages: make(map[page.PageID]bool),
656 keyMap: keyMap,
657
658 pages: map[page.PageID]util.Model{
659 chat.ChatPageID: chatPage,
660 },
661
662 dialog: dialogs.NewDialogCmp(),
663 completions: completions.New(),
664 }
665
666 return model
667}