247 lines
7.9 KiB
Rust
247 lines
7.9 KiB
Rust
//! Sidebar widget — session list, navigation-only.
|
|
//!
|
|
//! Status glyphs: ● attached / ○ live / ✗ dead.
|
|
|
|
use std::collections::HashSet;
|
|
|
|
use maestro_protocol::{Session, SessionStatus};
|
|
use ratatui::layout::Rect;
|
|
use ratatui::style::{Color, Modifier, Style};
|
|
use ratatui::text::{Line, Span};
|
|
use ratatui::widgets::{Block, Borders, Paragraph};
|
|
use ratatui::Frame;
|
|
use uuid::Uuid;
|
|
|
|
/// Renderable sidebar state.
|
|
#[derive(Debug, Clone)]
|
|
pub struct Sidebar {
|
|
pub sessions: Vec<Session>,
|
|
pub highlight: Option<Uuid>,
|
|
pub attached: HashSet<Uuid>,
|
|
}
|
|
|
|
impl Sidebar {
|
|
pub fn render(&self, f: &mut Frame, area: Rect) {
|
|
self.render_with_focus(f, area, false);
|
|
}
|
|
|
|
/// Same as [`Sidebar::render`] but tints the right-edge separator in the
|
|
/// focus colour when `focused`. Box borders eat too many rows/cols for
|
|
/// the v1 layout — a single vertical rule keeps the panel boundary
|
|
/// without stealing space.
|
|
pub fn render_with_focus(&self, f: &mut Frame, area: Rect, focused: bool) {
|
|
let border_style = if focused {
|
|
Style::default().fg(Color::Cyan)
|
|
} else {
|
|
Style::default()
|
|
};
|
|
let block = Block::default()
|
|
.borders(Borders::RIGHT)
|
|
.border_style(border_style);
|
|
let inner = block.inner(area);
|
|
f.render_widget(block, area);
|
|
|
|
let mut lines: Vec<Line> = vec![Line::from(Span::styled(
|
|
"sessions",
|
|
Style::default().add_modifier(Modifier::BOLD),
|
|
))];
|
|
for s in &self.sessions {
|
|
let glyph = match (s.status, self.attached.contains(&s.id)) {
|
|
(SessionStatus::Dead, _) => "✗",
|
|
(SessionStatus::Running, true) => "●",
|
|
(SessionStatus::Running, false) => "○",
|
|
};
|
|
let label = name_for(s);
|
|
// #83: a session whose worktree blocks a kill gets a warning
|
|
// glyph; the kill confirm names the specifics.
|
|
let blocked = s
|
|
.blocked_work
|
|
.filter(|b| !b.is_clear())
|
|
.map(|_| " ⚠")
|
|
.unwrap_or_default();
|
|
let style = if self.highlight == Some(s.id) {
|
|
Style::default().add_modifier(Modifier::REVERSED)
|
|
} else {
|
|
Style::default()
|
|
};
|
|
lines.push(Line::from(vec![
|
|
Span::raw(" "),
|
|
Span::styled(format!("{glyph} {label}{blocked}"), style),
|
|
]));
|
|
}
|
|
f.render_widget(Paragraph::new(lines), inner);
|
|
}
|
|
}
|
|
|
|
/// `metadata.name` if present, else the command line.
|
|
fn name_for(s: &Session) -> String {
|
|
if let Some(serde_json::Value::String(name)) = s.metadata.get("name") {
|
|
name.clone()
|
|
} else {
|
|
s.command.clone()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use chrono::Utc;
|
|
use ratatui::backend::TestBackend;
|
|
use ratatui::Terminal;
|
|
use std::collections::HashMap;
|
|
|
|
fn session_named(id: u128, name: &str) -> Session {
|
|
let mut metadata = HashMap::new();
|
|
metadata.insert("name".into(), serde_json::Value::String(name.into()));
|
|
Session {
|
|
id: Uuid::from_u128(id),
|
|
command: "bash".into(),
|
|
cwd: std::path::PathBuf::from("/tmp"),
|
|
env: Default::default(),
|
|
metadata,
|
|
worktree: None,
|
|
status: SessionStatus::Running,
|
|
created_at: Utc::now(),
|
|
foreground: None,
|
|
activity: Default::default(),
|
|
last_activity_at: chrono::Utc::now(),
|
|
current_cwd: None,
|
|
blocked_work: None,
|
|
}
|
|
}
|
|
|
|
fn render_to_string(sidebar: &Sidebar, w: u16, h: u16) -> String {
|
|
let backend = TestBackend::new(w, h);
|
|
let mut terminal = Terminal::new(backend).unwrap();
|
|
terminal.draw(|f| sidebar.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_session_names() {
|
|
let sb = Sidebar {
|
|
sessions: vec![session_named(1, "claude"), session_named(2, "bash")],
|
|
highlight: None,
|
|
attached: Default::default(),
|
|
};
|
|
let rendered = render_to_string(&sb, 28, 12);
|
|
assert!(
|
|
rendered.contains("claude"),
|
|
"missing session name:\n{rendered}"
|
|
);
|
|
assert!(
|
|
rendered.contains("bash"),
|
|
"missing session name:\n{rendered}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn attached_session_uses_filled_glyph() {
|
|
let sid = Uuid::from_u128(1);
|
|
let sb = Sidebar {
|
|
sessions: vec![session_named(1, "claude")],
|
|
highlight: None,
|
|
attached: [sid].into_iter().collect(),
|
|
};
|
|
let rendered = render_to_string(&sb, 28, 6);
|
|
let line = rendered
|
|
.lines()
|
|
.find(|l| l.contains("claude"))
|
|
.expect("claude row");
|
|
assert!(line.contains('●'), "expected filled glyph in: {line:?}");
|
|
assert!(
|
|
!line.contains('○'),
|
|
"should not contain hollow glyph: {line:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn dead_session_uses_cross_glyph() {
|
|
let mut sess = session_named(1, "claude");
|
|
sess.status = SessionStatus::Dead;
|
|
let sb = Sidebar {
|
|
sessions: vec![sess],
|
|
highlight: None,
|
|
attached: Default::default(),
|
|
};
|
|
let rendered = render_to_string(&sb, 28, 6);
|
|
let line = rendered
|
|
.lines()
|
|
.find(|l| l.contains("claude"))
|
|
.expect("claude row");
|
|
assert!(line.contains('✗'), "expected dead glyph in: {line:?}");
|
|
}
|
|
|
|
/// #83: a session whose worktree blocks a kill carries the warning glyph;
|
|
/// a clear or unprobed one does not.
|
|
#[test]
|
|
fn blocked_session_gets_a_warning_glyph() {
|
|
use maestro_protocol::InTheWay;
|
|
|
|
let mut blocked = session_named(1, "claude");
|
|
blocked.blocked_work = Some(InTheWay {
|
|
unpushed_commits: 4,
|
|
..InTheWay::default()
|
|
});
|
|
let mut clear = session_named(2, "bash");
|
|
clear.blocked_work = Some(InTheWay::default());
|
|
let unprobed = session_named(3, "vim");
|
|
let sb = Sidebar {
|
|
sessions: vec![blocked, clear, unprobed],
|
|
highlight: None,
|
|
attached: Default::default(),
|
|
};
|
|
let rendered = render_to_string(&sb, 40, 8);
|
|
let line = rendered
|
|
.lines()
|
|
.find(|l| l.contains("claude"))
|
|
.expect("blocked row");
|
|
assert!(line.contains('⚠'), "expected warning glyph in: {line:?}");
|
|
for name in ["bash", "vim"] {
|
|
let line = rendered
|
|
.lines()
|
|
.find(|l| l.contains(name))
|
|
.expect("clear row");
|
|
assert!(!line.contains('⚠'), "{name} must not warn: {line:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn falls_back_to_command_when_name_metadata_is_absent() {
|
|
let s = Session {
|
|
id: Uuid::from_u128(1),
|
|
command: "vim".into(),
|
|
cwd: std::path::PathBuf::from("/tmp"),
|
|
env: Default::default(),
|
|
metadata: HashMap::new(),
|
|
worktree: None,
|
|
status: SessionStatus::Running,
|
|
created_at: Utc::now(),
|
|
foreground: None,
|
|
activity: Default::default(),
|
|
last_activity_at: chrono::Utc::now(),
|
|
|
|
current_cwd: None,
|
|
blocked_work: None,
|
|
};
|
|
let sb = Sidebar {
|
|
sessions: vec![s],
|
|
highlight: None,
|
|
attached: Default::default(),
|
|
};
|
|
let rendered = render_to_string(&sb, 28, 6);
|
|
assert!(
|
|
rendered.contains("vim"),
|
|
"missing fallback command name:\n{rendered}"
|
|
);
|
|
}
|
|
}
|