naps62/maestro
Archived
1
0
Fork 0
Code Issues 9 Pull Requests Actions Packages Projects Releases Wiki Activity

feat(maestro): add the ctrl-k command bar to the TUI

Browse Source 
Opens from Normal and Insert mode as an ordinary keymap entry, so it is
rebindable and the help overlay picks it up from the live keymap. An
empty query lists sessions most recently focused first, matching the web
bar's `orderSessionsForBar`; typing ranks through `matcher.rs` with the
matched ranges highlighted, grouped under kind headers.

Enter attaches through the same path the sidebar's attach uses, Escape
closes and leaves focus and mode where they were.
This commit is contained in:
Miguel Palhas
2026-09-03 16:42:21 +01:00
parent 83741d7203
commit dc783778c8
9 changed files with 1204 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/maestro-protocol/src/display.rs
+53
View File
@@ -202,6 +202,41 @@ pub fn command_program(command: &str) -> String {
}
}
/// Program name (already basenamed and lowercased) -> the tool id its mark
/// stands for. Mirrors the web's `BY_PROGRAM` in `web/src/toolIcon.ts`;
/// recognition is deliberately narrow, so an unrecognised program has no tool.
const BY_PROGRAM: [(&str, &str); 17] = [
("claude", "claude"),
("claude-code", "claude"),
("codex", "codex"),
("opencode", "opencode"),
("gemini", "gemini"),
("aider", "aider"),
("cursor", "cursor"),
("cursor-agent", "cursor"),
("pi", "pi"),
("bash", "shell"),
("zsh", "shell"),
("sh", "shell"),
("fish", "shell"),
("dash", "shell"),
("ksh", "shell"),
("nu", "shell"),
("xonsh", "shell"),
];
/// The tool id a command line's icon stands for (`claude`, `codex`,
/// `opencode`, ...), or `None` when the program is not one we have a mark for.
/// The command bar matches this field (`docs/COMMAND-BAR.md`), so it must name
/// the same tools the web's `splitCommand().tool` does.
pub fn command_tool(command: &str) -> Option<&'static str> {
let program = command_program(command).to_lowercase();
BY_PROGRAM
.iter()
.find(|(name, _)| *name == program)
.map(|(_, tool)| *tool)
}
/// `FOO=bar`, the shell's own prefix for one command's environment.
fn is_env_assignment(word: &str) -> bool {
let mut chars = word.chars();
@@ -476,4 +511,22 @@ mod tests {
assert_eq!(command_program("sudo"), "sudo");
assert_eq!(command_program(""), "");
}
/// The command bar's `tool` field (docs/COMMAND-BAR.md) names the same
/// tools the web's `splitCommand().tool` does.
#[test]
fn command_tool_names_the_mark_the_card_shows() {
assert_eq!(command_tool("claude --resume"), Some("claude"));
assert_eq!(command_tool("npx opencode"), Some("opencode"));
assert_eq!(command_tool("/bin/zsh -l"), Some("shell"));
assert_eq!(command_tool("CLAUDE"), Some("claude"));
}
/// Narrow on purpose: an unrecognised program has no mark, so the
/// candidate has no `tool` field to match rather than a wrong one.
#[test]
fn command_tool_is_absent_for_an_unrecognised_program() {
assert_eq!(command_tool("hx src/main.rs"), None);
assert_eq!(command_tool(""), None);
}
}
crates/maestro-tui/src/action.rs
+18
View File
@@ -53,6 +53,9 @@ pub enum Action {
RenameHighlighted,
// Chrome
/// Open the `ctrl-k` command bar (`docs/COMMAND-BAR.md`) — a query line
/// over the sessions, ranked by the shared matcher.
OpenCommandBar,
ToggleSidebar,
ShowHelp,
Quit,
@@ -94,6 +97,7 @@ impl Action {
Action::FastForwardSpawn => "Create session with defaults".into(),
Action::KillHighlighted => "Kill selected session".into(),
Action::RenameHighlighted => "Rename selected session".into(),
Action::OpenCommandBar => "Go to a session".into(),
Action::ToggleSidebar => "Show or hide sidebar".into(),
Action::ShowHelp => "Show help".into(),
Action::Quit => "Quit Maestro".into(),
@@ -120,6 +124,7 @@ impl Action {
"FastForwardSpawn" => return Ok(Action::FastForwardSpawn),
"KillHighlighted" => return Ok(Action::KillHighlighted),
"RenameHighlighted" => return Ok(Action::RenameHighlighted),
"OpenCommandBar" => return Ok(Action::OpenCommandBar),
"ToggleSidebar" => return Ok(Action::ToggleSidebar),
"ShowHelp" => return Ok(Action::ShowHelp),
"Quit" => return Ok(Action::Quit),
@@ -239,10 +244,23 @@ mod tests {
);
}
/// The command bar is an ordinary keymap entry, so it must round-trip
/// like every other action (#153).
#[test]
fn open_command_bar_round_trips() {
assert_eq!(
Action::parse("OpenCommandBar").unwrap(),
Action::OpenCommandBar
);
assert_eq!(Action::OpenCommandBar.to_string(), "OpenCommandBar");
assert_eq!(Action::OpenCommandBar.help_label(), "Go to a session");
}
#[test]
fn display_round_trips() {
for a in [
Action::EnterInsert,
Action::OpenCommandBar,
Action::RenameHighlighted,
Action::Quit,
Action::OpenSpawnModal,
crates/maestro-tui/src/app.rs
+231
View File
@@ -23,6 +23,7 @@ use uuid::Uuid;
use crate::action::Action;
use crate::catalog::CatalogStore;
use crate::command_bar::{BarOutcome, BarTarget, CommandBar};
use crate::config::TuiConfig;
use crate::daemon_link::DaemonLink;
use crate::draft::{DraftInputResult, DraftPane};
@@ -78,6 +79,9 @@ pub struct App {
/// Edit buffer behind [`OverlayKind::Rename`] (#125), kept here for the
/// same reason the worktree entries are.
rename_input: TextInput,
/// Query buffer and result list behind [`OverlayKind::CommandBar`] (#153),
/// kept here for the same reason the rename buffer is.
command_bar: Option<CommandBar>,
region: RegionMap,
last_sent_size: HashMap<Uuid, (u16, u16)>,
clicks: ClickTracker,
@@ -210,6 +214,7 @@ impl App {
link,
http,
rename_input: TextInput::default(),
command_bar: None,
draft_tx,
draft_rx,
region: RegionMap::default(),
@@ -430,6 +435,32 @@ impl App {
(OverlayDecision::Consumed, Vec::new())
}
},
// The bar owns every key while it is up: the keymap must not see
// `j`, `x` or `q` as commands mid-query.
Some(OverlayKind::CommandBar) => {
let outcome = match self.command_bar.as_mut() {
Some(bar) => bar.handle_key(key),
None => BarOutcome::Close,
};
match outcome {
BarOutcome::Stay => (OverlayDecision::Consumed, Vec::new()),
BarOutcome::Close => {
self.close_command_bar();
(OverlayDecision::Consumed, Vec::new())
}
BarOutcome::Open(BarTarget::Session(sid)) => {
self.close_command_bar();
// The same open path the sidebar's own attach uses, so
// a bar attach can never leave the layout in a state a
// highlight-and-enter could not produce.
self.state.sidebar_highlight = Some(SidebarItem::Session(sid));
(
OverlayDecision::Consumed,
self.dispatch(Action::AttachHighlighted),
)
}
}
}
Some(OverlayKind::Help) => {
self.state.dismiss_overlay();
(OverlayDecision::Consumed, Vec::new())
@@ -475,6 +506,7 @@ impl App {
};
self.state.show_overlay(OverlayKind::Help);
}
Action::OpenCommandBar => self.open_command_bar(),
Action::OpenSpawnModal => {
self.open_spawn_modal();
effects.push(Effect::LoadDraft);
@@ -537,6 +569,10 @@ impl App {
/// highlight already sitting on the attached session — clears at once.
fn refresh_preview(&mut self) {
let wanted = match (self.state.focus, &self.state.sidebar_highlight) {
// The bar is a view over the app, not a place in it: while it is
// up the sidebar highlight behind it previews nothing
// (`docs/COMMAND-BAR.md`, "Focus round-trip").
_ if self.state.overlay() == Some(&OverlayKind::CommandBar) => None,
(Focus::Sidebar, Some(SidebarItem::Session(sid))) => Some(*sid),
_ => None,
};
@@ -588,6 +624,25 @@ impl App {
}
}
/// Put the command bar up over whatever is behind it (#153). Opening
/// while a session is previewed discards the preview first, like any
/// other real change (`docs/PREVIEW.md`); focus and mode are left alone,
/// so closing gives the keyboard back to whatever held it.
fn open_command_bar(&mut self) {
let snapshot = self.catalog.snapshot();
self.command_bar = Some(CommandBar::new(&snapshot.sessions, &self.home_dir));
self.pending_preview = None;
self.clear_preview();
self.state.show_overlay(OverlayKind::CommandBar);
}
/// Take the bar down, dropping its query. Every exit goes through here so
/// a stale buffer can never outlive the overlay.
fn close_command_bar(&mut self) {
self.command_bar = None;
self.state.dismiss_overlay();
}
fn clear_preview(&mut self) {
if self.state.preview.take().is_some() {
self.epoch = self.epoch.wrapping_add(1);
@@ -1222,6 +1277,7 @@ impl App {
draft: self.draft.as_ref(),
help: &self.help,
rename_input: &self.rename_input,
command_bar: self.command_bar.as_ref(),
link: &link_status,
};
@@ -2716,6 +2772,181 @@ mod tests {
.is_none());
}
// -- command bar (#153) -------------------------------------------------
fn seed_two_sessions(app: &mut App) -> (Uuid, Uuid) {
use chrono::Utc;
use maestro_protocol::{CatalogEvent, Session, SessionStatus};
let make = |n: u128, name: &str, focused: Option<chrono::DateTime<Utc>>| Session {
id: Uuid::from_u128(n),
command: "bash".into(),
cwd: std::path::PathBuf::from("/"),
env: Default::default(),
metadata: HashMap::from([(
"name".to_string(),
serde_json::Value::String(name.to_string()),
)]),
worktree: None,
status: SessionStatus::Running,
created_at: Utc::now(),
foreground: None,
activity: Default::default(),
activity_detail: None,
last_activity_at: Utc::now(),
activity_since: Utc::now(),
current_cwd: None,
blocked_work: None,
last_focused_at: focused,
};
let older = Utc::now() - chrono::Duration::seconds(60);
app.catalog.apply_event(CatalogEvent::Snapshot {
sessions: vec![
make(1, "alpha", Some(older)),
make(2, "bravo", Some(Utc::now())),
],
});
(Uuid::from_u128(1), Uuid::from_u128(2))
}
/// `ctrl-k` is an ordinary keymap entry, bound in both modes so the bar
/// opens from the sidebar and from inside a pane (`docs/COMMAND-BAR.md`).
#[test]
fn ctrl_k_is_bound_to_the_command_bar_in_both_modes() {
let app = make_app();
assert_eq!(
app.cfg.keymap.resolve(Mode::Normal, "ctrl-k"),
Some(Action::OpenCommandBar)
);
assert_eq!(
app.cfg.keymap.resolve(Mode::Insert, "ctrl-k"),
Some(Action::OpenCommandBar)
);
}
/// The help overlay builds its lines from the live keymap, so the bar
/// appears there with no second list to maintain.
#[test]
fn the_help_overlay_lists_the_command_bar() {
let app = make_app();
let lines = render_help_lines(&app.cfg);
assert!(
lines
.iter()
.any(|l| l.contains("ctrl-k") && l.contains("Go to a session")),
"{lines:#?}"
);
}
#[test]
fn opening_the_bar_lists_sessions_most_recently_focused_first() {
let mut app = make_app();
let (alpha, bravo) = seed_two_sessions(&mut app);
app.dispatch(Action::OpenCommandBar);
assert_eq!(app.state.overlay(), Some(&OverlayKind::CommandBar));
let bar = app.command_bar.as_ref().unwrap();
assert_eq!(bar.query(), "");
assert_eq!(
bar.rows()
.iter()
.map(|r| match r.target {
BarTarget::Session(id) => id,
})
.collect::<Vec<_>>(),
vec![bravo, alpha]
);
}
/// Opening from Insert mode leaves the keyboard where it was, so closing
/// gives it back — the bar is a view over the app, not a place in it.
#[test]
fn opening_from_insert_mode_leaves_focus_and_mode_alone() {
let mut app = make_app();
seed_two_sessions(&mut app);
app.state.attach_to_focused(Uuid::from_u128(1));
assert_eq!(
(app.state.focus, app.state.mode),
(Focus::Pane, Mode::Insert)
);
app.dispatch(Action::OpenCommandBar);
assert_eq!(app.state.overlay(), Some(&OverlayKind::CommandBar));
assert_eq!(
(app.state.focus, app.state.mode),
(Focus::Pane, Mode::Insert)
);
let (decision, effects) = app.handle_overlay_input(&InputKey::Esc);
assert_eq!(decision, OverlayDecision::Consumed);
assert!(effects.is_empty());
assert!(app.state.overlay().is_none());
assert!(app.command_bar.is_none());
assert_eq!(
(app.state.focus, app.state.mode),
(Focus::Pane, Mode::Insert)
);
}
/// Enter goes through the same open path the sidebar's attach uses.
#[test]
fn enter_attaches_the_highlighted_session() {
let mut app = make_app();
let (_alpha, bravo) = seed_two_sessions(&mut app);
app.dispatch(Action::OpenCommandBar);
let (decision, effects) = app.handle_overlay_input(&InputKey::Enter);
assert_eq!(decision, OverlayDecision::Consumed);
assert_eq!(effects, vec![Effect::Attach(bravo)]);
assert!(app.state.overlay().is_none());
assert!(app.command_bar.is_none());
assert_eq!(app.state.active_session(), Some(bravo));
}
/// Down moves the highlight, so Enter opens the second row instead.
#[test]
fn the_highlight_moves_before_enter_attaches() {
let mut app = make_app();
let (alpha, _bravo) = seed_two_sessions(&mut app);
app.dispatch(Action::OpenCommandBar);
app.handle_overlay_input(&InputKey::Down);
let (_, effects) = app.handle_overlay_input(&InputKey::Enter);
assert_eq!(effects, vec![Effect::Attach(alpha)]);
assert_eq!(app.state.active_session(), Some(alpha));
}
/// Typing goes to the query, not to the keymap: `q` must not quit and `x`
/// must not raise a kill confirm while the bar is up.
#[test]
fn typing_reaches_the_query_rather_than_the_keymap() {
let mut app = make_app();
seed_two_sessions(&mut app);
app.dispatch(Action::OpenCommandBar);
for c in "bra".chars() {
let (decision, _) = app.handle_overlay_input(&InputKey::Char {
c,
ctrl: false,
alt: false,
shift: false,
});
assert_eq!(decision, OverlayDecision::Consumed);
}
let bar = app.command_bar.as_ref().unwrap();
assert_eq!(bar.query(), "bra");
assert_eq!(bar.rows().len(), 1);
}
/// The bar is not previewed into (`docs/PREVIEW.md`): opening discards a
/// preview and the highlight behind it raises no new one.
#[test]
fn opening_the_bar_discards_a_preview() {
let mut app = make_app();
let (alpha, _bravo) = seed_two_sessions(&mut app);
app.state.sidebar_highlight = Some(SidebarItem::Session(alpha));
app.state.preview = Some(alpha);
app.dispatch(Action::OpenCommandBar);
assert_eq!(app.state.preview, None);
assert_eq!(app.pending_preview, None);
}
#[test]
fn kill_highlighted_opens_confirm() {
use chrono::Utc;
crates/maestro-tui/src/command_bar.rs
+758
View File
@@ -0,0 +1,758 @@
//! The `ctrl-k` command bar (`docs/COMMAND-BAR.md`): a query line over a
//! result list, opened from Normal or Insert mode, closed with Escape.
//!
//! Sessions are the only kind here (#153); the sigils (#154), the session
//! action page (#155) and the leader's literal Ctrl-K (#156) land later. The
//! grouping below is already kind-generic so those slot in without a rewrite.
//!
//! Ranking is [`crate::matcher`]'s job and nothing here reorders it — the
//! groups are a rendering of the ranked list, in the order their best-scoring
//! member appears. The web bar (`web/src/commandBar.ts`) implements the same
//! contract; the two must agree.
use maestro_protocol::display::{abbreviate_dir, command_tool, session_tree_path};
use maestro_protocol::{Session, SessionStatus};
use ratatui::layout::Rect;
use ratatui::style::{Modifier, Style};
use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, Borders, Clear, Paragraph};
use ratatui::Frame;
use uuid::Uuid;
use crate::input::InputKey;
use crate::matcher::{
match_and_rank, CandidateKind, MatchCandidate, MatchFieldName, MatchRange, SessionCandidate,
};
use crate::overlays::centered;
use crate::palette;
use crate::text_input::TextInput;
/// What Enter on a row does. Only sessions exist today; `>` commands and `~`
/// directories (#154) become further variants.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BarTarget {
Session(Uuid),
}
/// One row of the result list, already resolved to what it renders and what it
/// opens. Headers are labels, not rows, so they are never in this list.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BarRow {
pub kind: CandidateKind,
pub target: BarTarget,
/// Primary text — the name as the sidebar shows it.
pub name: String,
/// Secondary text: the field the match was found in when that was not the
/// name, so a session found through its directory says so.
pub meta: Option<String>,
/// The field that won, and the ranges inside it. `None` for an empty
/// query, which matches everything and highlights nothing.
pub field: Option<MatchFieldName>,
pub ranges: Vec<MatchRange>,
pub dead: bool,
}
impl BarRow {
/// Whether the highlight belongs on [`Self::meta`] rather than the name.
fn meta_is_matched(&self) -> bool {
!matches!(self.field, None | Some(MatchFieldName::Name))
}
}
/// One kind's slice of the ranked list, as a header plus the rows under it.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BarGroup {
pub kind: CandidateKind,
pub title: &'static str,
/// Index of this group's first row in [`CommandBar::rows`].
pub start: usize,
pub len: usize,
}
fn kind_title(kind: CandidateKind) -> &'static str {
match kind {
CandidateKind::Session => "Sessions",
CandidateKind::Command => "Commands",
CandidateKind::Directory => "Directories",
}
}
/// What a keystroke asked the bar to do.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BarOutcome {
/// The bar stays up.
Stay,
/// Escape: close and give the keyboard back.
Close,
/// Enter on a row: close and open what it points at.
Open(BarTarget),
}
/// The empty-query order (`docs/COMMAND-BAR.md`, "Empty query"): most recently
/// focused first; a session that has never been focused sorts after every
/// session that has, most recently created first among those; and a dead
/// session sorts after every live one regardless of recency, because a session
/// you cannot attach to is not where you just were.
///
/// This is also the input order for a non-empty query, which is what the
/// matcher's last tie-break preserves. Mirrors the web's
/// `orderSessionsForBar`.
pub fn order_sessions_for_bar(sessions: &[Session]) -> Vec<&Session> {
let mut ordered: Vec<&Session> = sessions.iter().collect();
ordered.sort_by(|a, b| {
let dead = |s: &Session| u8::from(s.status == SessionStatus::Dead);
dead(a)
.cmp(&dead(b))
.then_with(|| {
a.last_focused_at
.is_none()
.cmp(&b.last_focused_at.is_none())
})
.then_with(|| match (a.last_focused_at, b.last_focused_at) {
(Some(x), Some(y)) => y.cmp(&x),
_ => std::cmp::Ordering::Equal,
})
.then_with(|| b.created_at.cmp(&a.created_at))
});
ordered
}
/// One session's candidate: the fields `docs/COMMAND-BAR.md`'s candidate table
/// names, with the directory abbreviated the way the sidebar shows it.
pub fn session_candidate(session: &Session, home_dir: &str) -> SessionCandidate {
SessionCandidate {
name: crate::sidebar::name_for(session),
directory: session_tree_path(session).map(|path| abbreviate_dir(&path, home_dir)),
command: (!session.command.is_empty()).then(|| session.command.clone()),
tool: command_tool(&session.command).map(str::to_string),
}
}
/// The bar's state while it is up: the query buffer, the candidates it was
/// opened over, the rows the current query produces, and the highlight.
#[derive(Debug)]
pub struct CommandBar {
input: TextInput,
/// Matcher input, in the empty-query order. Never reordered — the matcher's
/// last tie-break is what keeps that order meaningful.
candidates: Vec<MatchCandidate>,
/// What each candidate opens, parallel to `candidates`.
targets: Vec<BarTarget>,
/// Whether each candidate's session is dead, parallel to `candidates`.
dead: Vec<bool>,
rows: Vec<BarRow>,
highlight: usize,
}
impl CommandBar {
/// Open the bar over the sessions the catalog has right now.
pub fn new(sessions: &[Session], home_dir: &str) -> Self {
let ordered = order_sessions_for_bar(sessions);
let candidates = ordered
.iter()
.map(|s| MatchCandidate::Session(session_candidate(s, home_dir)))
.collect();
let targets = ordered.iter().map(|s| BarTarget::Session(s.id)).collect();
let dead = ordered
.iter()
.map(|s| s.status == SessionStatus::Dead)
.collect();
let mut bar = Self {
input: TextInput::default(),
candidates,
targets,
dead,
rows: Vec::new(),
highlight: 0,
};
bar.recompute();
bar
}
pub fn query(&self) -> &str {
self.input.value()
}
pub fn rows(&self) -> &[BarRow] {
&self.rows
}
pub fn highlight(&self) -> usize {
self.highlight
}
/// The row Enter would open.
pub fn selected(&self) -> Option<&BarRow> {
self.rows.get(self.highlight)
}
/// Group the ranked rows by kind for rendering. Grouping never reorders:
/// a group holds its matches in rank order, and groups appear in the order
/// their best-scoring member does — so the first row under the first
/// header is the globally best result.
pub fn groups(&self) -> Vec<BarGroup> {
let mut groups: Vec<BarGroup> = Vec::new();
for (index, row) in self.rows.iter().enumerate() {
match groups.iter_mut().find(|g| g.kind == row.kind) {
Some(group) => group.len += 1,
None => groups.push(BarGroup {
kind: row.kind,
title: kind_title(row.kind),
start: index,
len: 1,
}),
}
}
groups
}
/// Move the highlight. It does not wrap: it stops at the first and last
/// row.
pub fn move_highlight(&mut self, delta: isize) {
if self.rows.is_empty() {
self.highlight = 0;
return;
}
let last = self.rows.len() as isize - 1;
let next = (self.highlight as isize + delta).clamp(0, last);
self.highlight = next as usize;
}
/// Feed the bar a key. Everything the key table (`docs/COMMAND-BAR.md`,
/// "Keys") does not claim is ordinary editing.
pub fn handle_key(&mut self, key: &InputKey) -> BarOutcome {
match key {
InputKey::Esc => BarOutcome::Close,
InputKey::Enter => match self.selected() {
Some(row) => BarOutcome::Open(row.target),
// Nothing to open: the bar stays up rather than closing on a
// key that did nothing.
None => BarOutcome::Stay,
},
InputKey::Up
| InputKey::Char {
c: 'p', ctrl: true, ..
} => {
self.move_highlight(-1);
BarOutcome::Stay
}
InputKey::Down
| InputKey::Char {
c: 'n', ctrl: true, ..
} => {
self.move_highlight(1);
BarOutcome::Stay
}
// Tab drills into the highlighted session's action page (#155).
// Until then it is inert rather than a literal tab in the query.
InputKey::Tab | InputKey::BackTab => BarOutcome::Stay,
other => {
let before = self.input.value().to_string();
self.input.handle_key(other);
if self.input.value() != before {
self.recompute();
}
BarOutcome::Stay
}
}
}
/// Re-rank for the current query. The highlight starts on the globally
/// best row every time the list changes: an old index would point at a
/// different result.
fn recompute(&mut self) {
let rows: Vec<BarRow> = {
let results = match_and_rank(self.input.value(), &self.candidates);
results
.iter()
.map(|result| {
let index = self
.candidates
.iter()
.position(|c| std::ptr::eq(c, result.candidate))
.expect("every result borrows one of this bar's candidates");
let MatchCandidate::Session(session) = result.candidate else {
unreachable!("sessions are the only kind the bar builds (#153)")
};
BarRow {
kind: CandidateKind::Session,
target: self.targets[index],
name: session.name.clone(),
meta: meta_text(session, result.field),
field: result.field,
ranges: result.ranges.clone(),
dead: self.dead[index],
}
})
.collect()
};
self.rows = rows;
self.highlight = 0;
}
/// Draw the bar and return where the terminal cursor belongs.
pub fn render(&self, f: &mut Frame, parent: Rect) -> Option<(u16, u16)> {
let pal = palette::active();
let height = parent.height.saturating_sub(4).clamp(5, 20);
let area = centered(parent, 72, height);
f.render_widget(Clear, area);
let block = Block::default()
.title(" go to ")
.borders(Borders::ALL)
.style(pal.card.base())
.border_style(pal.border_style(true));
let inner = block.inner(area);
f.render_widget(block, area);
if inner.height < 3 || inner.width == 0 {
return None;
}
let row = |offset: u16| Rect {
x: inner.x,
y: inner.y + offset,
width: inner.width,
height: 1,
};
// Query line, then the results, then the key hint on the last row.
let query = row(0);
let col = self
.input
.render(query, f.buffer_mut(), pal.card.text_style());
f.render_widget(
Paragraph::new(Line::from(Span::styled(
"[enter] open [esc] close",
pal.card.dim_style(),
))),
row(inner.height - 1),
);
let list_height = inner.height.saturating_sub(2) as usize;
if list_height > 0 {
for (offset, line) in self.visible_lines(list_height).into_iter().enumerate() {
f.render_widget(Paragraph::new(line), row(1 + offset as u16));
}
}
Some((col, query.y))
}
/// The result lines that fit in `height`, scrolled so the highlighted row
/// is on screen.
fn visible_lines(&self, height: usize) -> Vec<Line<'static>> {
let pal = palette::active();
if self.rows.is_empty() {
return vec![Line::from(Span::styled(
"No matches",
pal.card.muted_style(),
))];
}
// Headers and rows, in one list, remembering which line the highlight
// sits on so the scroll can keep it visible.
let mut lines: Vec<Line<'static>> = Vec::new();
let mut highlight_line = 0usize;
for group in self.groups() {
lines.push(Line::from(Span::styled(
group.title.to_string(),
pal.group_row_style(),
)));
for index in group.start..group.start + group.len {
if index == self.highlight {
highlight_line = lines.len();
}
lines.push(self.row_line(index));
}
}
let scroll = highlight_line.saturating_sub(height.saturating_sub(1));
lines.into_iter().skip(scroll).take(height).collect()
}
fn row_line(&self, index: usize) -> Line<'static> {
let pal = palette::active();
let row = &self.rows[index];
let selected = index == self.highlight;
let surface = pal.surface(selected);
let base = if row.dead {
surface.dim_style()
} else {
surface.text_style()
};
let hit = base.add_modifier(Modifier::BOLD | Modifier::UNDERLINED);
let mut spans = vec![Span::styled(if selected { "› " } else { " " }, base)];
let name_ranges: &[MatchRange] = if row.meta_is_matched() {
&[]
} else {
&row.ranges
};
spans.extend(highlighted_spans(&row.name, name_ranges, base, hit));
if let Some(meta) = &row.meta {
let meta_style = surface.muted_style();
let meta_hit = meta_style.add_modifier(Modifier::BOLD | Modifier::UNDERLINED);
spans.push(Span::styled(" ", base));
let meta_ranges: &[MatchRange] = if row.meta_is_matched() {
&row.ranges
} else {
&[]
};
spans.extend(highlighted_spans(meta, meta_ranges, meta_style, meta_hit));
}
Line::from(spans)
}
}
/// The secondary line under a row's name: the field the match was found in
/// when that was not the name, so a session found through its directory says
/// so. Mirrors the web's `metaText`.
fn meta_text(session: &SessionCandidate, field: Option<MatchFieldName>) -> Option<String> {
match field {
Some(MatchFieldName::Directory) => session.directory.clone(),
Some(MatchFieldName::Command) => session.command.clone(),
Some(MatchFieldName::Tool) => session.tool.clone(),
_ => session.directory.clone(),
}
}
/// Split `text` into styled spans, with the matcher's `[start, end)` character
/// ranges carrying `hit` and everything else `base`.
fn highlighted_spans(
text: &str,
ranges: &[MatchRange],
base: Style,
hit: Style,
) -> Vec<Span<'static>> {
let chars: Vec<char> = text.chars().collect();
let slice = |from: usize, to: usize| -> String {
chars[from.min(chars.len())..to.min(chars.len())]
.iter()
.collect()
};
let mut spans = Vec::new();
let mut cursor = 0usize;
for &(start, end) in ranges {
if start > cursor {
spans.push(Span::styled(slice(cursor, start), base));
}
spans.push(Span::styled(slice(start, end), hit));
cursor = end;
}
if cursor < chars.len() {
spans.push(Span::styled(slice(cursor, chars.len()), base));
}
spans
}
#[cfg(test)]
mod tests {
use super::*;
use chrono::{DateTime, TimeZone, Utc};
use ratatui::backend::TestBackend;
use ratatui::Terminal;
use std::collections::HashMap;
use std::path::PathBuf;
fn at(secs: i64) -> DateTime<Utc> {
Utc.timestamp_opt(1_700_000_000 + secs, 0).unwrap()
}
fn session(n: u128, command: &str) -> Session {
Session {
id: Uuid::from_u128(n),
cwd: PathBuf::from("/home/me/dev/api"),
command: command.to_string(),
env: HashMap::new(),
metadata: HashMap::new(),
worktree: None,
status: SessionStatus::Running,
created_at: at(0),
foreground: None,
activity: Default::default(),
activity_detail: None,
last_activity_at: at(0),
activity_since: at(0),
current_cwd: None,
blocked_work: None,
last_focused_at: None,
}
}
fn named(n: u128, name: &str) -> Session {
let mut s = session(n, "bash");
s.metadata
.insert("name".into(), serde_json::Value::String(name.to_string()));
s
}
fn ids(rows: &[BarRow]) -> Vec<Uuid> {
rows.iter()
.map(|r| match r.target {
BarTarget::Session(id) => id,
})
.collect()
}
fn typed(bar: &mut CommandBar, text: &str) {
for c in text.chars() {
bar.handle_key(&InputKey::Char {
c,
ctrl: false,
alt: false,
shift: false,
});
}
}
#[test]
fn empty_query_lists_sessions_most_recently_focused_first() {
let mut a = named(1, "alpha");
a.last_focused_at = Some(at(10));
let mut b = named(2, "bravo");
b.last_focused_at = Some(at(30));
let mut c = named(3, "charlie");
c.last_focused_at = Some(at(20));
let bar = CommandBar::new(&[a, b, c], "/home/me");
assert_eq!(
ids(bar.rows()),
vec![Uuid::from_u128(2), Uuid::from_u128(3), Uuid::from_u128(1)]
);
// Every row matches with no ranges, so nothing is highlighted inside.
assert!(bar.rows().iter().all(|r| r.ranges.is_empty()));
}
#[test]
fn never_focused_sessions_sort_after_focused_ones_newest_first() {
let mut focused = named(1, "focused");
focused.last_focused_at = Some(at(5));
let mut older = named(2, "older");
older.created_at = at(10);
let mut newer = named(3, "newer");
newer.created_at = at(20);
let bar = CommandBar::new(&[older, newer, focused], "/home/me");
assert_eq!(
ids(bar.rows()),
vec![Uuid::from_u128(1), Uuid::from_u128(3), Uuid::from_u128(2)]
);
}
/// A session you cannot attach to is not where you just were.
#[test]
fn dead_sessions_sort_after_live_ones_however_recent() {
let mut dead = named(1, "dead");
dead.status = SessionStatus::Dead;
dead.last_focused_at = Some(at(99));
let live = named(2, "live");
let bar = CommandBar::new(&[dead, live], "/home/me");
assert_eq!(
ids(bar.rows()),
vec![Uuid::from_u128(2), Uuid::from_u128(1)]
);
assert!(bar.rows()[1].dead);
}
#[test]
fn typing_ranks_through_the_matcher_and_returns_ranges() {
let mut bar = CommandBar::new(&[named(1, "web-search"), named(2, "websearch")], "/home/me");
typed(&mut bar, "ws");
// F9: the `s` after `-` earns the boundary bonus.
assert_eq!(
ids(bar.rows()),
vec![Uuid::from_u128(1), Uuid::from_u128(2)]
);
assert_eq!(bar.rows()[0].ranges, vec![(0, 1), (4, 5)]);
assert_eq!(bar.rows()[0].field, Some(MatchFieldName::Name));
}
#[test]
fn a_query_matching_nothing_leaves_no_rows() {
let mut bar = CommandBar::new(&[named(1, "alpha")], "/home/me");
typed(&mut bar, "zzz");
assert!(bar.rows().is_empty());
assert!(bar.selected().is_none());
}
/// A session found through its directory highlights inside the directory,
/// which is also what the row's meta text shows.
#[test]
fn a_directory_match_highlights_in_the_meta_text() {
let mut worker = named(1, "worker");
worker.cwd = PathBuf::from("/home/me/dev/api");
let mut bar = CommandBar::new(&[worker], "/home/me");
typed(&mut bar, "api");
assert_eq!(bar.rows()[0].field, Some(MatchFieldName::Directory));
assert_eq!(bar.rows()[0].meta.as_deref(), Some("~/dev/api"));
assert_eq!(bar.rows()[0].ranges, vec![(6, 9)]);
}
/// The candidate's `tool` is the mark the card's icon stands for, so
/// `claude` reaches a session whose name says nothing about it.
#[test]
fn the_tool_field_is_a_candidate_field() {
let mut nameless = named(1, "nameless");
nameless.command = "claude --resume".into();
let mut bar = CommandBar::new(&[nameless, named(2, "clay")], "/home/me");
typed(&mut bar, "claude");
assert_eq!(ids(bar.rows()), vec![Uuid::from_u128(1)]);
assert_eq!(bar.rows()[0].field, Some(MatchFieldName::Tool));
}
#[test]
fn results_group_under_kind_headers_with_the_best_row_first() {
let bar = CommandBar::new(&[named(1, "alpha"), named(2, "bravo")], "/home/me");
let groups = bar.groups();
assert_eq!(groups.len(), 1);
assert_eq!(groups[0].title, "Sessions");
assert_eq!(groups[0].kind, CandidateKind::Session);
assert_eq!((groups[0].start, groups[0].len), (0, 2));
// The highlight starts on the globally best row.
assert_eq!(bar.highlight(), 0);
}
#[test]
fn arrows_and_ctrl_pn_move_the_highlight_without_wrapping() {
let mut bar = CommandBar::new(
&[named(1, "alpha"), named(2, "bravo"), named(3, "charlie")],
"/home/me",
);
assert_eq!(bar.handle_key(&InputKey::Down), BarOutcome::Stay);
assert_eq!(bar.highlight(), 1);
bar.handle_key(&InputKey::Char {
c: 'n',
ctrl: true,
alt: false,
shift: false,
});
assert_eq!(bar.highlight(), 2);
// Stops at the last row rather than wrapping to the first.
bar.handle_key(&InputKey::Down);
assert_eq!(bar.highlight(), 2);
bar.handle_key(&InputKey::Char {
c: 'p',
ctrl: true,
alt: false,
shift: false,
});
assert_eq!(bar.highlight(), 1);
bar.handle_key(&InputKey::Up);
bar.handle_key(&InputKey::Up);
assert_eq!(bar.highlight(), 0);
}
#[test]
fn enter_opens_the_highlighted_session_and_escape_closes() {
let mut bar = CommandBar::new(&[named(1, "alpha"), named(2, "bravo")], "/home/me");
bar.handle_key(&InputKey::Down);
assert_eq!(
bar.handle_key(&InputKey::Enter),
BarOutcome::Open(BarTarget::Session(Uuid::from_u128(2)))
);
assert_eq!(bar.handle_key(&InputKey::Esc), BarOutcome::Close);
}
#[test]
fn enter_with_no_results_leaves_the_bar_up() {
let mut bar = CommandBar::new(&[named(1, "alpha")], "/home/me");
typed(&mut bar, "zzz");
assert_eq!(bar.handle_key(&InputKey::Enter), BarOutcome::Stay);
}
#[test]
fn editing_the_query_re_ranks_and_resets_the_highlight() {
let mut bar = CommandBar::new(&[named(1, "alpha"), named(2, "alpine")], "/home/me");
bar.handle_key(&InputKey::Down);
assert_eq!(bar.highlight(), 1);
typed(&mut bar, "alp");
assert_eq!(bar.query(), "alp");
assert_eq!(bar.highlight(), 0);
bar.handle_key(&InputKey::Backspace);
assert_eq!(bar.query(), "al");
assert_eq!(bar.rows().len(), 2);
}
/// Backspacing back to an empty query is not a special key: the list
/// becomes the recency order again.
#[test]
fn backspacing_to_an_empty_query_restores_the_recency_order() {
let mut recent = named(1, "alpha");
recent.last_focused_at = Some(at(50));
let older = named(2, "alpine");
let mut bar = CommandBar::new(&[older, recent], "/home/me");
typed(&mut bar, "alpi");
assert_eq!(ids(bar.rows()), vec![Uuid::from_u128(2)]);
for _ in 0..4 {
bar.handle_key(&InputKey::Backspace);
}
assert_eq!(bar.query(), "");
assert_eq!(
ids(bar.rows()),
vec![Uuid::from_u128(1), Uuid::from_u128(2)]
);
}
fn render_to_string(bar: &CommandBar, w: u16, h: u16) -> String {
let backend = TestBackend::new(w, h);
let mut terminal = Terminal::new(backend).unwrap();
terminal
.draw(|f| {
bar.render(f, f.area());
})
.unwrap();
let buf = terminal.backend().buffer().clone();
let mut out = String::new();
for y in 0..buf.area.height {
for x in 0..buf.area.width {
out.push_str(buf[(x, y)].symbol());
}
out.push('\n');
}
out
}
#[test]
fn renders_the_query_the_headers_and_the_rows() {
let mut bar = CommandBar::new(&[named(1, "alpha"), named(2, "alpine")], "/home/me");
typed(&mut bar, "alp");
let rendered = render_to_string(&bar, 90, 20);
assert!(rendered.contains("go to"), "{rendered}");
assert!(rendered.contains("alp"), "{rendered}");
assert!(rendered.contains("Sessions"), "{rendered}");
assert!(rendered.contains("alpha"), "{rendered}");
assert!(rendered.contains("alpine"), "{rendered}");
assert!(rendered.contains("[esc] close"), "{rendered}");
}
#[test]
fn renders_a_no_results_state() {
let mut bar = CommandBar::new(&[named(1, "alpha")], "/home/me");
typed(&mut bar, "zzz");
let rendered = render_to_string(&bar, 90, 20);
assert!(rendered.contains("No matches"), "{rendered}");
}
/// The matched characters are drawn bold, so the row shows why it matched.
#[test]
fn matched_ranges_are_styled_apart_from_the_rest_of_the_row() {
let mut bar = CommandBar::new(&[named(1, "web-search")], "/home/me");
typed(&mut bar, "ws");
let backend = TestBackend::new(90, 20);
let mut terminal = Terminal::new(backend).unwrap();
terminal
.draw(|f| {
bar.render(f, f.area());
})
.unwrap();
let buf = terminal.backend().buffer().clone();
let mut bold: Vec<String> = Vec::new();
for y in 0..buf.area.height {
for x in 0..buf.area.width {
let cell = &buf[(x, y)];
if cell.style().add_modifier.contains(Modifier::BOLD)
&& cell.style().add_modifier.contains(Modifier::UNDERLINED)
{
bold.push(cell.symbol().to_string());
}
}
}
assert_eq!(bold, vec!["w", "s"], "bold cells: {bold:?}");
}
}
crates/maestro-tui/src/config.rs
+9 -2
View File
@@ -65,6 +65,9 @@ const DEFAULT_NORMAL: &[(&str, &str)] = &[
("pageup", "ScrollPanePageUp"),
("pagedown", "ScrollPanePageDown"),
// Chrome
// The command bar (#153). An ordinary entry, so it is rebindable and the
// help overlay picks it up from the live keymap.
("ctrl-k", "OpenCommandBar"),
("ctrl-w b", "ToggleSidebar"),
("?", "ShowHelp"),
("ctrl-w q", "Quit"),
@@ -75,13 +78,17 @@ const DEFAULT_NORMAL: &[(&str, &str)] = &[
("mouse:dblclick(sidebar-row)", "AttachHighlighted"),
];
/// Default Insert-mode bindings — deliberately empty. Every key typed in
/// Default Insert-mode bindings — almost empty on purpose. Every key typed in
/// Insert mode belongs to the session, `esc` included: full-screen apps read
/// it constantly, so binding it here would make it unreachable. The only way
/// back to the sidebar is the leader (`LeaveInsert`), which
/// [`TuiConfig::load`] inserts dynamically so rebinding the leader rebinds
/// the Insert escape with it.
const DEFAULT_INSERT: &[(&str, &str)] = &[];
///
/// The one exception is the command bar (#153): `ctrl-k` opens it from inside
/// a pane too, so `docs/COMMAND-BAR.md`'s "from anywhere" holds. Readline's
/// kill-to-end-of-line is given back through the leader (#156).
const DEFAULT_INSERT: &[(&str, &str)] = &[("ctrl-k", "OpenCommandBar")];
impl TuiConfig {
/// Build a runtime config from a [`TuiSection`] (typically the `tui`
crates/maestro-tui/src/lib.rs
+1
View File
@@ -6,6 +6,7 @@ pub mod action;
pub mod app;
pub mod catalog;
pub mod cli;
pub mod command_bar;
pub mod config;
pub mod daemon_link;
pub mod draft;
crates/maestro-tui/src/render.rs
+15
View File
@@ -86,6 +86,9 @@ pub struct RenderInputs<'a> {
pub help: &'a HelpOverlay,
/// Edit buffer behind the rename prompt (#125).
pub rename_input: &'a crate::text_input::TextInput,
/// The command bar behind [`OverlayKind::CommandBar`] (#153), when one is
/// up.
pub command_bar: Option<&'a crate::command_bar::CommandBar>,
/// Liveness + release of the daemon, for the status bar's indicator and the
/// restart overlay (`docs/RESTART.md`).
pub link: &'a crate::daemon_link::LinkStatus,
@@ -198,6 +201,14 @@ pub fn draw(f: &mut Frame, inputs: RenderInputs<'_>) -> RegionMap {
}
map.modal = Some(area);
}
Some(OverlayKind::CommandBar) => {
if let Some(bar) = inputs.command_bar {
if let Some((x, y)) = bar.render(f, area) {
f.set_cursor_position((x, y));
}
map.modal = Some(area);
}
}
Some(OverlayKind::Help) => {
inputs.help.render(f, area);
map.modal = Some(area);
@@ -428,6 +439,7 @@ mod tests {
state: &state,
help: &help,
rename_input: &crate::text_input::TextInput::default(),
command_bar: None,
link,
};
let backend = ratatui::backend::TestBackend::new(120, 24);
@@ -524,6 +536,7 @@ mod tests {
state: &state,
help: &help,
rename_input: &crate::text_input::TextInput::default(),
command_bar: None,
link: &online_link(),
};
@@ -578,6 +591,7 @@ mod tests {
state: &state,
help: &help,
rename_input: &crate::text_input::TextInput::default(),
command_bar: None,
link: &online_link(),
};
let backend = ratatui::backend::TestBackend::new(80, 24);
@@ -619,6 +633,7 @@ mod tests {
state: &state,
help: &help,
rename_input: &crate::text_input::TextInput::default(),
command_bar: None,
link: &online_link(),
};
let backend = ratatui::backend::TestBackend::new(80, 24);
crates/maestro-tui/src/state.rs
+4
View File
@@ -52,6 +52,10 @@ pub enum OverlayKind {
/// so this stays comparable.
Rename(Uuid),
Help,
/// The `ctrl-k` command bar (#153). Its query buffer and result list live
/// on `App` as [`crate::command_bar::CommandBar`], for the same reason the
/// rename buffer does — so this stays comparable.
CommandBar,
Toast(String),
}