From 1204689de07918d85fed2d4df9aba0c36f9743a0 Mon Sep 17 00:00:00 2001 From: Kartios Date: Mon, 31 Aug 2026 17:18:55 -0700 Subject: [PATCH] feat: make terminal the primary workspace surface --- README.md | 9 +- docs/ARCHITECTURE.md | 18 +- docs/PRODUCT_SPEC.md | 6 + docs/RESEARCH.md | 7 + docs/RESEARCH_SNAPSHOTS.md | 2 + docs/TESTING.md | 7 +- docs/UI_SPIKE_SCORECARD.md | 14 +- docs/UX_VERTICAL_SLICE.md | 36 +- .../0008-primary-terminal-3x1-workspace.md | 23 + spikes/README.md | 5 +- spikes/gpui-shell/src/main.rs | 673 ++++++++++++++---- 11 files changed, 643 insertions(+), 157 deletions(-) create mode 100644 docs/decisions/0008-primary-terminal-3x1-workspace.md diff --git a/README.md b/README.md index 5245ac8..ff7adc1 100644 --- a/README.md +++ b/README.md @@ -18,11 +18,12 @@ as installable binaries; building from source will remain supported. This repository is in architecture and vertical-slice phase. The installable binary is still a scaffold, while the isolated native UI spikes now exercise an -interactive six-surface workspace and the root workspace contains the first +interactive 3×1 workspace backed by six live comparison surfaces and the root workspace contains the first bounded local PTY, runtime-actor, VT engine, and capability-gated workspace -command boundaries. The GPUI slice renders one real actor-owned VT session beside -five deterministic surfaces. We are still validating the dedicated styled -terminal renderer, standalone runtime IPC/durability, ACP integration, +command boundaries. The GPUI slice renders one styled actor-owned VT session in +the primary 60% work band while five deterministic surfaces keep updating in the +background. We are still validating selection/scrollback rendering, standalone +runtime IPC/durability, ACP integration, packaging, and usage-data contracts before a large implementation. ## Product shape diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 1251a1d..5adc9b0 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -69,12 +69,24 @@ The first `lumbridge-runtime` actor now owns one `PtySession` on a dedicated thread. Bounded command and event queues serialize input, resize, close, and shutdown against ordered raw-byte output. The GPUI slice feeds one actor session through the terminal engine while five surfaces retain deterministic comparison -output. Its current text adapter intentionally renders plain rows and does not -yet paint cell styles, selection, or the cursor; the next rendering slice owns -that work. This actor still runs in-process; moving the same framework-neutral +output. Its adapter groups adjacent cells into native GPUI paint runs and renders +ANSI/indexed/RGB colors, emphasis, hyperlinks, and cursor shapes. Window geometry +drives terminal rows and columns and resizes both the engine and PTY. Selection, +scrollback navigation, mouse reporting, and a lower-level terminal canvas remain. +This actor still runs in-process; moving the same framework-neutral contract behind local authenticated IPC is the next durability step. See decisions 0004 and 0005. +## Default workspace composition + +The default desktop workspace is a vertical 3×1 composition: the top 20% holds +pane, agent, tool, context, and goal state; the middle 60% is the active terminal +or work surface; the bottom 20% is the answer, choice, chat, and approval shelf. +Six deterministic surfaces still update in the spike so performance comparisons +remain meaningful, but only the selected surface owns the large work region. +Users may deliberately split that region later; a dashboard grid is not the +calm default. See decision 0008. + We should evaluate, not blindly copy, WezTerm, Zellij, RMUX, tmux, and cmux. The first spike must compare a reusable terminal crate with a small first-party layer. Remaining correctness cases include OSC 8 links, Kitty diff --git a/docs/PRODUCT_SPEC.md b/docs/PRODUCT_SPEC.md index ce625a5..dc8fb1a 100644 --- a/docs/PRODUCT_SPEC.md +++ b/docs/PRODUCT_SPEC.md @@ -66,6 +66,12 @@ surface change never silently launches a process, moves the pane to another host, or changes which agent owns the session. Unsupported surfaces are shown as unavailable rather than simulated. +The default workspace is a 3×1 vertical composition: the top 20% shows context, +pane/agent state, tools, and goal; the middle 60% is the selected terminal or +work surface; the bottom 20% is the decision shelf. Multiple panes may continue +working offscreen and remain one shortcut away. Explicit split and dashboard +layouts remain supported, but they do not displace the primary-terminal default. + An optional decision shelf sits below the active work surface. It may show an answer draft, two or three concrete choices, why each was suggested, and the capability each choice would need. Suggestions are inert data. Choosing one may diff --git a/docs/RESEARCH.md b/docs/RESEARCH.md index 2b70db5..fb46b6e 100644 --- a/docs/RESEARCH.md +++ b/docs/RESEARCH.md @@ -32,6 +32,13 @@ They are shallow snapshots for study, not dependencies or vendored source. - `block/buzz`: Rust human/agent collaboration plus production ACP harness design. - `bbarit/terminal`: Rust agent terminal/IDE ideas. No top-level license file was present in the captured snapshot, so do not reuse implementation code. +- `OnlyTerp/opengrok`: provider-wire maps, behavioral verification of reasoning + controls, local-key posture, drift detection, and fail-closed provider UX; + MIT, but its Grok Bot patching is product-specific reference work. +- `elie222/rakazo`: persistent AI teammates, delegation, routines, computer + providers, browser/terminal/desktop tools, and deterministic sandbox testing; + Apache-2.0. Its Electron/React/Postgres architecture is research-only because + Lumbridge's shell and local runtime remain native Rust and SQLite. ## Protocols diff --git a/docs/RESEARCH_SNAPSHOTS.md b/docs/RESEARCH_SNAPSHOTS.md index 958e71e..476df0c 100644 --- a/docs/RESEARCH_SNAPSHOTS.md +++ b/docs/RESEARCH_SNAPSHOTS.md @@ -18,6 +18,8 @@ checkouts are reference material and are not part of Lumbridge's source tree. | Agent IDEs | Orca | `main` | `02a7742406a5` | 322 MB | `stablyai/orca` | | Agent IDEs | Xum | `main` | `a4be59aade55` | 76 MB | `coder/xum` | | Agent IDEs | Zed | `main` | `ce48461eaadd` | 118 MB | `zed-industries/zed` | +| Agent IDEs | OpenGrok | `main` | `2b356649cfe5` | 5.4 MB | `OnlyTerp/opengrok` | +| Agent IDEs | Rakazo | `main` | `7e1ef9ea5d5d` | 30 MB | `elie222/rakazo` | | Protocols | ACP specification | `main` | `f76fe3f3d132` | 67 MB | `agentclientprotocol/agent-client-protocol` | | Protocols | ACP Rust SDK | `main` | `754d5aa1ce2c` | 4.5 MB | `agentclientprotocol/rust-sdk` | | Harnesses | Codex | `main` | `17e8101699c5` | 103 MB | `openai/codex` | diff --git a/docs/TESTING.md b/docs/TESTING.md index 7db0103..4f139a8 100644 --- a/docs/TESTING.md +++ b/docs/TESTING.md @@ -118,9 +118,10 @@ who already have the final cargo-watch release installed. blocked OSC 52 behavior, key encoding, application-cursor mode, and resize. - `lumbridge-core` tests capability-gated split/select/rename/close commands, idempotent request IDs, close-tree promotion, and atomic agentic setup plans. -- The GPUI slice tests its key-event adapter. It renders one real actor-owned VT - session as plain snapshot rows and keeps five surfaces deterministic; styled - cell/cursor rendering remains a separate gate. +- The GPUI slice tests its key-event adapter, 20/60/20 geometry-to-PTY sizing, + xterm 256-color conversion, styled-run coalescing, and cursor-run boundaries. + It renders one real actor-owned VT session while five surfaces continue their + deterministic background workload. - The current-GPUI probe compile-checks real AccessKit element wiring and real platform input-handler installation. Unit tests cover its semantic tree and UTF-16/UTF-8 composed-text mutations. OS screen readers, IME candidate windows, diff --git a/docs/UI_SPIKE_SCORECARD.md b/docs/UI_SPIKE_SCORECARD.md index 6cc9020..172a352 100644 --- a/docs/UI_SPIKE_SCORECARD.md +++ b/docs/UI_SPIKE_SCORECARD.md @@ -22,10 +22,11 @@ from macOS and Linux and the hard gates pass. | API clarity and maintenance burden | review | pending | pending | The current programs establish dependency, build, launch, and interaction -baselines. GPUI now routes a real PTY through a VT engine and keyboard encoder; -its renderer still flattens the immutable screen snapshot to plain rows. The -next iteration adds styled cells/cursor/selection, measured pane-driven resize, -a native Markdown editor, and one isolated browser child. +baselines. GPUI now routes a real PTY through a VT engine and keyboard encoder, +paints coalesced styled cell runs and cursor shapes, and derives PTY rows/columns +from its 60% terminal band when the window changes. Selection, scrollback +navigation, mouse modes, a native Markdown editor, and one isolated browser child +remain. ## Ubuntu baseline — metal, 2026-08-31 @@ -86,8 +87,9 @@ fallback. ## Measurement semantics Both renderers retain the same all-deterministic six-surface action stream for -comparison. The GPUI integration mode replaces one terminal fixture with a real -actor-owned VT session and leaves five deterministic surfaces running. Counters +comparison. GPUI now presents the selected surface in a 20/60/20 vertical +workspace while one terminal fixture is replaced with a real actor-owned VT +session and five deterministic surfaces keep running offscreen. Counters separate external PTY batches/lines from total model updates. The GPUI footer reports dispatch-to-element-build p50/p95 over a bounded 256-sample window. It is deliberately not called key-to-present or frame-present latency: neither diff --git a/docs/UX_VERTICAL_SLICE.md b/docs/UX_VERTICAL_SLICE.md index 36154ef..2097612 100644 --- a/docs/UX_VERTICAL_SLICE.md +++ b/docs/UX_VERTICAL_SLICE.md @@ -9,15 +9,13 @@ framework decision gate, not a decorative dashboard. ## Current-run audit -The 2026-08-31 GPUI baseline succeeds at calm density: the six surfaces are easy -to scan, typography is consistent, and local/remote targets remain visible. It -fails the task flow in four important ways: - -1. all panes have equal visual priority, so `NEEDS INPUT` is too easy to miss; -2. no pane exposes visible keyboard focus or selection; -3. the command palette affordance has no interaction behind it; -4. status and usage text in the footer is too quiet to explain provenance or - confidence at a glance. +The first 2026-08-31 GPUI baseline proved six-surface density but gave every +pane equal visual priority. The current slice replaces that dashboard with a +3×1 default: 20% context and pane selection, 60% active work surface, and 20% +decision shelf. Keyboard focus, command-palette input, live PTY input, styled VT +cells, cursor shapes, and geometry-driven resize are wired. Remaining visible +gaps are terminal selection/scrollback, real decision-shelf actions, usage-detail +provenance, and end-to-end platform accessibility/IME. Screenshots for the audit are stored outside Git under `~/shots/2026-08/lumbridge-ui-audit/`. Accessibility and IME correctness cannot @@ -60,11 +58,12 @@ surface rather than a hosted Lumbridge control plane. palette shortcut. 2. The sidebar starts with a compact `ATTENTION` group, followed by workspaces and remote hosts. It does not become a notification feed. -3. The active pane receives a two-pixel accent edge plus a quiet tinted header. -4. A waiting pane uses an amber semantic label and remains visible when another - pane is selected. The label always includes words such as `NEEDS INPUT`. -5. Pane headers expose title, execution target, harness state, and unread count - in a stable order. +3. A compact top 20% context band keeps all pane identities and states visible; + the selected pane receives the accent treatment. +4. A waiting pane uses an amber semantic label in both the context band and + attention sidebar. The label always includes words such as `NEEDS INPUT`. +5. The middle 60% gives the selected terminal or work surface uninterrupted + reading space and retains target, harness state, dimensions, and surface tabs. 6. The footer groups connection state, selected-harness identity, usage-window provenance, and burn forecast into readable regions. 7. The selected pane has a quiet surface strip for Terminal, Browser, Tools, @@ -75,7 +74,7 @@ surface rather than a hosted Lumbridge control plane. ## Keyboard task flow -- `Alt+Arrow` or `Alt+h/j/k/l`: move focus through the 2×3 pane grid while +- `Alt+Arrow` or `Alt+h/j/k/l`: move selection through the pane topology while leaving ordinary terminal arrows and text available to the PTY. - `Alt+1` through `Alt+6`: focus a pane directly while leaving terminal digits available to the PTY. @@ -93,8 +92,8 @@ receive the same state transitions and tests. - In the first actor integration, one terminal pane consumes ordered output from a real local PTY while each deterministic tick updates the other five - surfaces. The all-deterministic constructor remains available for framework - comparison and replay tests. + surfaces offscreen. The all-deterministic constructor remains available for + framework comparison and replay tests. - One pane enters and leaves `needs input` through a deterministic event. - Markdown, browser-boundary, and review panes update counters without using a web application shell. @@ -103,7 +102,8 @@ receive the same state transitions and tests. element-build timing is never presented as display-present timing. - The PTY actor replaces exactly one synthetic stream without changing focus or layout contracts. Synthetic streams stay available for repeatable performance - tests. Raw lines do not claim terminal-emulation fidelity. + tests. Live bytes are parsed into VT state and coalesced native paint runs; + deterministic fixture text makes no terminal-emulation claim. ## Hard gates diff --git a/docs/decisions/0008-primary-terminal-3x1-workspace.md b/docs/decisions/0008-primary-terminal-3x1-workspace.md new file mode 100644 index 0000000..de7168d --- /dev/null +++ b/docs/decisions/0008-primary-terminal-3x1-workspace.md @@ -0,0 +1,23 @@ +# 0008: The default workspace is a primary-terminal 3×1 composition + +Status: accepted for the native vertical slice. + +Lumbridge defaults to three vertical bands in one column. The top 20% exposes +pane, agent, tools, context, goal, target, and attention state. The middle 60% +belongs to the active terminal or work surface. The bottom 20% holds answers, +choices, chat, approvals, and the local-analyst boundary. + +This composition favors the surface where engineers type and read for most of +the day. It keeps context and decisions visible without making six equally sized +cards compete for attention. Pane selectors and keyboard shortcuts switch the +large work surface. Users may later create deliberate splits or dashboard grids, +but those are workspace choices rather than the default visual hierarchy. + +The framework spike retains six updating surfaces even when five are offscreen. +That preserves the earlier streaming and reducer workload for performance +comparison. Hidden surfaces do not receive keyboard input merely because they +continue to update. + +Window geometry determines the middle band's terminal rows and columns. The UI +resizes the terminal engine and PTY through the bounded runtime actor; it does +not resize only the text view or infer terminal wrapping after the fact. diff --git a/spikes/README.md b/spikes/README.md index 94909b1..7aa7d96 100644 --- a/spikes/README.md +++ b/spikes/README.md @@ -23,8 +23,9 @@ GPUI also has an integration mode with one real local PTY owned by shared model retain the all-deterministic mode for like-for-like framework comparison. GPUI feeds raw output through `lumbridge-terminal` and sends encoded keyboard input and terminal protocol replies through the bounded runtime actor. -Its visual adapter currently flattens the VT snapshot to plain rows, so styled -cells, selection, and cursor painting remain intentionally unfinished. +Its visual adapter coalesces VT cells into native styled runs, paints cursor +shapes, and resizes the engine and PTY from the middle 60% work band. Selection, +scrollback navigation, and mouse input remain intentionally unfinished. Build independently: diff --git a/spikes/gpui-shell/src/main.rs b/spikes/gpui-shell/src/main.rs index 9cbc4a0..2068322 100644 --- a/spikes/gpui-shell/src/main.rs +++ b/spikes/gpui-shell/src/main.rs @@ -2,8 +2,8 @@ use std::collections::VecDeque; use std::time::{Duration, Instant}; use gpui::{ - App, Application, Bounds, Context, FocusHandle, KeyBinding, KeyDownEvent, Window, WindowBounds, - WindowOptions, actions, div, prelude::*, px, rgb, size, + App, Application, Bounds, Context, FocusHandle, FontWeight, KeyBinding, KeyDownEvent, Pixels, + Size, Window, WindowBounds, WindowOptions, actions, div, prelude::*, px, relative, rgb, size, }; use lumbridge_runtime::{ CommandConfig, PtyOptions, RuntimeActor, RuntimeActorError, RuntimeActorOptions, @@ -14,8 +14,9 @@ use lumbridge_spike_model::{ ShellModel, SurfaceKind, WORKSPACES, }; use lumbridge_terminal::{ - KeyModifiers, TerminalDimensions, TerminalEngine, TerminalEngineOptions, TerminalKey, - TerminalKeyEvent, + KeyModifiers, TerminalCellStyle, TerminalColor, TerminalCursorShape, TerminalDimensions, + TerminalEngine, TerminalEngineOptions, TerminalKey, TerminalKeyEvent, TerminalNamedColor, + TerminalSnapshot, }; const BG: u32 = 0x090c12; @@ -34,6 +35,14 @@ const RUNTIME_POLL_INTERVAL: Duration = Duration::from_millis(16); const RUNTIME_DRAIN_LIMIT: usize = 64; const LIVE_PANE: PaneId = PaneId::CodexRuntime; const LIVE_PTY_SCRIPT: &str = "printf 'Lumbridge interactive PTY · type here\\n'; exec /bin/sh -i"; +const SIDEBAR_WIDTH: f32 = 248.0; +const APP_HEADER_HEIGHT: f32 = 48.0; +const TAB_BAR_HEIGHT: f32 = 38.0; +const APP_FOOTER_HEIGHT: f32 = 32.0; +const TERMINAL_CHROME_HEIGHT: f32 = 72.0; +const TERMINAL_HORIZONTAL_INSET: f32 = 32.0; +const TERMINAL_CELL_WIDTH: f32 = 8.4; +const TERMINAL_CELL_HEIGHT: f32 = 18.0; const TERMINAL_ROW_STEP: u16 = 2; const TERMINAL_COLUMN_STEP: u16 = 10; @@ -65,6 +74,7 @@ struct LumbridgeShell { runtime: Option, runtime_status: LiveRuntimeStatus, terminal: TerminalEngine, + terminal_snapshot: TerminalSnapshot, last_runtime_sequence: u64, root_focus: FocusHandle, pane_focus: [FocusHandle; 6], @@ -123,6 +133,171 @@ struct RenderTiming { dispatch_to_element_micros: VecDeque, } +#[derive(Clone, Eq, PartialEq)] +struct TerminalPaintRun { + text: String, + columns: u16, + foreground: u32, + background: u32, + style: TerminalCellStyle, + cursor: Option, + hyperlink: bool, +} + +impl TerminalPaintRun { + fn can_merge(&self, other: &Self) -> bool { + self.foreground == other.foreground + && self.background == other.background + && self.style == other.style + && self.cursor == other.cursor + && self.hyperlink == other.hyperlink + } +} + +fn terminal_paint_rows(snapshot: &TerminalSnapshot) -> Vec> { + (0..snapshot.dimensions.rows()) + .map(|row| { + let mut runs: Vec = Vec::new(); + for column in 0..snapshot.dimensions.columns() { + let Some(cell) = snapshot.cell(row, column) else { + continue; + }; + if cell.wide_spacer { + continue; + } + + let mut foreground = terminal_color(cell.foreground); + let mut background = terminal_color(cell.background); + if cell.style.contains(TerminalCellStyle::INVERSE) { + std::mem::swap(&mut foreground, &mut background); + } + if cell.style.contains(TerminalCellStyle::DIM) { + foreground = dim_color(foreground); + } + if cell.style.contains(TerminalCellStyle::HIDDEN) { + foreground = background; + } + + let cursor = (snapshot.cursor.row == row + && snapshot.cursor.column == column + && snapshot.cursor.shape != TerminalCursorShape::Hidden) + .then_some(snapshot.cursor.shape); + let text = if cell.text.is_empty() { + " ".to_owned() + } else { + cell.text.clone() + }; + let next = TerminalPaintRun { + text, + columns: if cell.wide { 2 } else { 1 }, + foreground, + background, + style: cell.style, + cursor, + hyperlink: cell.hyperlink.is_some(), + }; + + if let Some(current) = runs.last_mut() + && current.can_merge(&next) + { + current.text.push_str(&next.text); + current.columns = current.columns.saturating_add(next.columns); + continue; + } + runs.push(next); + } + runs + }) + .collect() +} + +fn terminal_color(color: TerminalColor) -> u32 { + match color { + TerminalColor::Rgb { red, green, blue } => { + (u32::from(red) << 16) | (u32::from(green) << 8) | u32::from(blue) + } + TerminalColor::Indexed(index) => indexed_terminal_color(index), + TerminalColor::Named(named) => match named { + TerminalNamedColor::Black => 0x1d2430, + TerminalNamedColor::Red => 0xff6b6b, + TerminalNamedColor::Green => 0x70d6a8, + TerminalNamedColor::Yellow => 0xf1c76a, + TerminalNamedColor::Blue => 0x68b5f8, + TerminalNamedColor::Magenta => 0xc79bf2, + TerminalNamedColor::Cyan => 0x63d5da, + TerminalNamedColor::White => 0xdbe5f4, + TerminalNamedColor::BrightBlack => 0x6d7a91, + TerminalNamedColor::BrightRed => 0xff8b8b, + TerminalNamedColor::BrightGreen => 0x93e6be, + TerminalNamedColor::BrightYellow => 0xf8d98c, + TerminalNamedColor::BrightBlue => 0x8bc8ff, + TerminalNamedColor::BrightMagenta => 0xd9b4fb, + TerminalNamedColor::BrightCyan => 0x86e7eb, + TerminalNamedColor::BrightWhite | TerminalNamedColor::BrightForeground => 0xf4f8ff, + TerminalNamedColor::Foreground => TEXT, + TerminalNamedColor::Background => BG, + TerminalNamedColor::Cursor => 0xf4f8ff, + TerminalNamedColor::DimBlack => 0x121820, + TerminalNamedColor::DimRed => 0x9f4a4a, + TerminalNamedColor::DimGreen => 0x4e9878, + TerminalNamedColor::DimYellow => 0xa88a49, + TerminalNamedColor::DimBlue => 0x477fac, + TerminalNamedColor::DimMagenta => 0x896ca4, + TerminalNamedColor::DimCyan => 0x459397, + TerminalNamedColor::DimWhite | TerminalNamedColor::DimForeground => MUTED, + }, + } +} + +fn indexed_terminal_color(index: u8) -> u32 { + const ANSI: [u32; 16] = [ + 0x1d2430, 0xff6b6b, 0x70d6a8, 0xf1c76a, 0x68b5f8, 0xc79bf2, 0x63d5da, 0xdbe5f4, 0x6d7a91, + 0xff8b8b, 0x93e6be, 0xf8d98c, 0x8bc8ff, 0xd9b4fb, 0x86e7eb, 0xf4f8ff, + ]; + match index { + 0..=15 => ANSI[usize::from(index)], + 16..=231 => { + const LEVELS: [u32; 6] = [0, 95, 135, 175, 215, 255]; + let offset = u32::from(index - 16); + let red = LEVELS[(offset / 36) as usize]; + let green = LEVELS[((offset % 36) / 6) as usize]; + let blue = LEVELS[(offset % 6) as usize]; + (red << 16) | (green << 8) | blue + } + 232..=255 => { + let level = 8 + 10 * u32::from(index - 232); + (level << 16) | (level << 8) | level + } + } +} + +fn dim_color(color: u32) -> u32 { + let dim = |channel: u32| channel * 13 / 20; + (dim((color >> 16) & 0xff) << 16) | (dim((color >> 8) & 0xff) << 8) | dim(color & 0xff) +} + +fn terminal_dimensions_for_window(window_size: Size) -> TerminalDimensions { + let width = f32::from(window_size.width); + let height = f32::from(window_size.height); + let workspace_height = + (height - APP_HEADER_HEIGHT - TAB_BAR_HEIGHT - APP_FOOTER_HEIGHT).max(0.0); + let terminal_height = (workspace_height * 0.60 - TERMINAL_CHROME_HEIGHT).max(0.0); + let terminal_width = (width - SIDEBAR_WIDTH - TERMINAL_HORIZONTAL_INSET).max(0.0); + let rows = (terminal_height / TERMINAL_CELL_HEIGHT) + .floor() + .clamp(2.0, f32::from(u16::MAX)); + let columns = (terminal_width / TERMINAL_CELL_WIDTH) + .floor() + .clamp(20.0, f32::from(u16::MAX)); + TerminalDimensions::with_cell_size( + rows as u16, + columns as u16, + TERMINAL_CELL_WIDTH.round() as u16, + TERMINAL_CELL_HEIGHT.round() as u16, + ) + .expect("geometry clamps terminal dimensions above zero") +} + impl RenderTiming { fn mark_dispatch(&mut self) { self.pending_dispatch = Some(Instant::now()); @@ -207,12 +382,23 @@ impl LumbridgeShell { }) .detach(); - let terminal = TerminalEngine::new(TerminalEngineOptions::default()); + let terminal_dimensions = terminal_dimensions_for_window(window.bounds().size); + let terminal = TerminalEngine::new(TerminalEngineOptions { + dimensions: terminal_dimensions, + ..TerminalEngineOptions::default() + }); + let terminal_snapshot = terminal.snapshot(); let (runtime, runtime_status) = match start_live_runtime(terminal.dimensions()) { Ok(runtime) => (Some(runtime), LiveRuntimeStatus::Starting), Err(error) => (None, LiveRuntimeStatus::Fault(error.to_string())), }; + cx.observe_window_bounds(window, |shell, window, cx| { + let dimensions = terminal_dimensions_for_window(window.bounds().size); + shell.resize_terminal(dimensions.rows(), dimensions.columns(), cx); + }) + .detach(); + Self { model: ShellModel::with_external_output(LIVE_PANE) .expect("the live comparison pane is a terminal"), @@ -220,6 +406,7 @@ impl LumbridgeShell { runtime, runtime_status, terminal, + terminal_snapshot, last_runtime_sequence: 0, root_focus, pane_focus, @@ -316,7 +503,9 @@ impl LumbridgeShell { } fn publish_terminal_snapshot(&mut self) { - let lines = self.terminal.snapshot().plain_rows(); + let snapshot = self.terminal.snapshot(); + let lines = snapshot.plain_rows(); + self.terminal_snapshot = snapshot; self.dispatch(ShellAction::ReplaceExternalOutput { pane: LIVE_PANE, lines, @@ -474,11 +663,10 @@ impl LumbridgeShell { cx.notify(); } - fn pane_card( + fn pane_selector( pane: &PaneState, selected: bool, runtime_status: LiveRuntimeStatus, - terminal_dimensions: TerminalDimensions, focus: FocusHandle, cx: &mut Context, ) -> gpui::AnyElement { @@ -500,147 +688,296 @@ impl LumbridgeShell { } else { ACCENT }; - let line_start = pane.lines().len().saturating_sub(12); div() .id(("pane", id.index())) .track_focus(&focus) .tab_index(id.index() as isize + 1) .flex() - .flex_col() - .min_w_0() - .min_h_0() - .overflow_hidden() - .bg(rgb(if selected { PANEL_ACTIVE } else { PANEL })) + .items_center() + .justify_between() + .gap_3() + .h_full() + .min_w(px(172.0)) + .px_3() + .bg(rgb(if selected { PANEL_ACTIVE } else { PANEL_ALT })) .border_1() .border_color(rgb(if selected || needs_input { state_color } else { - BORDER + BORDER_QUIET })) .rounded(px(5.0)) - .when(selected, |view| view.border_2()) .on_click(cx.listener(move |shell, _, window, cx| { shell.select_pane(id, window, cx); })) .child( div() .flex() - .items_center() - .justify_between() - .px_3() - .h(px(36.0)) - .flex_none() - .bg(rgb(if selected { PANEL_ACTIVE } else { PANEL_ALT })) - .border_b_1() - .border_color(rgb(BORDER_QUIET)) - .text_sm() - .text_color(rgb(TEXT)) + .flex_col() + .min_w_0() .child( div() - .flex() - .items_center() - .gap_2() - .child( - div() - .text_xs() - .text_color(rgb(MUTED)) - .child(format!("{}", id.index() + 1)), - ) + .truncate() + .text_sm() + .text_color(rgb(TEXT)) .child(if external { - "Shell · VT session" + "Terminal · local shell" } else { pane.fixture().title }), ) - .child(div().text_xs().text_color(rgb(state_color)).child(label)), + .child( + div() + .mt_1() + .truncate() + .text_xs() + .text_color(rgb(MUTED)) + .child(pane.fixture().target.to_owned()), + ), ) + .child(div().text_xs().text_color(rgb(state_color)).child(label)) + .into_any_element() + } + + fn terminal_run(run: TerminalPaintRun) -> gpui::AnyElement { + let cursor = run.cursor; + div() + .flex_none() + .h(px(TERMINAL_CELL_HEIGHT)) + .w(px(f32::from(run.columns) * TERMINAL_CELL_WIDTH)) + .overflow_hidden() + .whitespace_nowrap() + .text_color(rgb(run.foreground)) + .bg(rgb(run.background)) + .when(run.style.contains(TerminalCellStyle::BOLD), |view| { + view.font_weight(FontWeight::BOLD) + }) + .when(run.style.contains(TerminalCellStyle::ITALIC), |view| { + view.italic() + }) + .when( + run.style.contains(TerminalCellStyle::UNDERLINE) + || run.style.contains(TerminalCellStyle::DOUBLE_UNDERLINE) + || run.style.contains(TerminalCellStyle::UNDERCURL) + || run.style.contains(TerminalCellStyle::DOTTED_UNDERLINE) + || run.style.contains(TerminalCellStyle::DASHED_UNDERLINE) + || run.hyperlink, + |view| view.underline(), + ) + .when(run.style.contains(TerminalCellStyle::STRIKEOUT), |view| { + view.line_through() + }) + .when(cursor == Some(TerminalCursorShape::Block), |view| { + view.bg(rgb(TEXT)).text_color(rgb(BG)) + }) + .when(cursor == Some(TerminalCursorShape::HollowBlock), |view| { + view.border_1().border_color(rgb(TEXT)) + }) + .when(cursor == Some(TerminalCursorShape::Underline), |view| { + view.border_b_2().border_color(rgb(TEXT)) + }) + .when(cursor == Some(TerminalCursorShape::Beam), |view| { + view.border_l_2().border_color(rgb(TEXT)) + }) + .child(run.text) + .into_any_element() + } + + fn terminal_view(&self) -> gpui::AnyElement { + let rows = terminal_paint_rows(&self.terminal_snapshot) + .into_iter() + .map(|runs| { + div() + .flex() + .h(px(TERMINAL_CELL_HEIGHT)) + .flex_none() + .children(runs.into_iter().map(Self::terminal_run)) + }) + .collect::>(); + div() + .flex() + .flex_col() + .size_full() + .overflow_hidden() + .bg(rgb(BG)) + .font_family("monospace") + .text_size(px(13.0)) + .children(rows) + .into_any_element() + } + + fn work_surface(&self) -> gpui::AnyElement { + let pane = self.model.pane(self.model.selected_pane()); + let external = pane.output_source() == OutputSource::External; + let status = if external { + self.runtime_status.badge() + } else { + pane.fixture().badge + }; + let detail = if external { + self.runtime_status.detail() + } else { + pane.fixture().target.to_owned() + }; + let surface_status = if external { + format!( + "{} · {}×{} · auto-fit", + status, + self.terminal.dimensions().columns(), + self.terminal.dimensions().rows() + ) + } else { + status.to_owned() + }; + let surface = match pane.kind() { + SurfaceKind::Terminal => "TERMINAL", + SurfaceKind::Markdown => "CONTEXT", + SurfaceKind::Browser => "BROWSER", + SurfaceKind::Review => "REVIEW", + }; + let tabs = ["TERMINAL", "BROWSER", "TOOLS", "CONTEXT", "GOAL", "REVIEW"] + .into_iter() + .map(|label| { + div() + .h_full() + .flex() + .items_center() + .px_3() + .text_xs() + .text_color(rgb(if label == surface { ACCENT } else { MUTED })) + .when(label == surface, |view| { + view.border_b_2().border_color(rgb(ACCENT)) + }) + .child(label) + }) + .collect::>(); + let content = if external { + self.terminal_view() + } else { + let start = pane.lines().len().saturating_sub(18); + div() + .flex() + .flex_col() + .gap_1() + .size_full() + .overflow_hidden() + .font_family("monospace") + .text_sm() + .text_color(rgb(TEXT)) + .children(pane.lines()[start..].iter().cloned()) + .into_any_element() + }; + + div() + .flex() + .flex_col() + .size_full() + .min_h_0() + .overflow_hidden() + .bg(rgb(PANEL)) + .border_y_1() + .border_color(rgb(BORDER)) .child( div() .flex() .items_center() .justify_between() + .h(px(36.0)) + .flex_none() .px_3() - .py_2() - .text_xs() - .text_color(rgb(MUTED)) - .child(if external { - format!( - "{} · {}×{} · Alt+Shift+arrows resize", - runtime_status.detail(), - terminal_dimensions.columns(), - terminal_dimensions.rows() - ) - } else { - pane.fixture().target.to_owned() - }) - .when(selected, |view| view.child("FOCUSED")), + .bg(rgb(PANEL_ALT)) + .child( + div() + .flex() + .items_center() + .gap_3() + .text_sm() + .child(pane.fixture().title) + .child(div().text_xs().text_color(rgb(MUTED)).child(detail)), + ) + .child( + div() + .text_xs() + .text_color(rgb(SUCCESS)) + .child(surface_status), + ), ) - .when(external && selected, |view| { - view.child( - div() - .flex() - .items_center() - .gap_3() - .h(px(26.0)) - .flex_none() - .px_3() - .border_y_1() - .border_color(rgb(BORDER_QUIET)) - .bg(rgb(PANEL_ALT)) - .text_xs() - .child(div().text_color(rgb(ACCENT)).child("TERMINAL")) - .child(div().text_color(rgb(MUTED)).child("BROWSER")) - .child(div().text_color(rgb(MUTED)).child("TOOLS")) - .child(div().text_color(rgb(MUTED)).child("CONTEXT")) - .child(div().text_color(rgb(MUTED)).child("GOAL")) - .child(div().text_color(rgb(MUTED)).child("REVIEW")), - ) - }) .child( div() .flex() - .flex_col() + .h(px(28.0)) + .flex_none() + .px_1() + .bg(rgb(PANEL_ALT)) + .border_t_1() + .border_color(rgb(BORDER_QUIET)) + .children(tabs), + ) + .child( + div() .flex_1() .min_h_0() .overflow_hidden() - .gap_1() - .px_3() - .pb_3() - .text_sm() - .text_color(rgb(TEXT)) - .children(pane.lines()[line_start..].iter().cloned()), + .p_3() + .child(content), + ) + .into_any_element() + } + + fn decision_region(&self) -> gpui::AnyElement { + let choice = |label: &'static str, detail: &'static str| { + div() + .flex() + .flex_col() + .min_w(px(200.0)) + .px_3() + .py_2() + .rounded(px(5.0)) + .border_1() + .border_color(rgb(BORDER)) + .bg(rgb(PANEL_ALT)) + .text_sm() + .text_color(rgb(TEXT)) + .child(label) + .child(div().mt_1().text_xs().text_color(rgb(MUTED)).child(detail)) + }; + div() + .flex() + .flex_col() + .size_full() + .min_h_0() + .overflow_hidden() + .px_3() + .py_2() + .bg(rgb(PANEL)) + .child( + div() + .flex() + .items_center() + .justify_between() + .text_xs() + .child( + div() + .text_color(rgb(MUTED)) + .child("DECISION SHELF · answer, choices, approvals"), + ) + .child( + div() + .text_color(rgb(ATTENTION)) + .child("LOCAL ANALYST OFF · suggestions inert"), + ), + ) + .child( + div() + .flex() + .items_center() + .gap_2() + .mt_2() + .child(choice("Continue", "Keep the selected agent moving")) + .child(choice("Review plan", "Inspect capability-scoped commands")) + .child(choice("Ask…", "Refine before any action")), ) - .when(external && selected, |view| { - view.child( - div() - .flex() - .items_center() - .justify_between() - .gap_2() - .h(px(38.0)) - .flex_none() - .px_3() - .border_t_1() - .border_color(rgb(BORDER_QUIET)) - .bg(rgb(PANEL_ALT)) - .text_xs() - .child( - div() - .text_color(rgb(MUTED)) - .child("LOCAL ANALYST · OFF · suggestions only"), - ) - .child( - div() - .flex() - .gap_2() - .text_color(rgb(TEXT)) - .child("Continue") - .child("Review plan") - .child("Ask…"), - ), - ) - }) .into_any_element() } @@ -899,29 +1236,91 @@ impl Render for LumbridgeShell { .child("1 interactive VT · 5 deterministic · 1 waiting"), ); - let pane_cards = self + let pane_selectors = self .model .panes() .iter() .map(|pane| { - Self::pane_card( + Self::pane_selector( pane, self.model.selected_pane() == pane.id(), self.runtime_status.clone(), - self.terminal.dimensions(), self.pane_focus[pane.id().index()].clone(), cx, ) }) .collect::>(); - let grid = div() - .grid() - .grid_cols(3) - .grid_rows(2) - .gap_2() - .p_2() + let selected = self.model.pane(self.model.selected_pane()); + let workspace_stack = div() + .flex() + .flex_col() .size_full() - .children(pane_cards); + .min_h_0() + .overflow_hidden() + .child( + div() + .h(relative(0.20)) + .flex_none() + .flex() + .flex_col() + .min_h_0() + .overflow_hidden() + .px_3() + .py_2() + .bg(rgb(PANEL)) + .child( + div() + .flex() + .items_center() + .justify_between() + .text_xs() + .child( + div() + .text_color(rgb(MUTED)) + .child("CONTEXT · panes, agents, tools, goal"), + ) + .child( + div() + .text_color(rgb(if selected.needs_input() { + ATTENTION + } else { + SUCCESS + })) + .child(if selected.needs_input() { + "NEEDS INPUT · decision below" + } else { + "WORKSPACE HEALTHY" + }), + ), + ) + .child( + div() + .flex() + .items_center() + .gap_2() + .mt_2() + .flex_1() + .min_h_0() + .overflow_hidden() + .children(pane_selectors), + ), + ) + .child( + div() + .h(relative(0.60)) + .flex_none() + .min_h_0() + .overflow_hidden() + .child(self.work_surface()), + ) + .child( + div() + .h(relative(0.20)) + .flex_none() + .min_h_0() + .overflow_hidden() + .child(self.decision_region()), + ); let counters = self.model.counters(); let footer_left = format!( @@ -1014,7 +1413,7 @@ impl Render for LumbridgeShell { .flex_1() .min_w_0() .child(tabs) - .child(grid), + .child(workspace_stack), ), ) .child( @@ -1141,7 +1540,11 @@ fn main() { #[cfg(test)] mod tests { - use super::{KeyModifiers, TerminalKey, terminal_key_from_parts}; + use super::{ + KeyModifiers, TerminalEngine, TerminalEngineOptions, TerminalKey, indexed_terminal_color, + terminal_dimensions_for_window, terminal_key_from_parts, terminal_paint_rows, + }; + use gpui::{px, size}; #[test] fn maps_named_and_composed_gpui_keys_to_terminal_input() { @@ -1158,4 +1561,32 @@ mod tests { let control = terminal_key_from_parts("c", Some("c"), KeyModifiers::CONTROL).unwrap(); assert_eq!(control.key, TerminalKey::Text("c".into())); } + + #[test] + fn terminal_geometry_tracks_the_middle_sixty_percent() { + let dimensions = terminal_dimensions_for_window(size(px(1500.0), px(960.0))); + assert_eq!(dimensions.rows(), 24); + assert_eq!(dimensions.columns(), 145); + } + + #[test] + fn terminal_paint_rows_merge_runs_and_preserve_cursor_boundary() { + let mut terminal = TerminalEngine::new(TerminalEngineOptions::default()); + terminal.process(b"\x1b[31mAB\x1b[0m"); + let rows = terminal_paint_rows(&terminal.snapshot()); + assert!( + rows[0] + .iter() + .any(|run| run.text == "AB" && run.columns == 2) + ); + assert!(rows[0].iter().any(|run| run.cursor.is_some())); + } + + #[test] + fn xterm_color_cube_and_grayscale_are_deterministic() { + assert_eq!(indexed_terminal_color(16), 0x000000); + assert_eq!(indexed_terminal_color(231), 0xffffff); + assert_eq!(indexed_terminal_color(232), 0x080808); + assert_eq!(indexed_terminal_color(255), 0xeeeeee); + } }