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