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