Initial public release

Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
This commit is contained in:
Evan Whittaker
2026-10-17 12:08:30 -05:00
commit 09a7de2520
1730 changed files with 412952 additions and 0 deletions

433
crates/luxe-tui/src/app.rs Normal file
View File

@@ -0,0 +1,433 @@
//! TUI application state and message handling.
//!
//! Implements the Elm-style app loop: Msg → update → view.
use crate::dashboard::DashboardState;
use crate::editor::Editor;
use crate::guided_review::GuidedReviewWorkspace;
use crate::theme::styles::ThemeStyles;
use crate::workspace_dock::{DockList, DockListMetrics, DockState};
use crate::workspace_layout::WorkspaceLayout;
use luxe_core::config::Config;
use luxe_core::engine::Action;
use luxe_core::event::Event;
use luxe_core::guided_review::{GuidedReview, ReviewSession, ReviewSessionSaveRequestId};
use luxe_core::keymap::{KeyMap, UiAction};
use luxe_core::theme::ThemeRegistry;
use luxe_core::{ReviewLoadRequestId, ToolActivity, WorkspaceScopeId, WorkspaceSnapshot};
use std::collections::{HashMap, HashSet};
use tokio::sync::mpsc;
mod auth;
mod block_selection;
mod commands;
mod configuration;
mod construct;
mod conversation;
mod engine_send;
mod environment;
mod events;
mod images;
/// Key and mouse routing into [`Msg`].
///
/// Public because the review surface's router is worth testing directly and an integration test
/// cannot reach a `pub(crate)` one.
pub mod input;
pub(crate) mod messages;
#[cfg(test)]
pub(crate) use messages::github_post::item_count as github_post_item_count;
pub(crate) use messages::github_post::{
is_pull_request as github_post_is_pull_request, plan as github_post_plan,
refusal as github_post_refusal,
};
pub(crate) use messages::pull_request_opening::offered as pull_request_opening_offered;
pub(crate) use messages::review::reply_asks_for_fix;
pub(crate) use messages::review::window_sends;
pub(crate) use messages::review_draft::summary as review_draft_summary;
pub(crate) use messages::thread_answers::is_own_pull_request;
mod msg;
mod navigation;
mod opener;
mod outbox;
mod overlays;
mod pickers;
mod plan_handoff;
mod pointer;
mod queries;
mod review_edit;
mod review_mirror;
mod selection;
mod settings;
mod setup;
mod status;
mod submissions;
mod types;
mod workspace;
pub(crate) use construct::theme_notices;
pub(crate) use review_edit::ReviewEditPurpose;
pub(crate) use conversation::mcp_server;
pub use conversation::ToolRunFold;
use environment::AppEnvironment;
pub(crate) use input::chord_of;
pub use msg::*;
pub use opener::ExternalOpener;
pub use outbox::Outbox;
pub use overlays::Overlays;
pub use pointer::PointerState;
pub use review_mirror::ReviewMirror;
pub use status::{AppState, StatusModel};
pub use types::*;
/// Application state.
pub struct App {
pub editor: Editor,
pub convo: Vec<ConversationItem>,
next_provisional_turn: u64,
pub status: StatusModel,
pub should_quit: bool,
pub engine_tx: mpsc::Sender<Action>,
pub current_view: ViewMode,
pub active_guided_review_request: Option<ReviewLoadRequestId>,
pub guided_review: Option<Box<GuidedReview>>,
/// Route-local loading and focus state for the full-screen review workspace.
pub(crate) guided_review_workspace: GuidedReviewWorkspace,
/// The open review's session, what waits on the desk, and what was derived from it
pub review: ReviewMirror,
/// Whether the last conversation block is an assistant reply still being streamed
streaming: bool,
/// Whether the in-flight message streamed a reasoning block, which the commit refreshes in
/// place rather than adding fresh.
streamed_thinking: bool,
/// Which of a message's several reasoning blocks the streaming item belongs to, so the commit
/// can refresh it in place.
streaming_thinking_block: Option<usize>,
pub keymap: KeyMap,
pub config: Config,
/// Whether mouse capture is desired (`config.mouse`, flipped by `/mouse`); the event loop
/// reconciles the terminal to match.
pub mouse_enabled: bool,
/// Whether permission `ask`s are auto-approved (walk-away mode); `/permissions` flips it.
pub permission_auto_approve: bool,
/// Per-frame mouse hit-test regions, published by the render pass and read by `route_mouse`.
/// Behind a `RefCell` so the many `&App` render helpers can record regions without threading
/// a `&mut` through the whole view layer.
pub hit: std::cell::RefCell<crate::mouse::HitRegions>,
pub dock: DockState,
/// Largest useful dock scroll offset, written by the dock renderer each frame so wheel
/// scrolling can clamp without duplicating the layout math (interior-mutable: render is `&App`).
pub dock_scroll_max: std::cell::Cell<usize>,
/// What the same renderer measured about PLAN, FILES and ELSEWHERE, in that order, so a
/// wheel notch or a dragged thumb over one of them moves it without re-deriving the layout.
dock_lists: std::cell::Cell<[DockListMetrics; 3]>,
/// One file's diff, taking the conversation column. `None` when the transcript is showing.
pub(crate) changes: Option<crate::changes::ChangesView>,
pub files: crate::files::FilesTree,
/// Files outside the project this session has already looked at, and the ± they carried then.
///
/// Not [`ReviewMirror::seen`], which records what a review covered. Nothing can review a file
/// outside the project, so a look is all that can happen to one — and a place whose files have
/// all been looked at should stop taking rail. The counts are held with the path so a file
/// touched again since comes back unread.
pub(crate) external_seen: std::collections::HashMap<String, (u64, u64)>,
/// Places under ELSEWHERE the reader has folded or unfolded by hand, overriding the default.
pub(crate) external_folds: std::collections::HashMap<String, bool>,
pub statusline_state: crate::statusline_state::StatuslineState,
pub workspace_layout: WorkspaceLayout,
pub theme_styles: ThemeStyles,
/// Every theme a name can resolve to, read at start and again where one may have changed
pub(crate) themes: environment::Themes,
/// The commands the palette and `/` ran, most recent first, which lead the next menu
pub recent_commands: crate::commands::RecentCommands,
pub dashboard: Option<DashboardState>,
/// The frame the logotype is lit at, shared by every surface that draws it
pub banner: crate::widgets::BannerClock,
/// The command whose argument forms the reader put away, so they stay away while it is typed
pub slash_arguments_dismissed: Option<String>,
/// The GitHub rows referenced this session, by token target, so a mention sends what the row
/// is and not only its address
pub github_rows: crate::mentions::GithubRows,
/// Every row the last GitHub listing found, flattened and deduplicated, for the `@` picker;
/// `None` until something asked
pub github_listing: Option<Vec<luxe_core::github::ListItem>>,
/// The searches `/github`'s tabs were changed to this session, by the configured search each
/// replaces, so a tab reopens on what the reader last made it
pub github_searches: std::collections::HashMap<String, String>,
/// What each source row referenced this session stands for, by `kind:id`: the text the model
/// is sent in its place
pub mention_rows: crate::mentions::SourceRows,
/// The MCP servers whose tool names this conversation has been sent, so a second reference is
/// the pointer alone; cleared when compaction or a new session could have removed the first
pub mcp_listed: std::collections::HashSet<String>,
/// Each source's rows, by kind, once listed this session
pub mention_listings:
std::collections::HashMap<String, Vec<luxe_core::mention_source::MentionRow>>,
/// The plan file plan mode wrote during the turn in flight, offered a next step when it ends
pub plan_written: Option<String>,
/// The id of the question modal when it is the plan's handoff, which the TUI answers itself
pub plan_handoff: Option<luxe_core::question::QuestionRequestId>,
/// What to send once a fresh session has loaded: the plan, built from scratch
pub pending_build: Option<String>,
/// Whether the composer's draft goes out once a fresh session has loaded — a prompt typed on
/// the start screen, waiting for the session it asked for
pub send_draft_on_load: bool,
pub file_provider: crate::ref_provider::FileRefProvider,
/// The `@` picker's file list being read again, off the render thread
pub file_listing: FileListing,
/// The project a card's absolute path is shown relative to; `None` in a fixture
pub project_root: Option<std::path::PathBuf>,
/// Comments carried from reading a pull request, waiting for its checked-out review to load
pub carried_findings: Option<crate::main_loop::FixLaunch>,
/// The worktree `/worktree remove` asked about, waiting on the engine's fresh look at what is
/// uncommitted in it
pub worktree_removal_check: Option<std::path::PathBuf>,
/// The login engine, injected by the CLI (which owns config and the network).
pub auth_service: Option<crate::auth_wizard::AuthServiceHandle>,
/// Channel a spawned login task reports back on. Held so the app can build an interaction for
/// each flow it starts.
pub auth_tx: Option<tokio::sync::mpsc::Sender<crate::auth_wizard::AuthUiMsg>>,
/// Available models to browse in the picker (configured + models.dev), supplied by the CLI.
pub model_catalog: Vec<crate::model_picker::ModelEntry>,
/// Rebuild `model_catalog` when the picker opens, so config/catalog edits land mid-session,
/// and again off the frame once a local server has said what it is serving
pub model_sources: Option<crate::model_picker::ModelSources>,
/// Where `/sessions` reads the project's sessions from
pub(crate) session_catalog: navigation::SessionCatalog,
/// Full info for the active model, used to annotate the thinking picker's supported levels.
pub active_model_info: Option<luxe_core::provider::ModelInfo>,
pub scroll_state: crate::scroll::ScrollState,
/// First visible semantic conversation position from the latest render.
pub conversation_anchor: Option<ConversationAnchor>,
/// Asks parked for the event loop to run between frames
pub outbox: Outbox,
pub pointer: PointerState,
/// What is drawn over the view, taking its input while open
pub overlays: Overlays,
/// The transcript search; active while its query is non-empty
pub search_state: crate::search::SearchState,
pub reveal: crate::reveal::Reveal,
/// Notifier for turn-end feedback: a desktop notification through the terminal
pub notifier: Box<dyn crate::notify::Notifier>,
/// Whether the terminal has focus, once it has said; `None` until its first focus report, or
/// for a terminal that never sends one
pub terminal_focused: Option<bool>,
/// Whether this is a headless run, which suppresses notifications
pub headless: bool,
/// Whether submit sends `Action::EditResend` instead of `SubmitUserMessage`
edit_resend_mode: bool,
/// When an interrupt was sent that the engine has not yet confirmed by ending the turn.
pub(crate) interrupt_sent_at: Option<std::time::Instant>,
/// Whether this session has already been told that nothing is selected.
///
/// One line, however many times the reader presses Enter before choosing: the picker opening
/// over the composer is the message after the first time.
said_to_choose_a_model: bool,
/// Transcript items recording a submission that was dropped before it ever ran.
pub never_sent: HashSet<ConversationItemId>,
/// Mid-turn submissions pinned above the composer, in submission order.
pub pending_submissions: Vec<PendingSubmission>,
/// The conversation block the copy actions act on; `None` is the last block
pub selected_block: Option<usize>,
pub panes: crate::workspace_layout::PaneLayout,
/// The Context Dock's width as this frame drew it, which the rows inside it are measured to
pub(crate) dock_rail: std::cell::Cell<u16>,
/// Clipboard sink for writing copied text. Shared, not rebuilt per copy: on X11 the selection
/// belongs to this instance and dies with it.
pub clipboard_sink: std::sync::Arc<dyn crate::clipboard::ClipboardSink>,
pub opener: ExternalOpener,
pub workspace: Option<WorkspaceSnapshot>,
/// Whether uncommitted work has left the working tree since this session started.
///
/// Tells "nothing has happened yet" apart from "it was committed", which look identical in a
/// snapshot and mean opposite things to a reader about to review.
pub worktree_emptied: bool,
/// The agent's tool calls in flight that push or open a pull request
pub pull_request_pushes: HashSet<String>,
/// Whether such a call finished and the session has not been linked to its pull request yet
pub pull_request_link_pending: bool,
/// Project-open generations a newer snapshot superseded; a late snapshot from one is dropped
pub retired_workspace_scopes: HashSet<WorkspaceScopeId>,
session_id: Option<String>,
pub tool_activity: HashMap<(String, String), ToolActivity>,
/// Structured tool presentation state keyed by the same semantic call identity.
pub tool_items: HashMap<(String, String), ToolItem>,
/// Full persisted output available only for explicit structured-tool copy actions.
pub tool_copy_output: HashMap<(String, String), String>,
/// Folded runs of tool calls the reader has opened, keyed by the call each run starts at.
expanded_tool_groups: HashSet<ConversationItemId>,
/// User messages the reader asked to see in full past the preview cap.
expanded_messages: HashSet<ConversationItemId>,
/// Whether every tool card is showing its full body and output.
///
/// Transcript-wide rather than per-card: when you want to see what a tool actually returned you
/// rarely want it for exactly one call. Per-card expansion still works and either one opens a
/// card, so this never takes a choice away.
pub tool_output_expanded: bool,
pub images: crate::graphics::ImageStore,
next_attachment_image: u64,
/// The images each tool call produced, kept in the order its result carried them
pub tool_images: HashMap<(String, String), Vec<crate::graphics::ImageKey>>,
/// The transcript's laid-out rows, kept between frames.
///
/// Not view state so much as the *result* of viewing: the render path owns it entirely and
/// rebuilds only the items whose content or presentation moved. It lives here because a frame
/// has to be able to find last frame's work. See [`crate::view::transcript`].
pub(crate) transcript: crate::view::transcript::TranscriptLayout,
/// Things to tell the reader once the first session has loaded — which replaces the
/// conversation, so anything shown before it would be wiped unread.
pub(crate) startup_notices: Vec<String>,
}
impl App {
/// Sizes `pane` to `width`, or back to its own default with `None`.
pub(crate) fn size_pane(&mut self, pane: crate::workspace_layout::Pane, width: Option<u16>) {
self.panes.set(pane, width);
if pane == crate::workspace_layout::Pane::ReviewGuide {
self.guided_review_workspace.set_guide_width(width);
}
}
/// Where the last message you sent sits in the transcript, if there is one.
pub(crate) fn last_user_message_index(&self) -> Option<usize> {
self.convo.iter().rposition(|item| matches!(item.block(), ConvoBlock::User { .. }))
}
/// Takes everything from item `index` on out of the transcript.
///
/// For a re-send that replaces what it follows: the engine branches the session there, and a
/// transcript that kept the old messages would show the reader a conversation the model no
/// longer has.
pub(crate) fn drop_transcript_from(&mut self, index: usize) {
self.convo.truncate(index);
if self.selected_block.is_some_and(|selected| selected >= index) {
self.selected_block = None;
}
self.streaming = false;
self.streaming_thinking_block = None;
}
/// Appends one live conversation block with a session-scoped provisional identity.
pub fn push_convo(&mut self, block: ConvoBlock) {
let id = ConversationItemId::Provisional {
session_id: self.session_id.clone().unwrap_or_default(),
turn_id: self.next_provisional_turn,
block_index: 0,
};
self.next_provisional_turn = self.next_provisional_turn.saturating_add(1);
self.convo.push(ConversationItem::new(id, block));
}
/// Starts a placeholder session for a newly opened review, until the desk's arrives.
///
/// The engine follows every `GuidedReviewLoaded` with the session that goes with it, so this
/// only covers the moment in between: a review on screen with no session at all would render
/// its comments as absent. It is never written anywhere; the desk's copy replaces it.
pub(crate) fn initialize_review_session(&mut self, review: &GuidedReview) {
if self.review.session().is_some_and(|session| session.id == review.id) {
return;
}
self.review.session = Some(ReviewSession::new(
review.id.clone(),
review.target.clone(),
review.source.clone(),
review.generated_at_ms,
));
self.review.edits.clear();
self.review.bound = false;
self.review.provenance = None;
self.review.commit_request = None;
// `review.attention` and `review.flags` are deliberately not cleared here: they belong to
// the review, not the feedback session, and the load handler assigns them just before.
}
/// Whether the dashboard itself owns input, rather than something drawn over it.
///
/// Opening a picker or the context list does not change [`ViewMode`] — the dashboard stays
/// behind them on purpose, so the reader can see what they are changing. That makes the view
/// mode the wrong question to ask before handing the dashboard a key or a click: the model
/// picker was excluded by name and the context list was not, so arrowing inside it walked the
/// column underneath instead. One owner for the question, and every route asks it.
pub fn dashboard_owns_input(&self) -> bool {
self.current_view == ViewMode::Dashboard && !self.overlays.cover_the_dashboard()
}
/// Enter the startup dashboard with the given state.
///
/// Which style it wears is a UI preference, and the live config lives here rather than with
/// whoever assembled the dashboard's session data.
pub fn enter_dashboard(&mut self, state: DashboardState) {
self.current_view = ViewMode::Dashboard;
self.dashboard = Some(state.with_style(self.config.dashboard_style()));
self.editor.cancel();
}
/// Handles a message from input, the engine, or the terminal loop.
pub fn update(&mut self, msg: Msg) {
messages::reduce(self, msg);
}
/// What the workspace snapshot says changed in the project, as the FILES tree reads it.
pub(crate) fn project_changes(&self) -> Vec<crate::workspace_dock::DockChangeItem> {
messages::files::changed(self)
}
/// Route a key: resolve via KeyMap first, then fall through to submit/editor.
///
/// If the chord resolves to a known UiAction, dispatch it. Otherwise, Enter (no Shift)
/// submits the current buffer — slash commands are dispatched locally, everything else
/// is echoed and sent to the engine as a user message. Shift+Enter inserts a newline.
fn handle_key(&mut self, key: crossterm::event::KeyEvent) {
input::handle_key(self, key);
}
fn submit_prompt(&mut self) {
input::submit_prompt(self);
}
fn sync_completion_flyouts(&mut self) {
input::sync_completion_flyouts(self);
}
/// Opens, narrows or closes the `/` and `@` flyouts for the start screen's prompt, after the
/// dashboard has edited it.
pub fn sync_dashboard_flyouts(&mut self) {
if self.current_view == ViewMode::Dashboard {
input::sync_completion_flyouts(self);
}
}
/// Whether the composer's `/` or `@` flyout is open.
pub fn flyout_open(&self) -> bool {
self.overlays.slash_flyout.is_some() || self.overlays.mention.is_some()
}
/// Dispatch a resolved UiAction. Returns `true` if the action was consumed (handled),
/// `false` if it was unresolved — callers should fall through to the editor/submit path.
fn dispatch_action(&mut self, action: UiAction) -> bool {
commands::dispatch_action(self, action)
}
/// Takes a workspace snapshot from the engine, unless a newer one has already been taken.
fn apply_workspace_snapshot(&mut self, snapshot: WorkspaceSnapshot) {
workspace::apply_snapshot(self, snapshot);
}
fn apply_tool_activity(&mut self, activity: ToolActivity) {
workspace::apply_tool_activity(self, activity);
}
}
/// Lines of a user message the transcript shows before collapsing the rest behind a summary.
///
/// A submitted message carries its pasted payload verbatim, so a stack trace or a whole file can
/// arrive as one transcript item. Previewing keeps the conversation readable; the full text is
/// always one expand away, and always what the clipboard and the model receive.
pub const USER_MESSAGE_PREVIEW_LINES: usize = 12;
/// Whether a user message is short enough to render without a preview cap.
pub(super) fn user_message_fits_preview(text: &str) -> bool {
text.lines().count() <= USER_MESSAGE_PREVIEW_LINES + 1
}
#[cfg(test)]
mod tests;