60255
Zn
Zoea-Nova / files
Zoea-Nova / internal / tui / app.go
30.8 KB
1// Package tui provides the terminal user interface for Zoea Nova. 2package tui 3 4import ( 5 "fmt" 6 "sort" 7 "strings" 8 "time" 9 10 "github.com/charmbracelet/bubbles/key" 11 "github.com/charmbracelet/bubbles/spinner" 12 "github.com/charmbracelet/bubbles/viewport" 13 tea "github.com/charmbracelet/bubbletea" 14 "github.com/charmbracelet/lipgloss" 15 "github.com/xonecas/zoea-nova/internal/config" 16 "github.com/xonecas/zoea-nova/internal/core" 17 "github.com/xonecas/zoea-nova/internal/store" 18) 19 20// View represents the current view mode. 21type View int 22 23const ( 24 ViewDashboard View = iota 25 ViewFocus 26) 27 28// InputStage represents stages in multi-step input flows. 29type InputStage int 30 31const ( 32 InputStageName InputStage = iota 33 InputStageProvider 34) 35 36// Model is the main TUI model. 37type Model struct { 38 commander *core.Commander 39 store *store.Store 40 eventCh <-chan core.Event 41 config *config.Config 42 43 view View 44 width int 45 height int 46 selectedIdx int 47 showHelp bool 48 verboseJSON bool // show full JSON trees without truncation 49 50 input InputModel 51 myses []MysisInfo 52 logs []LogEntry 53 focusID string 54 55 // Multi-stage input for mysis creation 56 inputStage InputStage 57 pendingMysisName string 58 pendingMysisProvider string 59 60 pendingProvider string 61 startSwarm bool // auto-start idle myses on launch 62 63 // Swarm broadcast history 64 swarmMessages []SwarmMessage 65 66 // Current swarm aggregate tick 67 currentTick int64 68 69 // Test-only: override time.Now() for deterministic timestamps in tests 70 testTime *time.Time 71 72 spinner spinner.Model 73 loadingSet map[string]bool // mysisIDs currently loading 74 sending bool 75 sendingMode InputMode 76 77 // Conversation viewport 78 viewport viewport.Model 79 viewportTotalLines int // total lines in viewport content 80 81 // Sidebar scroll state 82 sidebarScrollOffset int // current scroll position for game state sidebar 83 sidebarTotalLines int // total lines in sidebar content 84 85 // Network activity indicator 86 netIndicator NetIndicator 87 activeNetworkOps int // Count of active network operations (LLM/MCP calls) 88 89 providerErrorTimes []time.Time 90 91 onQuit func() // Callback to run before quitting 92 err error 93} 94 95const ( 96 providerErrorWindow = 10 * time.Minute 97 maxConversationEntries = 500 // Maximum conversation log entries to load for performance 98 MaxConversationMessages = 500 // Maximum conversation messages to display in focus view 99) 100 101// SwarmMessage represents a broadcast message for display. 102type SwarmMessage struct { 103 SenderID string 104 Content string 105 CreatedAt time.Time 106} 107 108// EventMsg wraps a core event for the TUI. 109type EventMsg struct { 110 Event core.Event 111} 112 113// New creates a new TUI model. 114func New(commander *core.Commander, s *store.Store, eventCh <-chan core.Event, startSwarm bool, cfg *config.Config) Model { 115 // Use provided config (already loaded in main.go) 116 117 // Initialize spinner with hexagonal theme (matching logo) 118 sp := spinner.New() 119 sp.Spinner = spinner.Spinner{ 120 Frames: []string{"⬡", "⬢", "⬡", "⬢", "⬦", "⬥", "⬦", "⬥"}, 121 FPS: time.Second / 8, // 8 frames per second 122 } 123 sp.Style = lipgloss.NewStyle().Foreground(colorBrand) 124 125 // Initialize viewport for conversation scrolling 126 vp := viewport.New(80, 20) 127 vp.Style = logStyle 128 129 return Model{ 130 commander: commander, 131 store: s, 132 eventCh: eventCh, 133 config: cfg, 134 view: ViewDashboard, 135 input: NewInputModel(), 136 myses: []MysisInfo{}, 137 inputStage: InputStageName, 138 spinner: sp, 139 loadingSet: make(map[string]bool), 140 viewport: vp, 141 netIndicator: NewNetIndicator(), 142 startSwarm: startSwarm, 143 } 144} 145 146// SetOnQuit sets a callback to run before the TUI quits. 147func (m *Model) SetOnQuit(fn func()) { 148 m.onQuit = fn 149} 150 151// Init initializes the model. 152func (m Model) Init() tea.Cmd { 153 // Auto-start idle myses if flag enabled 154 if m.startSwarm { 155 go m.autoStartIdleMyses() 156 } 157 158 return tea.Batch( 159 m.netIndicator.Init(), 160 m.refreshMyses(), 161 m.listenForEvents(), 162 m.spinner.Tick, 163 ) 164} 165 166// autoStartIdleMyses starts all myses in idle state (no error). 167func (m Model) autoStartIdleMyses() { 168 myses := m.commander.ListMyses() 169 for _, mysis := range myses { 170 // Start myses that are not errored (idle state) 171 if mysis.LastError() == nil { 172 _ = m.commander.StartMysis(mysis.ID()) 173 } 174 } 175} 176 177// Update handles messages. 178func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) { 179 var cmds []tea.Cmd 180 181 m.pruneProviderErrors(time.Now()) 182 183 switch msg := msg.(type) { 184 case tea.WindowSizeMsg: 185 m.width = msg.Width 186 m.height = msg.Height 187 m.input.SetWidth(msg.Width - 4) 188 189 // Update viewport size (account for all UI chrome) 190 // Layout in RenderFocusViewWithViewport: 191 // - Header: 2 lines (mysis name + ID/created) 192 // - Info panel: 3 lines (top border + content + bottom border) 193 // - Title row: 1 line (GAME STATE + CONVERSATION LOG titles) 194 // - Content: max(sidebar_lines, vp.Height) lines (sidebar + conversation side-by-side) 195 // - Bottom border: 1 line 196 // - Footer: 1 line (hints) 197 // Added in View(): 198 // - Newline: 1 line (before message bar) 199 // - Message bar: 1 line 200 // - Newline: 1 line (before status bar) 201 // - Status bar: 1 line 202 // Total: (2+3+1+1+1) + vp.Height + (1+1+1+1) = 12 + vp.Height 203 // Therefore: vp.Height = msg.Height - 12 204 vpHeight := msg.Height - 12 205 if vpHeight < 5 { 206 vpHeight = 5 207 } 208 // Viewport width must match the conversation log width calculation in focus.go 209 // Two-column layout: Sidebar (33% of width) + Gap (3: space+│+space) + Conversation 210 // Sidebar takes 33% of terminal width (multiply first to avoid precision loss) 211 // Viewport content width = conversation - 2 (for scrollbar) 212 sidebarWidth := (msg.Width * 33) / 100 213 const columnGap = 3 214 conversationWidth := msg.Width - sidebarWidth - columnGap 215 m.viewport.Width = conversationWidth - 2 // -2 for scrollbar 216 m.viewport.Height = vpHeight 217 218 // Re-render content if in focus view 219 if m.view == ViewFocus { 220 m.updateViewportContent() 221 } 222 223 case tea.MouseMsg: 224 // Handle mouse wheel scrolling in focus view 225 if m.view == ViewFocus { 226 return m.handleMouseInFocus(msg) 227 } 228 // For other views, let viewport handle it 229 var cmd tea.Cmd 230 m.viewport, cmd = m.viewport.Update(msg) 231 return m, cmd 232 233 case tea.KeyMsg: 234 // Handle input mode first 235 if m.input.IsActive() { 236 return m.handleInputKey(msg) 237 } 238 239 // Handle help toggle 240 if key.Matches(msg, keys.Help) { 241 m.showHelp = !m.showHelp 242 return m, nil 243 } 244 245 // Close help if shown 246 if m.showHelp { 247 m.showHelp = false 248 return m, nil 249 } 250 251 // Handle global keys 252 switch { 253 case key.Matches(msg, keys.Quit): 254 // Call cleanup callback before quitting 255 if m.onQuit != nil { 256 m.onQuit() 257 } 258 return m, tea.Quit 259 260 case key.Matches(msg, keys.Escape): 261 if m.view == ViewFocus { 262 m.view = ViewDashboard 263 m.focusID = "" 264 } 265 return m, nil 266 } 267 268 // View-specific keys 269 if m.view == ViewDashboard { 270 return m.handleDashboardKey(msg) 271 } else { 272 return m.handleFocusKey(msg) 273 } 274 275 case EventMsg: 276 // Don't re-schedule if channel closed (zero-value event) 277 if msg.Event.Type == "" { 278 return m, nil 279 } 280 m.handleEvent(msg.Event) 281 return m, m.listenForEvents() 282 283 case refreshMysesMsg: 284 m.refreshMysisList() 285 m.refreshSwarmMessages() 286 m.refreshTick() 287 288 case spinner.TickMsg: 289 var cmd tea.Cmd 290 m.spinner, cmd = m.spinner.Update(msg) 291 return m, cmd 292 293 case sendMessageResult: 294 // Message finished sending (success or failure) 295 delete(m.loadingSet, msg.mysisID) 296 if msg.err != nil { 297 m.err = msg.err 298 } 299 // Check if any loading is still active 300 if len(m.loadingSet) == 0 { 301 m.netIndicator.SetActivity(NetActivityIdle) 302 m.sending = false 303 m.sendingMode = InputModeNone 304 m.input.Reset() 305 } 306 // Don't refresh logs here - EventMysisMessage and EventMysisResponse handle that 307 308 case broadcastResult: 309 // Broadcast finished - clear all loading states 310 m.loadingSet = make(map[string]bool) 311 m.netIndicator.SetActivity(NetActivityIdle) 312 m.sending = false 313 m.sendingMode = InputModeNone 314 m.input.Reset() 315 if msg.err != nil { 316 m.err = msg.err 317 } 318 // Refresh swarm messages to show the new broadcast 319 m.refreshSwarmMessages() 320 321 case NetIndicatorTickMsg: 322 var cmd tea.Cmd 323 m.netIndicator, cmd = m.netIndicator.Update(msg) 324 return m, cmd 325 } 326 327 return m, tea.Batch(cmds...) 328} 329 330// View renders the UI. 331func (m Model) View() string { 332 if m.width == 0 || m.height == 0 { 333 return "Loading..." 334 } 335 336 // Check for minimum terminal dimensions 337 const minWidth = 80 338 const minHeight = 20 339 if m.width < minWidth || m.height < minHeight { 340 warning := lipgloss.NewStyle(). 341 Foreground(lipgloss.Color("#FF5555")). 342 Bold(true). 343 Render(fmt.Sprintf("Terminal too small!\n\nMinimum size: %dx%d\nCurrent size: %dx%d\n\nPlease resize your terminal.", 344 minWidth, minHeight, m.width, m.height)) 345 return warning 346 } 347 348 var content string 349 350 // Check if currently focused mysis is loading 351 isLoading := m.loadingSet[m.focusID] 352 353 // Reserve space for status bar 354 contentHeight := m.height - 1 355 356 if m.showHelp { 357 content = RenderHelp(m.width, contentHeight) 358 } else if m.view == ViewFocus { 359 focusIndex, totalMyses := m.focusPosition(m.focusID) 360 361 // Get game state snapshots for focused mysis 362 var gameStateSnapshots []*store.GameStateSnapshot 363 focusMysis := m.mysisByID(m.focusID) 364 if focusMysis.AccountUsername != "" { 365 snapshots, err := m.store.GetAllGameStateSnapshots(focusMysis.AccountUsername) 366 if err == nil { 367 gameStateSnapshots = snapshots 368 } 369 } 370 371 content = RenderFocusViewWithViewport(focusMysis, m.viewport, m.width, isLoading, m.spinner.View(), m.verboseJSON, m.viewportTotalLines, focusIndex, totalMyses, m.currentTick, gameStateSnapshots, m.sidebarScrollOffset, m.err) 372 } else { 373 // Convert swarm messages for display (reversed so most recent is first) 374 swarmInfos := make([]SwarmMessageInfo, len(m.swarmMessages)) 375 for i, msg := range m.swarmMessages { 376 // Reverse order: most recent first 377 swarmInfos[len(m.swarmMessages)-1-i] = SwarmMessageInfo{ 378 SenderID: msg.SenderID, 379 SenderName: m.mysisNameByID(msg.SenderID), 380 Content: msg.Content, 381 CreatedAt: msg.CreatedAt, 382 } 383 } 384 content = RenderDashboard(m.myses, swarmInfos, m.selectedIdx, m.width, contentHeight-3, m.loadingSet, m.spinner.View(), m.currentTick, m.err) 385 } 386 387 // Always show message bar 388 sendingLabel := "" 389 if m.sending { 390 switch m.sendingMode { 391 case InputModeBroadcast: 392 sendingLabel = "Broadcasting..." 393 case InputModeMessage: 394 sendingLabel = "Sending message..." 395 default: 396 sendingLabel = "Sending..." 397 } 398 } 399 content += "\n" + m.input.ViewAlways(m.width, m.sending, sendingLabel, m.spinner.View()) 400 401 // Build status bar 402 statusBar := m.renderStatusBar() 403 404 return content + "\n" + statusBar 405} 406 407// renderStatusBar renders the bottom status bar with activity indicator, tick, and state counts. 408// Layout: [activity indicator] | T#### ⬡ [HH:MM] | [state icons + counts] 409func (m Model) renderStatusBar() string { 410 // Left segment: Activity indicator (LLM/MCP/IDLE) 411 leftSegment := m.netIndicator.View() 412 413 // Middle segment: Tick + timestamp 414 middleSegment := m.renderTickTimestamp() 415 416 // Right segment: State counts with animated icons 417 rightSegment := m.renderStateCounts() 418 419 // Calculate widths 420 leftWidth := lipgloss.Width(leftSegment) 421 middleWidth := lipgloss.Width(middleSegment) 422 rightWidth := lipgloss.Width(rightSegment) 423 424 // Separator style 425 separators := lipgloss.NewStyle().Foreground(colorMuted).Render(" | ") 426 sepWidth := lipgloss.Width(separators) 427 428 // Calculate center position for middle segment 429 centerPos := m.width / 2 430 middleStart := centerPos - (middleWidth / 2) 431 432 // Calculate padding to center the middle segment 433 // Left side: leftSegment + separator + padding 434 leftSideWidth := leftWidth + sepWidth 435 leftPad := middleStart - leftSideWidth 436 if leftPad < 1 { 437 leftPad = 1 438 } 439 440 // Right side: padding + separator + rightSegment 441 rightSideStart := middleStart + middleWidth 442 rightPad := m.width - rightSideStart - sepWidth - rightWidth 443 if rightPad < 1 { 444 rightPad = 1 445 } 446 447 // Style the status bar 448 barStyle := lipgloss.NewStyle(). 449 Background(colorBorder). 450 Foreground(colorBrand). 451 Width(m.width) 452 453 bar := leftSegment + 454 separators + 455 strings.Repeat(" ", leftPad) + 456 middleSegment + 457 strings.Repeat(" ", rightPad) + 458 separators + 459 rightSegment 460 461 return barStyle.Render(bar) 462} 463 464// renderStateCounts renders the state counts with animated icons. 465// Format: ⬡ 3 ◦ 2 ◌ 1 ✖ 0 466func (m Model) renderStateCounts() string { 467 // Count states 468 counts := map[string]int{ 469 "running": 0, 470 "idle": 0, 471 "stopped": 0, 472 "errored": 0, 473 } 474 475 for _, mysis := range m.myses { 476 counts[mysis.State]++ 477 } 478 479 // Get spinner frame for running/loading states 480 spinnerFrame := m.spinner.View() 481 482 // Build state count segments 483 var parts []string 484 485 // Running: animated spinner 486 if counts["running"] > 0 { 487 icon := lipgloss.NewStyle().Foreground(colorBrand).Render(spinnerFrame) 488 count := fmt.Sprintf("%d", counts["running"]) 489 parts = append(parts, icon+" "+count) 490 } 491 492 // Idle: ◦ 493 if counts["idle"] > 0 { 494 icon := stateIdleStyle.Render("◦") 495 count := fmt.Sprintf("%d", counts["idle"]) 496 parts = append(parts, icon+" "+count) 497 } 498 499 // Stopped: ◌ 500 if counts["stopped"] > 0 { 501 icon := stateStoppedStyle.Render("◌") 502 count := fmt.Sprintf("%d", counts["stopped"]) 503 parts = append(parts, icon+" "+count) 504 } 505 506 // Errored: ✖ 507 if counts["errored"] > 0 { 508 icon := stateErroredStyle.Render("✖") 509 count := fmt.Sprintf("%d", counts["errored"]) 510 parts = append(parts, icon+" "+count) 511 } 512 513 if len(parts) == 0 { 514 return dimmedStyle.Render("(no myses)") 515 } 516 517 return strings.Join(parts, " ") 518} 519 520// renderTickTimestamp renders the tick + timestamp in format: T#### ⬡ [HH:MM] 521func (m Model) renderTickTimestamp() string { 522 // Get current time (or test time override) 523 var now time.Time 524 if m.testTime != nil { 525 now = *m.testTime 526 } else { 527 now = time.Now() 528 } 529 530 // Use the shared formatter from styles.go 531 // formatTickTimestamp returns pre-styled string with colors 532 return formatTickTimestamp(m.currentTick, now) 533} 534 535func (m Model) handleDashboardKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) { 536 switch { 537 case key.Matches(msg, keys.Up), key.Matches(msg, keys.ShiftTab): 538 if m.selectedIdx > 0 { 539 m.selectedIdx-- 540 } 541 542 case key.Matches(msg, keys.Down), key.Matches(msg, keys.Tab): 543 if m.selectedIdx < len(m.myses)-1 { 544 m.selectedIdx++ 545 } 546 547 case key.Matches(msg, keys.Enter): 548 if len(m.myses) > 0 && m.selectedIdx < len(m.myses) { 549 m.focusID = m.myses[m.selectedIdx].ID 550 m.view = ViewFocus 551 m.loadMysisLogs() 552 // Start at bottom when entering focus view 553 m.viewport.GotoBottom() 554 } 555 556 case key.Matches(msg, keys.NewMysis): 557 m.input.SetMode(InputModeNewMysis, "") 558 m.inputStage = InputStageName // Reset to name stage 559 m.pendingMysisName = "" 560 m.pendingMysisProvider = "" 561 return m, m.input.Focus() 562 563 case key.Matches(msg, keys.Delete): 564 if len(m.myses) > 0 && m.selectedIdx < len(m.myses) { 565 id := m.myses[m.selectedIdx].ID 566 m.err = m.commander.DeleteMysis(id, true) 567 m.refreshMysisList() 568 if m.selectedIdx >= len(m.myses) && m.selectedIdx > 0 { 569 m.selectedIdx-- 570 } 571 } 572 573 case key.Matches(msg, keys.Relaunch): 574 if len(m.myses) > 0 && m.selectedIdx < len(m.myses) { 575 id := m.myses[m.selectedIdx].ID 576 m.err = m.commander.StartMysis(id) 577 } 578 579 case key.Matches(msg, keys.Stop): 580 if len(m.myses) > 0 && m.selectedIdx < len(m.myses) { 581 id := m.myses[m.selectedIdx].ID 582 m.err = m.commander.StopMysis(id) 583 } 584 585 case key.Matches(msg, keys.Broadcast): 586 m.input.SetMode(InputModeBroadcast, "") 587 return m, m.input.Focus() 588 589 case key.Matches(msg, keys.Message): 590 if len(m.myses) > 0 && m.selectedIdx < len(m.myses) { 591 id := m.myses[m.selectedIdx].ID 592 m.input.SetMode(InputModeMessage, id) 593 return m, m.input.Focus() 594 } 595 596 case key.Matches(msg, keys.Configure): 597 if len(m.myses) > 0 && m.selectedIdx < len(m.myses) { 598 id := m.myses[m.selectedIdx].ID 599 m.input.SetMode(InputModeConfigProvider, id) 600 return m, m.input.Focus() 601 } 602 } 603 604 return m, nil 605} 606 607func (m Model) handleFocusKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) { 608 switch { 609 case key.Matches(msg, keys.Message): 610 m.input.SetMode(InputModeMessage, m.focusID) 611 return m, m.input.Focus() 612 613 case key.Matches(msg, keys.Relaunch): 614 m.err = m.commander.StartMysis(m.focusID) 615 return m, nil 616 617 case key.Matches(msg, keys.Stop): 618 m.err = m.commander.StopMysis(m.focusID) 619 return m, nil 620 621 case key.Matches(msg, keys.Configure): 622 m.input.SetMode(InputModeConfigProvider, m.focusID) 623 return m, m.input.Focus() 624 625 case key.Matches(msg, keys.Broadcast): 626 m.input.SetMode(InputModeBroadcast, "") 627 return m, m.input.Focus() 628 629 case key.Matches(msg, keys.End): 630 // Go to bottom 631 m.viewport.GotoBottom() 632 return m, nil 633 634 case key.Matches(msg, keys.VerboseToggle): 635 m.verboseJSON = !m.verboseJSON 636 // Re-render viewport content with new verbose setting 637 m.updateViewportContent() 638 return m, nil 639 640 // Sidebar scrolling (Shift+Up/Down for sidebar, plain Up/Down for conversation) 641 case msg.String() == "shift+up": 642 if m.sidebarScrollOffset > 0 { 643 m.sidebarScrollOffset-- 644 } 645 return m, nil 646 647 case msg.String() == "shift+down": 648 // sidebarTotalLines is calculated during render, but we need to constrain here 649 // For now, just increment - render will constrain to valid range 650 m.sidebarScrollOffset++ 651 return m, nil 652 653 case msg.String() == "shift+home": 654 m.sidebarScrollOffset = 0 655 return m, nil 656 } 657 658 // Pass other keys to viewport for scrolling 659 var cmd tea.Cmd 660 m.viewport, cmd = m.viewport.Update(msg) 661 662 return m, cmd 663} 664 665func (m Model) handleMouseInFocus(msg tea.MouseMsg) (tea.Model, tea.Cmd) { 666 // Only handle mouse wheel events 667 if msg.Type != tea.MouseWheelUp && msg.Type != tea.MouseWheelDown { 668 // Pass other mouse events to viewport 669 var cmd tea.Cmd 670 m.viewport, cmd = m.viewport.Update(msg) 671 return m, cmd 672 } 673 674 // Calculate sidebar width (same calculation as in rendering) 675 sidebarWidth := (m.width * 33) / 100 676 677 // Check if mouse is over sidebar (X coordinate < sidebarWidth) 678 if msg.X < sidebarWidth { 679 // Scroll sidebar 680 if msg.Type == tea.MouseWheelUp { 681 if m.sidebarScrollOffset > 0 { 682 m.sidebarScrollOffset-- 683 } 684 } else if msg.Type == tea.MouseWheelDown { 685 m.sidebarScrollOffset++ 686 } 687 return m, nil 688 } 689 690 // Mouse is over conversation - pass to viewport 691 var cmd tea.Cmd 692 m.viewport, cmd = m.viewport.Update(msg) 693 return m, cmd 694} 695 696func (m Model) handleInputKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) { 697 switch { 698 case key.Matches(msg, keys.Escape): 699 m.resetInput() 700 m.pendingProvider = "" 701 m.err = nil 702 return m, nil 703 704 case key.Matches(msg, keys.Enter): 705 value := strings.TrimSpace(m.input.Value()) 706 707 // Allow empty values for optional fields (provider selection) 708 // but block for required fields (handled per-mode) 709 710 var cmd tea.Cmd 711 712 switch m.input.Mode() { 713 case InputModeBroadcast: 714 if value == "" { 715 m.input.Reset() 716 return m, nil 717 } 718 // Add to history before sending 719 m.input.AddToHistory(value) 720 m.input.Reset() 721 // Mark all running myses as loading 722 myses := m.commander.ListMyses() 723 for _, mysis := range myses { 724 if mysis.State() == core.MysisStateRunning { 725 m.loadingSet[mysis.ID()] = true 726 } 727 } 728 m.netIndicator.SetActivity(NetActivityLLM) 729 m.sending = true 730 m.sendingMode = InputModeBroadcast 731 // Use Broadcast to properly set source='broadcast' 732 cmd = m.broadcastAsync(value) 733 734 case InputModeMessage: 735 // Add to history before sending 736 m.input.AddToHistory(value) 737 targetID := m.input.TargetID() // Save targetID BEFORE reset 738 m.input.Reset() // Clear input immediately after saving targetID 739 m.loadingSet[targetID] = true 740 m.netIndicator.SetActivity(NetActivityLLM) 741 // Note: m.sending NOT set here - SendMessageAsync returns immediately 742 // Network indicator shows activity, but input is ready for next message 743 cmd = m.sendMessageAsync(targetID, value) 744 // Don't call loadMysisLogs() here - message storage now happens instantly 745 // and EventMysisMessage will trigger the refresh via handleEvent() 746 747 case InputModeNewMysis: 748 // Multi-stage flow: name → provider 749 switch m.inputStage { 750 case InputStageName: 751 // Name is required 752 if value == "" { 753 m.err = fmt.Errorf("name cannot be empty") 754 return m, nil 755 } 756 m.pendingMysisName = value 757 m.inputStage = InputStageProvider 758 m.input.textInput.SetValue("") // Clear input but keep mode 759 m.input.textInput.Placeholder = fmt.Sprintf("Provider (empty for default: %s)...", m.config.Swarm.DefaultProvider) 760 return m, nil 761 762 case InputStageProvider: 763 // Provider is optional - use default if empty 764 provider := value 765 if provider == "" { 766 provider = m.config.Swarm.DefaultProvider 767 } 768 769 // Validate provider exists 770 if _, ok := m.config.Providers[provider]; !ok { 771 // Debug: show available providers 772 var available []string 773 for p := range m.config.Providers { 774 available = append(available, p) 775 } 776 m.err = fmt.Errorf("provider '%s' not found. Available: %v", provider, available) 777 m.resetInput() 778 m.refreshMysisList() 779 return m, nil 780 } 781 782 // Create mysis with selected provider 783 mysis, err := m.commander.CreateMysis(m.pendingMysisName, provider) 784 if err == nil { 785 // Auto-start newly created myses 786 m.err = m.commander.StartMysis(mysis.ID()) 787 } else { 788 m.err = err 789 } 790 m.resetInput() 791 m.refreshMysisList() 792 return m, nil 793 794 default: 795 // Safety: reset if in unexpected state 796 m.err = fmt.Errorf("unexpected input stage (%d), resetting", m.inputStage) 797 m.resetInput() 798 return m, nil 799 } 800 801 case InputModeConfigProvider: 802 // Validate provider exists in config 803 if _, ok := m.config.Providers[value]; !ok { 804 var available []string 805 for p := range m.config.Providers { 806 available = append(available, p) 807 } 808 m.err = fmt.Errorf("provider '%s' not found. Available: %v", value, available) 809 m.input.Reset() 810 return m, nil 811 } 812 m.pendingProvider = value 813 m.input.SetMode(InputModeConfigModel, m.input.TargetID()) 814 return m, m.input.Focus() 815 816 case InputModeConfigModel: 817 m.err = m.commander.ConfigureMysis(m.input.TargetID(), m.pendingProvider, value) 818 m.pendingProvider = "" 819 } 820 821 m.input.Reset() 822 return m, cmd 823 } 824 825 // Pass to text input 826 var cmd tea.Cmd 827 m.input, cmd = m.input.Update(msg) 828 return m, cmd 829} 830 831// sendMessageAsync sends a message to a mysis asynchronously. 832func (m Model) sendMessageAsync(mysisID, content string) tea.Cmd { 833 return func() tea.Msg { 834 // Use async version to clear input immediately when message is sent, 835 // not when LLM completes processing 836 err := m.commander.SendMessageAsync(mysisID, content) 837 return sendMessageResult{mysisID: mysisID, err: err} 838 } 839} 840 841type broadcastResult struct { 842 err error 843} 844 845func (m Model) broadcastAsync(content string) tea.Cmd { 846 return func() tea.Msg { 847 err := m.commander.Broadcast(content) 848 return broadcastResult{err: err} 849 } 850} 851 852func (m *Model) handleEvent(event core.Event) { 853 switch event.Type { 854 case core.EventMysisCreated, core.EventMysisDeleted, core.EventMysisStateChanged, core.EventMysisConfigChanged: 855 m.refreshMysisList() 856 857 case core.EventMysisResponse, core.EventMysisMessage: 858 // Refresh dashboard to update last message 859 m.refreshMysisList() 860 // Refresh tick in case tool results updated server tick 861 m.refreshTick() 862 if m.view == ViewFocus && event.MysisID == m.focusID { 863 m.loadMysisLogs() 864 } 865 866 case core.EventBroadcast: 867 // Refresh swarm message history 868 m.refreshSwarmMessages() 869 870 case core.EventNetworkLLM: 871 m.activeNetworkOps++ 872 m.netIndicator.SetActivity(NetActivityLLM) 873 874 case core.EventNetworkMCP: 875 m.activeNetworkOps++ 876 m.netIndicator.SetActivity(NetActivityMCP) 877 878 case core.EventNetworkIdle: 879 // Decrement active operations counter 880 m.activeNetworkOps-- 881 if m.activeNetworkOps < 0 { 882 m.activeNetworkOps = 0 // Safety: prevent negative counts 883 } 884 // Only go idle if no active network operations 885 if m.activeNetworkOps == 0 { 886 m.netIndicator.SetActivity(NetActivityIdle) 887 } 888 // Refresh tick when network goes idle (tool calls completed) 889 m.refreshTick() 890 891 case core.EventMysisError: 892 if event.Error != nil { 893 if strings.Contains(strings.ToLower(event.Error.Error), "provider chat") { 894 m.recordProviderError(event.Timestamp) 895 } 896 } 897 } 898 899 // Clear error on successful events 900 m.err = nil 901} 902 903func (m *Model) recordProviderError(ts time.Time) { 904 if ts.IsZero() { 905 ts = time.Now() 906 } 907 m.pruneProviderErrors(ts) 908 m.providerErrorTimes = append(m.providerErrorTimes, ts) 909} 910 911func (m *Model) pruneProviderErrors(now time.Time) { 912 cutoff := now.Add(-providerErrorWindow) 913 filtered := m.providerErrorTimes[:0] 914 for _, t := range m.providerErrorTimes { 915 if t.After(cutoff) { 916 filtered = append(filtered, t) 917 } 918 } 919 m.providerErrorTimes = filtered 920} 921 922func (m *Model) refreshMysisList() { 923 myses := m.commander.ListMyses() 924 m.myses = make([]MysisInfo, len(myses)) 925 for i, mysis := range myses { 926 info := MysisInfoFromCore(mysis) 927 928 if info.AccountUsername == "" { 929 if acc, err := m.store.GetAccountByMysisID(info.ID); err == nil && acc != nil { 930 info.AccountUsername = acc.Username 931 } 932 } 933 934 // Fetch recent memories for message row formatting (5-10 messages to check priority) 935 memories, err := m.store.GetRecentMemories(mysis.ID(), 10) 936 if err == nil && len(memories) > 0 { 937 info.RecentMemories = memories 938 // Keep LastMessage and LastMessageAt for backward compatibility 939 info.LastMessage = memories[0].Content 940 info.LastMessageAt = memories[0].CreatedAt 941 } 942 943 m.myses[i] = info 944 } 945 946 // Sort by creation time (oldest first) 947 sort.Slice(m.myses, func(i, j int) bool { 948 return m.myses[i].CreatedAt.Before(m.myses[j].CreatedAt) 949 }) 950} 951 952func (m *Model) refreshSwarmMessages() { 953 broadcasts, err := m.store.GetRecentBroadcasts(10) 954 if err != nil { 955 m.swarmMessages = nil 956 return 957 } 958 959 m.swarmMessages = make([]SwarmMessage, len(broadcasts)) 960 for i, b := range broadcasts { 961 m.swarmMessages[i] = SwarmMessage{ 962 SenderID: b.SenderID, 963 Content: b.Content, 964 CreatedAt: b.CreatedAt, 965 } 966 } 967} 968 969// refreshTick updates the currentTick field from the Commander's aggregate tick. 970func (m *Model) refreshTick() { 971 m.currentTick = m.commander.AggregateTick() 972} 973 974func (m *Model) loadMysisLogs() { 975 if m.focusID == "" { 976 m.logs = nil 977 m.viewport.SetContent("") 978 return 979 } 980 981 memories, err := m.store.GetRecentMemories(m.focusID, MaxConversationMessages) 982 if err != nil { 983 m.err = err 984 return 985 } 986 987 // Filter out broadcast and system messages from conversation log 988 var filteredLogs []LogEntry 989 for _, mem := range memories { 990 // Skip broadcast messages (both sent and received) 991 if mem.Source == store.MemorySourceBroadcast { 992 continue 993 } 994 // Skip system messages (system prompts) 995 if mem.Role == store.MemoryRoleSystem { 996 continue 997 } 998 senderName := m.mysisNameByID(mem.SenderID) 999 filteredLogs = append(filteredLogs, LogEntryFromMemory(mem, m.focusID, senderName)) 1000 } 1001 1002 // Limit to MaxConversationMessages 1003 if len(filteredLogs) > MaxConversationMessages { 1004 filteredLogs = filteredLogs[len(filteredLogs)-MaxConversationMessages:] 1005 } 1006 1007 m.logs = filteredLogs 1008 1009 m.updateViewportContent() 1010} 1011 1012// updateViewportContent renders log entries and sets viewport content. 1013// Smart auto-scroll: if user is at bottom when content updates, stay at bottom. 1014func (m *Model) updateViewportContent() { 1015 if len(m.logs) == 0 { 1016 m.viewport.SetContent(dimmedStyle.Render("No conversation history.")) 1017 return 1018 } 1019 1020 // Remember if user was at bottom before updating content 1021 wasAtBottom := m.viewport.AtBottom() 1022 1023 // Two-column layout: Game State Sidebar | Conversation Log 1024 // Sidebar takes 33% of terminal width (multiply first to avoid precision loss) 1025 sidebarWidth := (m.width * 33) / 100 1026 const columnGap = 3 // space + │ + space 1027 conversationWidth := m.width - sidebarWidth - columnGap 1028 1029 // Content width for conversation log (accounting for scrollbar) 1030 // No borders on conversation log, just scrollbar 1031 panelContentWidth := conversationWidth - 2 // -2 for scrollbar 1032 1033 var lines []string 1034 // Render logs in chronological order (oldest first, newest last) 1035 // Bottom of viewport shows newest messages (normal chat behavior) 1036 for i := 0; i < len(m.logs); i++ { 1037 entryLines := renderLogEntryImpl(m.logs[i], panelContentWidth, m.verboseJSON, m.currentTick) 1038 lines = append(lines, entryLines...) 1039 } 1040 1041 content := strings.Join(lines, "\n") 1042 m.viewport.SetContent(content) 1043 m.viewportTotalLines = len(lines) // Track total lines 1044 1045 // Smart auto-scroll: if user was at bottom, keep them at bottom after content update 1046 // This prevents jarring jumps when user has manually scrolled up to read history 1047 if wasAtBottom { 1048 m.viewport.GotoBottom() 1049 } 1050} 1051 1052func (m Model) mysisByID(id string) MysisInfo { 1053 for _, mysis := range m.myses { 1054 if mysis.ID == id { 1055 return mysis 1056 } 1057 } 1058 return MysisInfo{ID: id, Name: "Unknown", State: "unknown"} 1059} 1060 1061func (m Model) mysisNameByID(id string) string { 1062 if id == "" { 1063 return "" 1064 } 1065 for _, mysis := range m.myses { 1066 if mysis.ID == id { 1067 return mysis.Name 1068 } 1069 } 1070 return "" 1071} 1072 1073func (m Model) focusPosition(focusID string) (int, int) { 1074 total := len(m.myses) 1075 if focusID == "" || total == 0 { 1076 return 0, total 1077 } 1078 for i, mysis := range m.myses { 1079 if mysis.ID == focusID { 1080 return i + 1, total 1081 } 1082 } 1083 return 0, total 1084} 1085 1086// resetInput resets input state and clears multi-stage flow. 1087func (m *Model) resetInput() { 1088 m.input.Reset() 1089 m.inputStage = InputStageName 1090 m.pendingMysisName = "" 1091 m.pendingMysisProvider = "" 1092} 1093 1094type refreshMysesMsg struct{} 1095 1096// sendMessageResult is returned when an async message send completes. 1097type sendMessageResult struct { 1098 mysisID string 1099 err error 1100} 1101 1102func (m Model) refreshMyses() tea.Cmd { 1103 return func() tea.Msg { 1104 return refreshMysesMsg{} 1105 } 1106} 1107 1108func (m Model) listenForEvents() tea.Cmd { 1109 return func() tea.Msg { 1110 event, ok := <-m.eventCh 1111 if !ok { 1112 return nil 1113 } 1114 return EventMsg{Event: event} 1115 } 1116} 1117 1118// Key bindings 1119var keys = struct { 1120 Quit key.Binding 1121 Help key.Binding 1122 Escape key.Binding 1123 Enter key.Binding 1124 Tab key.Binding 1125 ShiftTab key.Binding 1126 Up key.Binding 1127 Down key.Binding 1128 NewMysis key.Binding 1129 Delete key.Binding 1130 Relaunch key.Binding 1131 Stop key.Binding 1132 Broadcast key.Binding 1133 Message key.Binding 1134 Configure key.Binding 1135 End key.Binding 1136 VerboseToggle key.Binding 1137}{ 1138 Quit: key.NewBinding(key.WithKeys("q", "ctrl+c")), 1139 Help: key.NewBinding(key.WithKeys("?")), 1140 Escape: key.NewBinding(key.WithKeys("esc")), 1141 Enter: key.NewBinding(key.WithKeys("enter")), 1142 Tab: key.NewBinding(key.WithKeys("tab")), 1143 ShiftTab: key.NewBinding(key.WithKeys("shift+tab")), 1144 Up: key.NewBinding(key.WithKeys("up", "k")), 1145 Down: key.NewBinding(key.WithKeys("down", "j")), 1146 NewMysis: key.NewBinding(key.WithKeys("n")), 1147 Delete: key.NewBinding(key.WithKeys("d")), 1148 Relaunch: key.NewBinding(key.WithKeys("r")), 1149 Stop: key.NewBinding(key.WithKeys("s")), 1150 Broadcast: key.NewBinding(key.WithKeys("b")), 1151 Message: key.NewBinding(key.WithKeys("m")), 1152 Configure: key.NewBinding(key.WithKeys("c")), 1153 End: key.NewBinding(key.WithKeys("end", "G")), 1154 VerboseToggle: key.NewBinding(key.WithKeys("v")), 1155}