use std::cmp::Reverse;
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
use std::fs::{self, File};
use std::io::{BufRead, BufReader, IsTerminal, Read, Seek, SeekFrom, Write};
use std::ops::Range;
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime};
use anyhow::{Result, bail};
use serde_json::Value;
use crate::daemon::render;
use crate::identity;
use crate::platform;
use crate::store::{self, Event, Status, Store, Task};
mod markdown;
const REFRESH: Duration = Duration::from_secs(1);
const RECENT_MS: u64 = 60 * 60 * 1000;
const LOGGED: usize = 300;
const PLAIN_MESSAGES: usize = 20;
const LABEL: usize = 8;
const GUTTER: usize = 2;
const TASK_MARK: (&str, &str) = ("› ", "1;2");
const SAID_MARK: (&str, &str) = ("• ", DIM);
const READ_BYTES: u64 = 64 * 1024;
const WITH_TASKS: u8 = u8::MAX;
const ESC_WAIT: Duration = Duration::from_millis(100);
const FALLBACK_SIZE: (usize, usize) = (100, 30);
const NAME: usize = 20;
const SESSION: usize = 8;
const STATE: usize = 11;
const BOLD: &str = "1";
const DIM: &str = "2";
const CHOSEN: &str = "7";
const RED: &str = "31";
const GREEN: &str = "32";
const YELLOW: &str = "33";
type Seg = (String, &'static str);
pub async fn run(home: &Path, task: Option<&str>, all: bool) -> Result<i32> {
let mut view = View::new(home, all);
view.refresh();
let focus = task.map(|r| view.find(r)).transpose()?;
if !std::io::stdout().is_terminal() {
let mut out = std::io::stdout().lock();
let lines = match &focus {
Some(id) => view.task_frame(id, store::now_ms(), None, false),
None => view.frame(store::now_ms(), None, None),
};
for line in lines {
writeln!(out, "{line}")?;
}
return Ok(0);
}
let mut stop = std::pin::pin!(stopped());
tokio::select! {
biased;
() = &mut stop => return Ok(0),
() = std::future::ready(()) => {}
}
let mut keys = match std::io::stdin().is_terminal() {
true => platform::Keys::enable(),
false => None,
};
let (send, mut read) = tokio::sync::mpsc::unbounded_channel();
if keys.is_some() {
std::thread::spawn(move || read_keys(send));
}
let mut input = Input::default();
let mut ui = Ui {
open: focus.clone(),
list_paused: focus.is_some(),
chosen: focus,
keys: keys.is_some(),
..Ui::default()
};
let _ansi = platform::Ansi::enable();
show("\x1b[?1049h\x1b[?25l\x1b[?7l")?;
let mut tick = tokio::time::interval(REFRESH);
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
tick.tick().await;
let mut previous = Vec::new();
let mut last_size = None;
let drawn = loop {
let size = platform::terminal_size()
.filter(|&(w, h)| w > 0 && h > 0)
.or_else(env_size)
.unwrap_or(FALLBACK_SIZE);
let lines = ui.draw(&mut view, store::now_ms(), size);
let output = redraw(&previous, &lines, last_size != Some(size), size.1);
if !output.is_empty()
&& let Err(e) = show(&output)
{
break Err(e);
}
previous = lines;
last_size = Some(size);
let pressed = tokio::select! {
() = &mut stop => break Ok(()),
bytes = read.recv(), if ui.keys => match bytes {
Some(bytes) => input.feed(&bytes),
None => {
keys = None;
ui.keys = false;
input = Input::default();
Vec::new()
}
},
() = tokio::time::sleep(ESC_WAIT), if input.waiting() => input.flush(),
_ = tick.tick() => {
view.refresh();
Vec::new()
}
};
let now = store::now_ms();
if !pressed.into_iter().all(|key| ui.press(key, &view, now)) {
break Ok(());
}
};
show("\x1b[?2026l\x1b[0m\x1b[?7h\x1b[?25h\x1b[?1049l")?;
drop(keys);
drawn?;
Ok(0)
}
async fn stopped() {
#[cfg(unix)]
let terminate = async {
use tokio::signal::unix::{SignalKind, signal};
match signal(SignalKind::terminate()) {
Ok(mut s) => drop(s.recv().await),
Err(_) => std::future::pending().await,
}
};
#[cfg(not(unix))]
let terminate = std::future::pending::<()>();
tokio::select! {
_ = tokio::signal::ctrl_c() => {}
() = terminate => {}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum Key {
Up,
Down,
PageUp,
PageDown,
Home,
End,
Open,
Back,
Q,
Quit,
}
#[derive(Default)]
struct Input {
pending: Vec<u8>,
}
impl Input {
fn feed(&mut self, bytes: &[u8]) -> Vec<Key> {
self.pending.extend_from_slice(bytes);
let mut out = Vec::new();
let mut i = 0;
while let Some((key, used)) = key_at(&self.pending[i..]) {
out.extend(key);
i += used;
}
self.pending.drain(..i);
out
}
fn waiting(&self) -> bool {
!self.pending.is_empty()
}
fn flush(&mut self) -> Vec<Key> {
let esc = self.pending == [0x1b];
self.pending.clear();
esc.then_some(Key::Back).into_iter().collect()
}
}
fn key_at(bytes: &[u8]) -> Option<(Option<Key>, usize)> {
Some(match bytes {
[] | [0x1b] | [0x1b, b'[' | b'O'] => return None,
[0x1b, b'[', tail @ ..] => {
let params = tail
.iter()
.take_while(|b| (0x20..0x40).contains(*b))
.count();
match *tail.get(params)? {
end @ 0x40..=0x7e => {
let key = if end == b'~' {
match tail[..params].split(|b| *b == b';').next() {
Some(b"1" | b"7") => Some(Key::Home),
Some(b"4" | b"8") => Some(Key::End),
Some(b"5") => Some(Key::PageUp),
Some(b"6") => Some(Key::PageDown),
_ => None,
}
} else {
arrow(end)
};
(key, 2 + params + 1)
}
_ => (None, 2 + params),
}
}
[0x1b, b'O', end @ 0x40..=0x7e, ..] => (arrow(*end), 3),
[0x1b, b'O', ..] => (None, 2),
[0x1b, ..] => (Some(Key::Back), 1),
[b'\r' | b'\n', ..] => (Some(Key::Open), 1),
[b'k', ..] => (Some(Key::Up), 1),
[b'j', ..] => (Some(Key::Down), 1),
[b'q', ..] => (Some(Key::Q), 1),
[0x7f | 0x08, ..] => (Some(Key::Back), 1),
[0x03, ..] => (Some(Key::Quit), 1),
_ => (None, 1),
})
}
fn arrow(b: u8) -> Option<Key> {
match b {
b'A' => Some(Key::Up),
b'B' => Some(Key::Down),
b'C' => Some(Key::Open),
b'D' => Some(Key::Back),
b'H' => Some(Key::Home),
b'F' => Some(Key::End),
_ => None,
}
}
fn read_keys(send: tokio::sync::mpsc::UnboundedSender<Vec<u8>>) {
let mut stdin = std::io::stdin().lock();
let mut bytes = [0; 64];
loop {
match stdin.read(&mut bytes) {
Ok(0) if cfg!(windows) => std::thread::sleep(Duration::from_millis(50)),
Ok(0) => return,
Ok(n) => {
if send.send(bytes[..n].to_vec()).is_err() {
return;
}
}
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => {}
Err(_) => return,
}
}
}
#[derive(Default)]
struct Ui {
open: Option<String>,
chosen: Option<String>,
keys: bool,
list_top: usize,
list_paused: bool,
list_anchor: Option<(String, usize)>,
page: usize,
detail: Scroll,
}
impl Ui {
fn draw(&mut self, view: &mut View, now: u64, size: (usize, usize)) -> Vec<String> {
self.page = size.1.saturating_sub(3).max(1);
if let Some(id) = &self.open {
return view.task_view(
id,
now,
Some(size),
self.keys,
self.keys.then_some(&mut self.detail),
);
}
if !self.keys {
return view.frame(now, Some(size), None);
}
view.load_list(now);
let rows = view.table(now).0;
if !self.list_paused {
self.list_top = 0;
self.list_anchor = None;
self.chosen = rows.iter().find_map(|r| r.id.clone());
} else if !self
.chosen
.as_ref()
.is_some_and(|c| rows.iter().any(|r| r.id.as_ref() == Some(c)))
{
self.chosen = rows.iter().find_map(|r| r.id.clone());
}
let at = rows
.iter()
.position(|r| r.id.is_some() && r.id == self.chosen);
if let (Some(at), Some((id, offset))) = (at, &self.list_anchor)
&& self.chosen.as_ref() == Some(id)
{
self.list_top = at.saturating_sub(*offset);
}
let frame = view.list_frame(
now,
Some(size),
self.chosen.as_deref(),
Some(&mut self.list_top),
);
self.list_anchor =
at.and_then(|at| Some((self.chosen.clone()?, at.saturating_sub(self.list_top))));
frame
}
fn press(&mut self, key: Key, view: &View, now: u64) -> bool {
if self.open.is_none()
&& matches!(
key,
Key::Up | Key::Down | Key::PageUp | Key::PageDown | Key::Home | Key::End
)
{
self.list_anchor = None;
self.list_paused = true;
}
match (key, &self.open) {
(Key::Quit, _) | (Key::Q, None) => return false,
(Key::Back | Key::Q, Some(_)) => self.open = None,
(Key::Open, None) => {
self.open = self.chosen.clone();
self.detail = Scroll::default();
}
(Key::Up | Key::Down | Key::PageUp | Key::PageDown | Key::Home | Key::End, Some(_)) => {
self.detail.press(key);
}
(Key::Up | Key::Down, None) => {
let ids = view.order(now);
let at = self
.chosen
.as_ref()
.and_then(|c| ids.iter().position(|id| id == c));
let next = match (key, at) {
(Key::Up, Some(i)) => i.saturating_sub(1),
(_, Some(i)) => (i + 1).min(ids.len().saturating_sub(1)),
_ => 0,
};
self.chosen = ids.into_iter().nth(next);
}
(Key::PageUp | Key::PageDown | Key::Home | Key::End, None) => {
self.list_top = match key {
Key::Home => 0,
Key::End => usize::MAX,
Key::PageUp => self.list_top.saturating_sub(self.page),
_ => self.list_top.saturating_add(self.page),
};
let rows = view.table(now).0;
let at = rows
.iter()
.position(|r| r.id.is_some() && r.id == self.chosen)
.unwrap_or(0);
let target = match key {
Key::Home => 0,
Key::End => rows.len().saturating_sub(1),
Key::PageUp => at.saturating_sub(self.page),
_ => at
.saturating_add(self.page)
.min(rows.len().saturating_sub(1)),
};
let next = if matches!(key, Key::PageUp | Key::End) {
rows.iter()
.take(target + 1)
.rev()
.find_map(|r| r.id.clone())
.or_else(|| rows.iter().find_map(|r| r.id.clone()))
} else {
rows.iter().skip(target).find_map(|r| r.id.clone())
};
self.chosen = next;
}
_ => {}
}
if self.open.is_none()
&& matches!(key, Key::Up | Key::PageUp | Key::Home)
&& self.chosen == view.order(now).first().cloned()
{
self.list_paused = false;
self.list_top = 0;
}
true
}
}
#[derive(Default)]
struct Scroll {
top: Option<usize>,
end: usize,
page: usize,
}
impl Scroll {
fn press(&mut self, key: Key) {
let at = self.top.unwrap_or(self.end);
let step = if matches!(key, Key::PageUp | Key::PageDown) {
self.page.max(1)
} else {
1
};
self.top = match key {
Key::Home => Some(0),
Key::End => None,
Key::Up | Key::PageUp => Some(at.saturating_sub(step)),
Key::Down | Key::PageDown => {
let next = at.saturating_add(step);
(next < self.end).then_some(next)
}
_ => self.top,
};
}
fn rows(&mut self, rows: Vec<Vec<Seg>>, height: usize) -> Vec<Vec<Seg>> {
let total = rows.len();
let footer = height > 1;
let room = height.saturating_sub(usize::from(footer));
self.page = room.max(1);
self.end = total.saturating_sub(room);
if let Some(top) = &mut self.top {
*top = (*top).min(self.end);
}
let top = self.top.unwrap_or(self.end);
let mut shown: Vec<_> = rows.into_iter().skip(top).take(room).collect();
if footer {
shown.resize(room, Vec::new());
let mode = if self.top.is_none() { "live" } else { "paused" };
shown.push(vec![(
format!(
" {}–{}/{} {mode} ↑↓ scroll PgUp/PgDn page Home/End",
(top + 1).min(total),
(top + room).min(total),
total
),
DIM,
)]);
}
shown
}
}
fn show(s: &str) -> std::io::Result<()> {
let mut out = std::io::stdout().lock();
out.write_all(s.as_bytes())?;
out.flush()
}
fn redraw(previous: &[String], lines: &[String], resized: bool, height: usize) -> String {
let mut changes = String::new();
for (i, line) in lines.iter().enumerate() {
if resized || previous.get(i) != Some(line) {
changes.push_str(&format!("\x1b[{};1H{line}\x1b[0m\x1b[K", i + 1));
}
}
if (resized || lines.len() < previous.len()) && lines.len() < height {
changes.push_str(&format!("\x1b[{};1H\x1b[J", lines.len() + 1));
}
if changes.is_empty() {
return changes;
}
format!("\x1b[?2026h\x1b[0m{changes}\x1b[?2026l")
}
fn env_size() -> Option<(usize, usize)> {
let get = |k: &str| -> Option<usize> {
std::env::var(k)
.ok()?
.trim()
.parse()
.ok()
.filter(|&n| n > 0)
};
Some((get("COLUMNS")?, get("LINES").unwrap_or(FALLBACK_SIZE.1)))
}
#[derive(Debug, PartialEq, Eq)]
struct FileStamp {
len: u64,
modified: SystemTime,
created: Option<SystemTime>,
}
impl FileStamp {
fn of(path: &Path) -> Option<Self> {
let m = fs::metadata(path).ok()?;
Some(Self {
len: m.len(),
modified: m.modified().ok()?,
created: m.created().ok(),
})
}
}
struct View {
store: Store,
root: PathBuf,
task_stamps: HashMap<String, FileStamp>,
detail: Option<(String, Tail)>,
list_ready: bool,
detail_ready: bool,
all: bool,
tasks: HashMap<String, Task>,
tails: HashMap<String, Tail>,
width: usize,
id_width: usize,
last_spawned: HashMap<String, u64>,
projects: HashMap<PathBuf, Option<String>>,
}
impl View {
fn new(home: &Path, all: bool) -> View {
View {
store: Store::new(home),
root: home.join("tasks"),
task_stamps: HashMap::new(),
detail: None,
list_ready: false,
detail_ready: false,
all,
tasks: HashMap::new(),
tails: HashMap::new(),
width: 0,
id_width: 0,
last_spawned: HashMap::new(),
projects: HashMap::new(),
}
}
fn refresh(&mut self) {
self.list_ready = false;
self.detail_ready = false;
let Ok(entries) = fs::read_dir(&self.root) else {
if !self.root.exists() {
self.tasks.clear();
self.task_stamps.clear();
self.tails.clear();
self.detail = None;
}
return;
};
let mut changed = false;
let mut present = HashSet::new();
for entry in entries.flatten() {
let Some(id) = entry.file_name().to_str().map(str::to_owned) else {
continue;
};
present.insert(id.clone());
let path = entry.path().join("task.json");
let Some(stamp) = FileStamp::of(&path) else {
continue;
};
if self.task_stamps.get(&id) == Some(&stamp) {
continue;
}
if let Some(t) = fs::read(&path)
.ok()
.and_then(|bytes| serde_json::from_slice::<Task>(&bytes).ok())
.filter(|t| t.id == id)
{
changed = true;
self.tasks.insert(id.clone(), t);
self.task_stamps.insert(id, stamp);
}
}
let previous = self.tasks.len();
self.tasks
.retain(|id, _| present.contains(id) || self.store.exists(id));
if !changed && previous == self.tasks.len() {
return;
}
self.task_stamps.retain(|id, _| self.tasks.contains_key(id));
self.tails.retain(|id, _| self.tasks.contains_key(id));
if self
.detail
.as_ref()
.is_some_and(|(id, _)| !self.tasks.contains_key(id))
{
self.detail = None;
}
for t in self.tasks.values() {
let mut depth = 1;
let mut root = t;
let mut up = self.parent(t);
while let Some(p) = up.filter(|_| depth <= self.tasks.len()) {
depth += 1;
root = p;
up = self.parent(p);
}
let caller = root.parent.clone();
let at = self.last_spawned.entry(caller).or_default();
*at = (*at).max(t.created_ms);
self.projects
.entry(t.cwd.clone())
.or_insert_with(|| project(&t.cwd));
self.width = self.width.max(columns(&name_cell(depth, t)));
if t.name.is_some() {
self.id_width = self.id_width.max(columns(&t.id));
}
}
}
fn shown(&self, now: u64) -> HashSet<&str> {
let mut shown: HashSet<&str> = self
.tasks
.values()
.filter(|t| self.all || active(t) || now.saturating_sub(t.updated_ms) < RECENT_MS)
.map(|t| t.id.as_str())
.collect();
for id in shown.clone() {
let mut up = self.parent(&self.tasks[id]);
while let Some(p) = up {
if !shown.insert(&p.id) {
break;
}
up = self.parent(p);
}
}
shown
}
fn load_list(&mut self, now: u64) {
if self.list_ready {
return;
}
self.list_ready = true;
self.detail_ready = false;
let shown: HashSet<String> = self.shown(now).into_iter().map(str::to_owned).collect();
self.tails.retain(|id, _| shown.contains(id));
for id in shown {
self.tails
.entry(id.clone())
.or_default()
.refresh(&self.store, &self.tasks[&id], false);
}
}
fn load_detail(&mut self, id: &str) {
let same = self.detail.as_ref().is_some_and(|(loaded, _)| loaded == id);
if same && self.detail_ready {
return;
}
self.detail_ready = true;
self.list_ready = false;
let Some(t) = self.tasks.get(id) else {
return;
};
if !same {
self.detail = Some((id.to_owned(), Tail::default()));
}
self.detail
.as_mut()
.unwrap()
.1
.refresh(&self.store, t, true);
}
fn find(&self, reference: &str) -> Result<String> {
if self.tasks.contains_key(reference) {
return Ok(reference.into());
}
let mut named: Vec<&str> = self
.tasks
.values()
.filter(|t| t.name.as_deref() == Some(reference))
.map(|t| t.id.as_str())
.collect();
named.sort();
match named.as_slice() {
[id] => Ok(id.to_string()),
[] => bail!("no task {reference}"),
ids => bail!(
"{} tasks are named {reference}; give one of their IDs: {}",
ids.len(),
ids.join(", ")
),
}
}
fn parent(&self, t: &Task) -> Option<&Task> {
identity::task_of(&t.parent).and_then(|id| self.tasks.get(id))
}
fn tail(&self, id: &str) -> &Tail {
static NONE: Tail = Tail::empty();
self.tails.get(id).unwrap_or(&NONE)
}
fn frame(
&mut self,
now: u64,
size: Option<(usize, usize)>,
chosen: Option<&str>,
) -> Vec<String> {
self.load_list(now);
self.list_frame(now, size, chosen, None)
}
fn list_frame(
&self,
now: u64,
size: Option<(usize, usize)>,
chosen: Option<&str>,
scroll: Option<&mut usize>,
) -> Vec<String> {
let (mut rows, hidden) = self.table(now);
let count = |s: Status| self.tasks.values().filter(|t| t.status == s).count();
let approvals: usize = self
.tasks
.values()
.filter(|t| t.status == Status::Running)
.map(|t| self.tail(&t.id).approvals.len())
.sum();
let counts: Vec<String> = [
(count(Status::Running), "running"),
(count(Status::Waiting), "waiting"),
(count(Status::Queued), "queued"),
(approvals, "approval(s)"),
]
.into_iter()
.filter(|(n, _)| *n > 0)
.map(|(n, what)| format!("{n} {what}"))
.collect();
let counts = match counts.is_empty() {
true => "nothing running".to_string(),
false => counts.join(", "),
};
let mut title: Vec<Seg> = vec![("axiopera top".into(), BOLD), (format!(" {counts}"), "")];
if hidden > 0 {
title.push((format!(" {hidden} older hidden (--all)"), DIM));
}
if chosen.is_some() {
title.push((" ↑↓ choose Enter open q quit".into(), DIM));
}
let mut lines = vec![title, vec![]];
if rows.is_empty() {
lines.push(vec![("no tasks".into(), DIM)]);
return finish(&lines, size);
}
if let Some(row) = chosen.and_then(|c| rows.iter_mut().find(|r| r.id.as_deref() == Some(c)))
{
row.chosen = true;
row.segs.insert(0, (String::new(), CHOSEN));
}
match size {
None => lines.extend(rows.into_iter().map(|r| r.segs)),
Some((_, height)) => {
let room = height.saturating_sub(lines.len());
if let Some(top) = scroll {
let total = rows.len();
let footer = total > room && room > 1;
let page = room.saturating_sub(usize::from(footer)).max(1);
*top = (*top).min(total.saturating_sub(page));
if let Some(at) = rows.iter().position(|r| r.chosen) {
*top = (*top).min(at).max(at.saturating_sub(page - 1));
if page > 1 && at > 0 && rows[at - 1].id.is_none() && *top == at {
*top = at - 1;
}
}
lines.extend(rows.into_iter().skip(*top).take(page).map(|r| r.segs));
if footer {
lines.push(vec![(
format!(
" rows {}–{}/{} PgUp/PgDn page Home/End",
*top + 1,
(*top + page).min(total),
total
),
DIM,
)]);
}
} else {
lines.extend(choose(rows, room));
}
}
}
finish(&lines, size)
}
fn order(&self, now: u64) -> Vec<String> {
self.table(now).0.into_iter().filter_map(|r| r.id).collect()
}
fn table(&self, now: u64) -> (Vec<Row>, usize) {
let shown = self.shown(now);
let hidden = self.tasks.len() - shown.len();
let mut sorted: Vec<&Task> = shown.iter().map(|id| &self.tasks[*id]).collect();
sorted.sort_by_key(|t| (Reverse(t.created_ms), t.id.as_str()));
let mut groups: Vec<(&str, Vec<&Task>)> = Vec::new();
let mut children: HashMap<&str, Vec<&Task>> = HashMap::new();
for t in sorted {
match self.parent(t) {
Some(p) => children.entry(p.id.as_str()).or_default().push(t),
None => match groups.iter_mut().find(|(c, _)| *c == t.parent) {
Some((_, roots)) => roots.push(t),
None => groups.push((t.parent.as_str(), vec![t])),
},
}
}
groups
.sort_by_key(|(caller, _)| (Reverse(self.last_spawned.get(*caller).copied()), *caller));
let short: Vec<String> = groups
.iter()
.map(|(c, _)| caller_label(c, SESSION))
.collect();
let labels: HashMap<&str, String> = groups
.iter()
.zip(&short)
.map(
|((caller, _), label)| match short.iter().filter(|l| *l == label).count() {
1 => (*caller, label.clone()),
_ => (*caller, caller_label(caller, usize::MAX)),
},
)
.collect();
let mut order: Vec<(&str, Option<(usize, &Task)>)> = Vec::new();
for (caller, roots) in &groups {
order.push((*caller, None));
let mut stack: Vec<(usize, &Task)> = roots.iter().rev().map(|t| (1, *t)).collect();
while let Some((depth, t)) = stack.pop() {
order.push((*caller, Some((depth, t))));
if let Some(kids) = children.get(t.id.as_str()) {
stack.extend(kids.iter().rev().map(|k| (depth + 1, *k)));
}
}
}
let mut projects: HashMap<&str, Vec<&str>> = HashMap::new();
for (caller, row) in &order {
let names = projects.entry(caller).or_default();
let name = row.and_then(|(_, t)| self.projects.get(&t.cwd)?.as_deref());
if let Some(name) = name.filter(|n| !names.contains(n)) {
names.push(name);
}
}
let mut rows = Vec::new();
let mut lines: HashMap<&str, usize> = HashMap::new();
let mut group = None;
for (caller, row) in order {
let Some((depth, t)) = row else {
group = Some(rows.len());
let mut segs = Vec::new();
if let Some(names) = projects.get(caller).filter(|n| !n.is_empty()) {
segs.push((clean(&names.join(", ")), ""));
segs.push((" · ".into(), DIM));
}
segs.push((labels[caller].clone(), DIM));
rows.push(Row {
rank: WITH_TASKS,
..Row::new(segs)
});
continue;
};
let mut with: Vec<usize> = group.into_iter().collect();
let mut up = self.parent(t);
while let Some(p) = up {
with.extend(lines.get(p.id.as_str()));
up = self.parent(p);
}
lines.insert(&t.id, rows.len());
rows.push(Row {
with,
..self.task_row(&name_cell(depth, t), t, self.width)
});
}
(rows, hidden)
}
fn task_row(&self, cell: &str, t: &Task, width: usize) -> Row {
let tail = self.tail(&t.id);
let (state, color) = state(t, tail);
let mut segs = vec![(format!("{} ", pad(cell, width)), "")];
if self.id_width > 0 {
let id = t.name.as_ref().map_or("", |_| t.id.as_str());
segs.push((format!("{} ", pad(id, self.id_width)), DIM));
}
match words(t, tail) {
Some(text) => {
segs.push((pad(state, STATE), color));
segs.push((" ".into(), ""));
segs.extend(markdown::inline(&text));
}
None => segs.push((state.into(), color)),
}
Row {
rank: rank(t, tail),
spawned: t.created_ms,
id: Some(t.id.clone()),
..Row::new(segs)
}
}
fn task_frame(
&mut self,
id: &str,
now: u64,
size: Option<(usize, usize)>,
keys: bool,
) -> Vec<String> {
self.task_view(id, now, size, keys, None)
}
fn task_view(
&mut self,
id: &str,
now: u64,
size: Option<(usize, usize)>,
keys: bool,
scroll: Option<&mut Scroll>,
) -> Vec<String> {
self.load_detail(id);
let width = size.map(|(w, _)| w);
let back = |title: Vec<Seg>| match keys {
true => hinted(title, " Esc back", width),
false => title,
};
let Some(t) = self.tasks.get(id) else {
let gone = format!("{id} is gone: it was removed, by gc or by hand");
return finish(&[back(vec![(gone, DIM)])], size);
};
let tail = &self.detail.as_ref().unwrap().1;
let (state, color) = state(t, tail);
let agent = format!(
"{}/{}",
render::agent_name(t.agent),
render::tier_name(t.tier)
);
let about = match &t.name {
Some(_) => format!(" {id} {agent} "),
None => format!(" {agent} "),
};
let title = back(vec![
(clean(t.name.as_deref().unwrap_or(id)), BOLD),
(about, DIM),
(state.into(), color),
(format!(" {}", meta(t, tail, now)), ""),
]);
let mut head = vec![title];
let mut waiting: Vec<Vec<Seg>> = details(t, tail).iter().map(Detail::row).collect();
if let Some((_, height)) = size
&& scroll.is_none()
&& waiting.len() > height.saturating_sub(head.len())
{
let kept = height.saturating_sub(head.len() + 1);
let more = waiting.len() - kept;
waiting.truncate(kept);
waiting.push(vec![(format!("{:8}…and {more} more", ""), DIM)]);
}
head.extend(waiting);
let mut blocks: Vec<(u64, Block)> = Vec::new();
let prompt = || Some((tail.prompt.as_ref()?, self.store.prompt_path(id)));
let first = tail.first.as_ref().map(|(t, f)| (t, f.clone()));
match first.or_else(prompt) {
Some((text, file)) => blocks.push((0, Block::task(text.shown(), Some(file)))),
None if tail.log.is_empty() => blocks.push((
0,
Block::task(
vec!["not recorded: spawned before axiopera kept it".into()],
None,
),
)),
None => {}
}
let given = blocks.len();
let cwd = t.cwd.to_string_lossy();
let result = |turn: u32| {
let (r, _) = tail.results.get(&turn)?;
Some(r).filter(|r| !r.lines.is_empty())
};
let as_result =
|turn: u32, r: &Text| Block::said(r.shown(), Some(self.store.turn_path(id, turn)));
let mut result_shown = false;
for l in &tail.log {
let block = match &l.what {
What::Said { text, turn } => match turn.and_then(|n| Some((n, result(n)?))) {
Some((n, r)) => {
result_shown |= n == t.turns;
as_result(n, r)
}
None => Block::said(
uncounted(text).split(" ↵ ").map(String::from).collect(),
None,
),
},
What::Tool { name, detail, .. } => {
Block::Tools(vec![tool_call(name, detail, &cwd)])
}
What::Turn(n) => Block::Turn(format!(
"── turn {n}, {} ago",
age(now.saturating_sub(l.at))
)),
What::Given { text, file, .. } => Block::task(text.shown(), Some(file.clone())),
};
blocks.push((l.at, block));
}
if let Some(r) = result(t.turns).filter(|_| !result_shown) {
let at = match tail.ended_ms {
0 => t.updated_ms,
at => at,
};
blocks.push((at, as_result(t.turns, r)));
}
blocks[given..].sort_by_key(|(at, _)| *at);
let mut merged: Vec<Block> = Vec::new();
for (_, b) in blocks {
match (merged.last_mut(), b) {
(Some(Block::Tools(rows)), Block::Tools(more)) => rows.extend(more),
(_, b) => merged.push(b),
}
}
let mut blocks = merged;
if size.is_none() {
let said: Vec<usize> = (given..blocks.len())
.filter(|&i| matches!(blocks[i], Block::Text { .. }))
.collect();
if said.len() > PLAIN_MESSAGES {
blocks.drain(given..said[said.len() - PLAIN_MESSAGES]);
}
}
let mut lines = head;
if let (Some((width, height)), Some(scroll)) = (size, scroll) {
let mut waiting = lines.split_off(1);
let room = height.saturating_sub(1) / 2;
let pinned = match waiting.len() <= room {
true => waiting.len(),
false => room.saturating_sub(1),
};
let mut body = waiting.split_off(pinned);
lines.extend(waiting);
if !body.is_empty() && room > 0 {
let more = format!("{:8}…and {} more above the conversation", "", body.len());
lines.push(vec![(more, DIM)]);
}
for b in &blocks {
if !matches!(b, Block::Tools(_)) {
body.push(vec![]);
}
body.extend(b.rows(Some(width), &cwd));
}
lines.extend(scroll.rows(body, height.saturating_sub(lines.len())));
return finish(&lines, size);
}
match size {
None => {
for b in &blocks {
if !matches!(b, Block::Tools(_)) {
lines.push(vec![]);
}
lines.extend(b.rows(None, &cwd));
}
}
Some((width, height)) => {
let room = height.saturating_sub(lines.len());
let rows = transcript(&blocks, width, room, &cwd);
if rows.len() < room {
lines.push(vec![]);
}
lines.extend(rows);
}
}
finish(&lines, size)
}
}
fn left_out(count: &str, file: Option<&Path>, width: usize) -> Vec<Vec<Seg>> {
let count = count.to_string();
let Some(file) = file else {
return vec![vec![(count, DIM)]];
};
let path = file.display().to_string();
let one = format!("{count}; all in {path}");
if columns(&one) < width {
return vec![vec![(one, DIM)]];
}
let pieces = chop(&path, width.saturating_sub(GUTTER + 1));
std::iter::once(vec![(format!("{count}; all in:"), DIM)])
.chain(
pieces
.into_iter()
.map(|p| vec![(format!("{:GUTTER$}{p}", ""), DIM)]),
)
.collect()
}
fn chop(text: &str, room: usize) -> Vec<String> {
let room = room.max(2);
let mut out = vec![String::new()];
let mut used = 0;
for c in text.chars() {
let w = char_columns(c);
if used + w > room {
out.push(String::new());
used = 0;
}
out.last_mut().unwrap().push(c);
used += w;
}
out
}
enum Block {
Text {
mark: (&'static str, &'static str),
lines: Vec<String>,
file: Option<PathBuf>,
},
Tools(Vec<(String, String)>),
Turn(String),
}
impl Block {
fn task(lines: Vec<String>, file: Option<PathBuf>) -> Block {
Block::Text {
mark: TASK_MARK,
lines,
file,
}
}
fn said(lines: Vec<String>, file: Option<PathBuf>) -> Block {
Block::Text {
mark: SAID_MARK,
lines,
file,
}
}
fn rows(&self, width: Option<usize>, cwd: &str) -> Vec<Vec<Seg>> {
match self {
Block::Text { mark, lines, .. } => {
let room = width.map(|w| w.saturating_sub(GUTTER + 1));
let mut rows = markdown::render(lines, room, cwd);
if rows.is_empty() {
rows.push(Vec::new());
}
for (i, row) in rows.iter_mut().enumerate() {
match i {
0 => row.insert(0, (mark.0.to_string(), mark.1)),
_ if !row.is_empty() => row.insert(0, (" ".repeat(GUTTER), "")),
_ => {}
}
}
rows
}
Block::Tools(calls) => calls
.iter()
.enumerate()
.map(|(i, (name, detail))| {
let gutter = if i == 0 { " └ " } else { " " };
let mut row = vec![(gutter.to_string(), DIM), (name.clone(), "")];
if !detail.is_empty() {
row.push((format!(" {detail}"), DIM));
}
row
})
.collect(),
Block::Turn(text) => vec![vec![(text.clone(), DIM)]],
}
}
fn file(&self) -> Option<&Path> {
match self {
Block::Text { file, .. } => file.as_deref(),
_ => None,
}
}
}
fn tool_call(name: &str, detail: &str, cwd: &str) -> (String, String) {
let verb = match name.to_ascii_lowercase().as_str() {
"bash" | "shell" | "execute" => "Run",
"read" => "Read",
"edit" | "multiedit" => "Edit",
"write" => "Write",
"grep" | "glob" | "search" => "Search",
"webfetch" | "fetch" => "Fetch",
_ => name,
};
let detail = from_dir(&one_line(&unshelled(uncounted(detail))), cwd);
(verb.to_string(), detail)
}
fn from_dir(text: &str, cwd: &str) -> String {
if cwd.is_empty() {
return text.to_string();
}
let mut out = String::new();
let mut kept = 0;
for (i, _) in text.match_indices(cwd) {
let end = i + cwd.len();
let starts = text[..i]
.chars()
.next_back()
.is_none_or(|c| c.is_whitespace() || "\"'`=(<>,;|&".contains(c));
if i >= kept && starts && text[end..].starts_with(['/', '\\']) {
out.push_str(&text[kept..i]);
kept = end + 1;
}
}
out.push_str(&text[kept..]);
out
}
fn transcript(blocks: &[Block], width: usize, room: usize, cwd: &str) -> Vec<Vec<Seg>> {
let mut shown: Vec<Vec<Vec<Seg>>> = Vec::new();
let mut left = room;
for (i, b) in blocks.iter().enumerate().rev() {
let mut rows = b.rows(Some(width), cwd);
let whole = rows.len();
let next = blocks.get(i + 1);
let gap = usize::from(next.is_some_and(|n| !matches!(n, Block::Tools(_))));
if gap > 0 {
rows.push(Vec::new());
}
if rows.len() <= left {
left -= rows.len();
shown.push(rows);
continue;
}
if next.is_none() && !matches!(b, Block::Tools(_)) {
let lead = |keep: usize| match keep {
0 => format!("{:GUTTER$}{whole} line(s)", ""),
_ => format!("{:GUTTER$}…{} more line(s)", "", whole - keep),
};
let file = b.file();
let keep = left.saturating_sub(left_out(&lead(1), file, width).len());
let note = left_out(&lead(keep), file, width);
rows.truncate(keep);
rows.extend(note);
rows.truncate(left);
shown.push(rows);
} else if left > gap {
let mut rows = rows.split_off(rows.len() - left);
match rows[0].first_mut() {
Some(gutter) => {
let w = columns(&gutter.0);
*gutter = (format!("{:w$}", "…"), DIM);
}
None => rows[0].push(("…".into(), DIM)),
}
shown.push(rows);
}
break;
}
shown.into_iter().rev().flatten().collect()
}
fn hinted(title: Vec<Seg>, hint: &str, width: Option<usize>) -> Vec<Seg> {
let mut room = width.map_or(usize::MAX, |w| w.saturating_sub(1 + columns(hint)));
let mut out = Vec::new();
for (text, color) in title {
let (piece, cut) = fit(&clean(&text), room);
room -= columns(&piece);
out.push((piece, color));
if cut {
break;
}
}
out.push((hint.to_string(), DIM));
out
}
fn finish(lines: &[Vec<Seg>], size: Option<(usize, usize)>) -> Vec<String> {
let width = size.map(|(w, _)| w);
let mut out: Vec<String> = lines.iter().map(|l| paint(l, width)).collect();
match size {
Some((_, height)) => out.truncate(height),
None => {
for line in &mut out {
line.truncate(line.trim_end().len());
}
}
}
out
}
struct Row {
segs: Vec<Seg>,
rank: u8,
spawned: u64,
with: Vec<usize>,
id: Option<String>,
chosen: bool,
}
impl Row {
fn new(segs: Vec<Seg>) -> Row {
Row {
segs,
rank: 0,
spawned: 0,
with: Vec::new(),
id: None,
chosen: false,
}
}
}
fn rank(t: &Task, tail: &Tail) -> u8 {
if waits(t, tail) {
0
} else if matches!(t.status, Status::Running | Status::Queued) {
1
} else if matches!(t.status, Status::Failed | Status::Interrupted) || t.detached {
2
} else {
3
}
}
fn choose(rows: Vec<Row>, room: usize) -> Vec<Vec<Seg>> {
if rows.len() <= room {
return rows.into_iter().map(|r| r.segs).collect();
}
let (mut out, left) = pick(rows, room.saturating_sub(1));
if out.len() < room {
out.push(vec![(format!(" …and {left} more task(s)"), DIM)]);
}
out
}
fn pick(rows: Vec<Row>, budget: usize) -> (Vec<Vec<Seg>>, usize) {
let mut order: Vec<usize> = (0..rows.len())
.filter(|&i| rows[i].rank != WITH_TASKS)
.collect();
order.sort_by_key(|&i| {
let r = &rows[i];
(!r.chosen, r.rank, Reverse(r.spawned), Reverse(i))
});
let mut kept = vec![false; rows.len()];
let mut used = 0;
for i in order {
let cost = usize::from(!kept[i]) + rows[i].with.iter().filter(|&&w| !kept[w]).count();
if used + cost <= budget {
used += cost;
kept[i] = true;
for &w in &rows[i].with {
kept[w] = true;
}
} else if rows[i].chosen {
used += 1;
kept[i] = true;
}
}
let left = rows
.iter()
.zip(&kept)
.filter(|(r, k)| !**k && r.rank != WITH_TASKS)
.count();
let out = rows
.into_iter()
.zip(kept)
.filter(|(_, k)| *k)
.map(|(r, _)| r.segs)
.collect();
(out, left)
}
fn name_cell(depth: usize, t: &Task) -> String {
let name = clean(t.name.as_deref().unwrap_or(&t.id));
format!("{}{}", " ".repeat(depth), fit(&name, NAME).0)
}
fn meta(t: &Task, tail: &Tail, now: u64) -> String {
let ago = |ms: u64| age(now.saturating_sub(ms));
match t.status {
Status::Running if tail.in_turn => format!(
"turn {}, {}, {} tool call(s)",
t.turns + 1,
ago(tail.started_ms),
tail.tool_calls
),
Status::Running if tail.ended_ms > 0 => format!(
"turn {} ended {} ago; background work still runs",
t.turns,
ago(tail.ended_ms)
),
Status::Running => "starting".to_string(),
Status::Queued => "about to start".to_string(),
_ => {
let mut done = format!("{} turn(s), last change {} ago", t.turns, ago(t.updated_ms));
if !t.changed_files.is_empty() {
done.push_str(&format!(", {} file(s) changed", t.changed_files.len()));
}
done
}
}
}
struct Detail {
label: &'static str,
color: &'static str,
text: String,
}
impl Detail {
fn row(&self) -> Vec<Seg> {
vec![
(format!("{:>w$} ", self.label, w = LABEL - 2), self.color),
(one_line(&self.text), ""),
]
}
}
fn details(t: &Task, tail: &Tail) -> Vec<Detail> {
let mut out = Vec::new();
let line = |label, color, text: String| Detail { label, color, text };
if t.status == Status::Running {
for (id, summary) in &tail.approvals {
out.push(line("needs", YELLOW, format!("approval {id}: {summary}")));
}
}
if !t.status.is_final() {
for q in t.open_questions() {
out.push(line("asks", YELLOW, format!("{}: {}", q.id, q.text)));
}
}
if let Some((label, text)) = stop(t, tail) {
out.push(line(label, RED, text.into()));
}
out
}
fn stop<'a>(t: &Task, tail: &'a Tail) -> Option<(&'static str, &'a str)> {
let (label, text) = tail.stop.as_ref()?;
let stopped = !matches!(t.status, Status::Running | Status::Queued | Status::Idle);
(stopped || t.detached).then_some((*label, text.as_str()))
}
fn waits(t: &Task, tail: &Tail) -> bool {
t.status == Status::Waiting
|| t.status == Status::Running && !tail.approvals.is_empty()
|| !t.status.is_final() && t.open_questions().next().is_some()
}
fn words(t: &Task, tail: &Tail) -> Option<String> {
let asked = match t.status.is_final() {
true => None,
false => t.open_questions().max_by_key(|q| q.asked_ms),
};
let text = match (&tail.words, asked) {
(Some((said, at)), Some(q)) if *at > q.asked_ms => said.clone(),
(_, Some(q)) => q.text.clone(),
(Some((said, _)), None) => said.clone(),
(None, None) => tail.results.get(&t.turns)?.0.lines.first()?.clone(),
};
Some(one_line(&uncounted(&text).replace(" ↵ ", " ")))
}
fn unshelled(command: &str) -> String {
let whole = command.trim();
let (shell, mut rest) = match whole.strip_prefix('"') {
Some(quoted) => match quoted.split_once('"') {
Some(split) => split,
None => return whole.into(),
},
None => whole.split_once(' ').unwrap_or((whole, "")),
};
let name = shell.rsplit(['/', '\\']).next().unwrap_or(shell);
let name = name.to_ascii_lowercase();
let name = name.strip_suffix(".exe").unwrap_or(&name);
if !["pwsh", "powershell", "bash", "sh", "zsh", "cmd"].contains(&name) {
return whole.into();
}
loop {
let (option, after) = rest.trim_start().split_once(' ').unwrap_or((rest, ""));
rest = after.trim_start();
let option = option.to_ascii_lowercase();
if ["-command", "-c", "-lc", "/c"].contains(&option.as_str()) {
break;
}
if rest.is_empty() || !option.starts_with(['-', '/']) {
return whole.into();
}
}
for (quote, escaped) in [('\'', "''"), ('"', "\\\"")] {
if let Some(inner) = rest.strip_prefix(quote) {
let inner = inner.strip_suffix(quote).unwrap_or(inner);
return inner.replace(escaped, "e.to_string());
}
}
rest.into()
}
fn uncounted(text: &str) -> &str {
const MARK: &str = "…(+";
match text.rfind(MARK) {
Some(i)
if text
.strip_suffix(" chars)")
.and_then(|t| t.get(i + MARK.len()..))
.is_some_and(|n| !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit())) =>
{
&text[..i + '…'.len_utf8()]
}
_ => text,
}
}
fn one_line(text: &str) -> String {
text.split_whitespace().collect::<Vec<_>>().join(" ")
}
fn age(ms: u64) -> String {
const DAY_MS: u64 = 24 * 60 * 60 * 1000;
if ms < 2 * DAY_MS {
return render::duration(ms);
}
format!("{}d{:02}h", ms / DAY_MS, ms % DAY_MS / (60 * 60 * 1000))
}
fn active(t: &Task) -> bool {
matches!(t.status, Status::Queued | Status::Running | Status::Waiting)
}
fn state(t: &Task, tail: &Tail) -> (&'static str, &'static str) {
match t.status {
_ if t.detached => ("detached", RED),
Status::Running if !tail.approvals.is_empty() => ("approval", YELLOW),
Status::Running if t.stalled => ("stalled", RED),
Status::Queued => ("queued", DIM),
Status::Running => ("running", GREEN),
Status::Idle => ("idle", DIM),
Status::Waiting => ("waiting", YELLOW),
Status::Failed => ("failed", RED),
Status::Interrupted => ("interrupted", RED),
Status::Cancelled => ("cancelled", DIM),
}
}
fn project(cwd: &Path) -> Option<String> {
let name = |dir: &Path| Some(dir.file_name()?.to_string_lossy().into_owned());
for dir in cwd.ancestors() {
let git = dir.join(".git");
if git.is_dir() {
return name(dir);
}
let Ok(text) = fs::read_to_string(&git) else {
continue;
};
let gitdir = text.lines().next().and_then(|l| l.strip_prefix("gitdir:"));
let main = gitdir
.map(|g| dir.join(g.trim()))
.and_then(|g| Some(g.parent()?.to_path_buf()))
.filter(|w| w.file_name().is_some_and(|n| n == "worktrees"))
.and_then(|w| Some(w.parent()?.to_path_buf()));
return match main {
Some(git) if git.file_name().is_some_and(|n| n == ".git") => name(git.parent()?),
Some(bare) => name(&bare).map(|n| n.strip_suffix(".git").unwrap_or(&n).to_string()),
None => name(dir),
};
}
name(cwd)
}
fn caller_label(caller: &str, session_chars: usize) -> String {
match caller.split_once(':') {
_ if caller == "user" => "user: terminals and unrecognized agents".into(),
Some((host, session)) if host != "task" => {
let session: String = session.chars().take(session_chars).collect();
format!("{host} session {session}")
}
_ => caller.into(),
}
}
struct Text {
lines: Vec<String>,
len: u64,
whole: bool,
}
fn read_text(path: &Path) -> Option<Text> {
let mut file = File::open(path).ok()?;
let len = file.metadata().ok()?.len();
let mut bytes = Vec::new();
Read::by_ref(&mut file)
.take(READ_BYTES)
.read_to_end(&mut bytes)
.ok()?;
let mut lines: Vec<String> = String::from_utf8_lossy(&bytes)
.lines()
.map(|l| l.trim_end().to_string())
.collect();
let first = lines
.iter()
.position(|l| !l.is_empty())
.unwrap_or(lines.len());
lines.drain(..first);
while lines.last().is_some_and(String::is_empty) {
lines.pop();
}
Some(Text {
lines,
len,
whole: bytes.len() as u64 >= len,
})
}
impl Text {
fn shown(&self) -> Vec<String> {
let mut lines = self.lines.clone();
if !self.whole {
lines.push("…".into());
}
lines
}
}
fn breaks(chars: &[char], room: usize) -> Vec<Range<usize>> {
let room = room.max(2);
let mut out = Vec::new();
let mut start = 0;
let mut used = 0;
for (i, &c) in chars.iter().enumerate() {
let w = char_columns(c);
if used + w > room {
if c == ' ' {
out.push(start..i);
start = i + 1;
used = 0;
continue;
}
match break_at(&chars[start..i], c) {
Some(k) => {
let mut end = start + k;
while end > start && chars[end - 1] == ' ' {
end -= 1;
}
out.push(start..end);
start += k;
}
None => {
out.push(start..i);
start = i;
}
}
used = chars[start..i].iter().map(|c| char_columns(*c)).sum();
}
used += w;
}
out.push(start..chars.len());
out
}
fn break_at(piece: &[char], next: char) -> Option<usize> {
let mut after = next;
for (i, &before) in piece.iter().enumerate().rev() {
let wide = char_columns(before) == 2 || char_columns(after) == 2;
let held =
",。、;:?!)」』】》,.;:?!)".contains(after) || "(「『【《(".contains(before);
if before == ' ' || wide && !held {
return Some(i + 1);
}
after = before;
}
None
}
#[derive(Default)]
struct Tail {
offset: u64,
stamp: Option<FileStamp>,
in_turn: bool,
started_ms: u64,
ended_ms: u64,
tool_calls: u64,
words: Option<(String, u64)>,
log: VecDeque<Logged>,
approvals: Vec<(String, String)>,
stop: Option<(&'static str, String)>,
prompt: Option<Text>,
first: Option<(Text, PathBuf)>,
results: BTreeMap<u32, (Text, bool)>,
ended_turns: BTreeSet<u32>,
}
impl Tail {
const fn empty() -> Tail {
Tail {
offset: 0,
stamp: None,
in_turn: false,
started_ms: 0,
ended_ms: 0,
tool_calls: 0,
words: None,
log: VecDeque::new(),
approvals: Vec::new(),
stop: None,
prompt: None,
first: None,
results: BTreeMap::new(),
ended_turns: BTreeSet::new(),
}
}
fn refresh(&mut self, store: &Store, t: &Task, detail: bool) {
self.read(&store.events_path(&t.id), |e| {
if !detail {
return None;
}
let path = store.message_path(&t.id, e.seq);
Some((read_text(&path)?, path))
});
if detail && self.prompt.is_none() {
self.prompt = read_text(&store.prompt_path(&t.id));
}
let mut wanted: Vec<u32> = self
.log
.iter()
.filter_map(|l| match l.what {
What::Said { turn, .. } => turn,
_ => None,
})
.collect();
if !detail {
wanted.clear();
}
if t.turns > 0 && (detail || self.words.is_none()) {
wanted.push(t.turns);
}
wanted.sort_unstable();
wanted.dedup();
self.results.retain(|n, _| wanted.contains(n));
for n in wanted {
let path = store.turn_path(&t.id, n);
let ended = self.ended_turns.contains(&n);
match self.results.get_mut(&n) {
Some((_, true)) => {}
Some((r, whole)) if fs::metadata(&path).is_ok_and(|m| m.len() == r.len) => {
*whole = ended
}
_ => match read_text(&path) {
Some(r) => drop(self.results.insert(n, (r, ended))),
None => drop(self.results.remove(&n)),
},
}
}
}
fn read(&mut self, path: &Path, message: impl Fn(&Event) -> Option<(Text, PathBuf)>) {
let Some(stamp) = FileStamp::of(path) else {
return;
};
if self.stamp.as_ref() == Some(&stamp) {
return;
}
let Ok(mut file) = File::open(path) else {
return;
};
if self.stamp.as_ref().is_some_and(|old| {
stamp.len < self.offset || stamp.len <= old.len || stamp.created != old.created
}) {
*self = Self::default();
}
if file.seek(SeekFrom::Start(self.offset)).is_err() {
return;
}
let mut reader = BufReader::new(file.take(stamp.len.saturating_sub(self.offset)));
let mut line = Vec::new();
loop {
line.clear();
match reader.read_until(b'\n', &mut line) {
Ok(0) => break,
Ok(_) if line.last() != Some(&b'\n') => break,
Ok(n) => {
self.offset += n as u64;
if let Ok(e) = serde_json::from_slice::<Event>(&line) {
self.absorb(&e, || message(&e));
}
}
Err(_) => return,
}
}
self.stamp = Some(stamp);
}
fn absorb(&mut self, e: &Event, message: impl FnOnce() -> Option<(Text, PathBuf)>) {
let text = |k: &str| e.data.get(k).and_then(Value::as_str).unwrap_or("");
let turn = || e.data.get("turn").and_then(Value::as_u64).map(|n| n as u32);
match e.kind.as_str() {
"turn_started" => {
let (queued, log) = std::mem::take(&mut self.log)
.into_iter()
.partition(|l| matches!(l.what, What::Given { queued: true, .. }));
self.log = log;
self.start(e.ts);
self.approvals.clear();
self.stop = None;
let n = turn();
if let Some(n) = n.filter(|n| *n > 1) {
self.log(e.ts, What::Turn(n));
}
for l in queued {
if let What::Given { text, file, .. } = l.what {
let queued = false;
self.log(e.ts, What::Given { text, file, queued });
}
}
match n {
Some(1) => self.first = message().filter(|(t, _)| !t.lines.is_empty()),
Some(_) => self.given(e.ts, false, message),
None => {}
}
}
"steered" => {
let queued = e.data.get("queued") == Some(&Value::Bool(true));
self.given(e.ts, queued, message);
}
"turn_ended" => {
if !self.in_turn {
self.start(e.ts);
}
self.in_turn = false;
self.ended_ms = e.ts;
self.ended_turns.extend(turn());
let since = self.started_ms;
let last = self.log.iter_mut().rev().take_while(|l| l.at >= since);
if let Some(What::Said {
turn: of @ None, ..
}) = last
.map(|l| &mut l.what)
.find(|w| matches!(w, What::Said { .. }))
{
*of = turn();
}
if e.data.get("ok") == Some(&Value::Bool(false)) {
self.stop = Some(("error", text("error").into()));
}
}
"said" => {
if !self.in_turn && self.ended_ms > 0 {
self.start(e.ts);
}
self.words = Some((text("text").into(), e.ts));
let text = text("text").into();
self.log(e.ts, What::Said { text, turn: None });
}
"tool" => {
if !self.in_turn {
self.start(e.ts);
}
self.tool_calls += 1;
let (name, detail) = (text("name").into(), text("detail").into());
self.log(
e.ts,
What::Tool {
id: text("id").into(),
name,
detail,
},
);
}
"tool_updated" => {
if !text("id").is_empty() {
for logged in self.log.iter_mut().rev() {
if let What::Tool { id, name, detail } = &mut logged.what
&& id == text("id")
{
*name = text("name").into();
*detail = text("detail").into();
break;
}
}
}
}
"approval_request" => self
.approvals
.push((text("id").into(), text("summary").into())),
"approved" | "denied" => self.approvals.retain(|(id, _)| id != text("id")),
"failed" => self.stop = Some(("error", text("error").into())),
"cancelled" | "interrupted" | "detached" => {
self.stop = Some(("why", text("reason").into()));
}
_ => {}
}
}
fn start(&mut self, at: u64) {
self.in_turn = true;
self.started_ms = at;
self.tool_calls = 0;
for l in &mut self.log {
if let What::Given { queued, .. } = &mut l.what {
*queued = false;
}
}
}
fn given(&mut self, at: u64, queued: bool, message: impl FnOnce() -> Option<(Text, PathBuf)>) {
if let Some((text, file)) = message().filter(|(t, _)| !t.lines.is_empty()) {
self.log(at, What::Given { text, file, queued });
}
}
fn log(&mut self, at: u64, what: What) {
if self.log.len() == LOGGED {
self.log.pop_front();
}
self.log.push_back(Logged { at, what });
}
}
struct Logged {
at: u64,
what: What,
}
enum What {
Said { text: String, turn: Option<u32> },
Tool {
id: String,
name: String,
detail: String,
},
Turn(u32),
Given {
text: Text,
file: PathBuf,
queued: bool,
},
}
fn paint(segs: &[Seg], width: Option<usize>) -> String {
let mut room = width.map_or(usize::MAX, |w| w.saturating_sub(1));
let chosen = width.is_some()
&& segs
.first()
.is_some_and(|(t, c)| t.is_empty() && *c == CHOSEN);
let sgr = |color: &str| match (chosen, color) {
(false, "") => None,
(false, c) => Some(c.to_string()),
(true, "") => Some(CHOSEN.to_string()),
(true, c) => Some(format!("{c};{CHOSEN}")),
};
let mut line = String::new();
for (text, color) in segs {
let (piece, cut) = fit(&clean(text), room);
room -= columns(&piece);
match sgr(color) {
Some(sgr) if width.is_some() && !piece.is_empty() => {
line.push_str(&format!("\x1b[{sgr}m{piece}\x1b[0m"));
}
_ => line.push_str(&piece),
}
if cut {
break;
}
}
if chosen && room > 0 {
line.push_str(&format!("\x1b[{CHOSEN}m{}\x1b[0m", " ".repeat(room)));
}
line
}
fn clean(text: &str) -> String {
text.chars()
.map(|c| match c {
'\n' => '↵',
c if c.is_control() => ' ',
c => c,
})
.collect()
}
fn fit(text: &str, room: usize) -> (String, bool) {
if columns(text) <= room {
return (text.to_string(), false);
}
let mut used = 0;
let mut kept = String::new();
for c in text.chars() {
let w = char_columns(c);
if used + w + 1 > room {
break;
}
used += w;
kept.push(c);
}
if room > 0 {
kept.push('…');
}
(kept, true)
}
fn pad(text: &str, width: usize) -> String {
let (mut s, _) = fit(text, width);
s.push_str(&" ".repeat(width.saturating_sub(columns(&s))));
s
}
fn columns(s: &str) -> usize {
s.chars().map(char_columns).sum()
}
fn char_columns(c: char) -> usize {
match c as u32 {
0x1100..=0x115F
| 0x231A..=0x23FF
| 0x25FD..=0x27BF
| 0x2B1B..=0x2B55
| 0x2E80..=0x303E
| 0x3041..=0x33FF
| 0x3400..=0x4DBF
| 0x4E00..=0x9FFF
| 0xA000..=0xA4CF
| 0xAC00..=0xD7A3
| 0xF900..=0xFAFF
| 0xFE30..=0xFE4F
| 0xFF00..=0xFF60
| 0xFFE0..=0xFFE6
| 0x1F000..=0x1FAFF
| 0x20000..=0x3FFFD => 2,
_ => 1,
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
use std::path::PathBuf;
const NOW: u64 = 100_000_000;
const PWSH: &str = "\"C:\\\\Program Files\\\\PowerShell\\\\7\\\\pwsh.exe\" -NoProfile -Command \
'git status --short; echo ''done'''";
const HOUR: u64 = 60 * 60 * 1000;
struct Home(PathBuf);
impl Drop for Home {
fn drop(&mut self) {
std::fs::remove_dir_all(&self.0).unwrap();
}
}
fn home() -> Home {
let path = std::env::temp_dir().join(format!("axiopera-top-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&path).unwrap();
Home(path)
}
fn task(id: &str, parent: &str, status: &str, at: u64, more: Value) -> Task {
let mut fields = json!({
"id": id, "parent": parent, "agent": "codex", "tier": "work", "cwd": ".",
"status": status, "turns": 1, "delivered": 0, "changed_files": [],
"stalled": false, "detached": false, "created_ms": at, "updated_ms": at,
});
fields
.as_object_mut()
.unwrap()
.extend(more.as_object().unwrap().clone());
serde_json::from_value(fields).unwrap()
}
fn event(seq: u64, ago_ms: u64, task: &str, kind: &str, data: Value) -> Event {
Event {
seq,
ts: NOW - ago_ms,
task: task.into(),
kind: kind.into(),
data: data.as_object().unwrap().clone(),
}
}
fn line_of<'a>(frame: &'a [String], start: &str) -> &'a str {
frame
.iter()
.find(|l| l.trim_start().starts_with(start))
.unwrap_or_else(|| panic!("no line starting {start:?} in {frame:#?}"))
}
fn cells<'a>(frame: &'a [String], name: &str) -> Vec<&'a str> {
line_of(frame, &format!("{name} "))
.split(" ")
.map(str::trim)
.filter(|c| !c.is_empty())
.collect()
}
fn indent(line: &str) -> usize {
line.len() - line.trim_start().len()
}
#[test]
fn each_task_is_one_line_of_its_name_id_state_and_words() {
let h = home();
let store = Store::new(&h.0);
for (t, prompt) in [
(
task(
"t1",
"claude:s1234567890",
"running",
NOW - 600_000,
json!({"name": "审查"}),
),
Some("\nReview the parser.\n\nReport findings."),
),
(
task("t2", "task:t1", "idle", NOW - 500_000, json!({})),
Some("Run the tests."),
),
(
task(
"t3",
"task:t1/claude:native",
"waiting",
NOW - 400_000,
json!({"questions": [
{"id": "q1", "text": "Which\nport?", "answer": null, "asked_ms": NOW - 9_000}
]}),
),
None,
),
(task("t4", "user", "idle", NOW - 2 * HOUR, json!({})), None),
(task("t5", "user", "idle", NOW - 3 * HOUR, json!({})), None),
(
task("t6", "task:t5", "queued", NOW - 1_000, json!({})),
Some("Check the adapter.\nThen report."),
),
(task("t7", "user", "failed", NOW - 1_000, json!({})), None),
] {
if let Some(text) = prompt {
store.save_prompt(&t.id, text).unwrap();
}
store.save(&t).unwrap();
}
store
.save_turn("t2", 1, "\n\nAll tests pass.\nDetails.\n")
.unwrap();
for e in [
event(1, 120_000, "t1", "turn_started", json!({"turn": 2})),
event(
2,
61_000,
"t1",
"said",
json!({"text": "Running\n\nthe tests."}),
),
event(
3,
60_000,
"t1",
"tool",
json!({"name": "Bash", "detail": "cargo test"}),
),
event(
4,
30_000,
"t1",
"approval_request",
json!({"id": "r1", "summary": "push"}),
),
event(
5,
5_000,
"t1",
"tool",
json!({"name": "Read", "detail": "src/x.rs"}),
),
event(
6,
2_000,
"t7",
"failed",
json!({"error": "429 rate limited"}),
),
] {
store.append(&e).unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let frame = view.frame(NOW, None, None);
let text = frame.join("\n");
assert!(
frame[0].starts_with(
"axiopera top 1 running, 1 waiting, 1 queued, 1 approval(s) 1 older hidden (--all)"
),
"{text}"
);
assert_eq!(frame[1..3], ["", "user: terminals and unrecognized agents"]);
assert!(text.contains("\nclaude session s1234567\n"), "{text}");
assert!(
text.contains("\nuser: terminals and unrecognized agents\n"),
"{text}"
);
assert!(!text.contains("t4 "), "{text}");
assert_eq!(
cells(&frame, "审查"),
["审查", "t1", "approval", "Running the tests."],
"{text}"
);
for child in ["t2", "t3"] {
assert_eq!(
indent(line_of(&frame, &format!("{child} "))),
indent(line_of(&frame, "审查 ")) + 2,
"{text}"
);
}
assert_eq!(cells(&frame, "t2"), ["t2", "idle", "All tests pass."]);
assert_eq!(cells(&frame, "t3"), ["t3", "waiting", "Which port?"]);
assert_eq!(cells(&frame, "t5"), ["t5", "idle"]);
assert!(indent(line_of(&frame, "t6 ")) > indent(line_of(&frame, "t5 ")));
assert_eq!(cells(&frame, "t6"), ["t6", "queued"]);
assert_eq!(cells(&frame, "t7"), ["t7", "failed"]);
let more = serde_json::to_string(&event(
7,
1_000,
"t1",
"said",
json!({"text": "Editing ↵ ↵ a.rs…(+12 chars)"}),
))
.unwrap();
let (head, rest) = more.split_at(20);
let mut f = std::fs::OpenOptions::new()
.append(true)
.open(store.events_path("t1"))
.unwrap();
f.write_all(head.as_bytes()).unwrap();
view.refresh();
assert_eq!(
cells(&view.frame(NOW, None, None), "审查")[3],
"Running the tests."
);
f.write_all(format!("{rest}\n").as_bytes()).unwrap();
drop(f);
store
.append(&event(
8,
500,
"t1",
"approved",
json!({"id": "r1", "by": "user"}),
))
.unwrap();
view.refresh();
assert_eq!(
cells(&view.frame(NOW, None, None), "审查")[2..],
["running", "Editing a.rs…"]
);
for t in store.load_all() {
assert_eq!(t.delivered, 0);
}
assert!(!h.0.join("ledger.json").exists() && !h.0.join("daemon").exists());
let mut everything = View::new(&h.0, true);
everything.refresh();
assert!(
everything
.frame(NOW, None, None)
.iter()
.any(|l| l.contains("t4 "))
);
}
#[test]
fn one_task_in_detail() {
let h = home();
let store = Store::new(&h.0);
let mut t1 = task(
"t1",
"claude:s1",
"idle",
NOW - 600_000,
json!({"name": "review", "cwd": "/w"}),
);
t1.turns = 2;
store
.save_prompt("t1", "Review the parser.\nReport findings.")
.unwrap();
store.save(&t1).unwrap();
store
.save_turn(
"t1",
2,
"No bugs.\n\n- checked the reader\n- and the writer\n",
)
.unwrap();
store
.save(&task(
"t2",
"task:t1",
"running",
NOW - 60_000,
json!({"name": "tests"}),
))
.unwrap();
store
.save(&task("t3", "user", "idle", NOW, json!({"name": "tests"})))
.unwrap();
store.save_turn("t1", 1, "Read it.\nAll of it.").unwrap();
for e in [
event(
0,
55_000,
"t1",
"said",
json!({"text": "Read it. ↵ All…(+6 chars)"}),
),
event(
0,
55_000,
"t1",
"turn_ended",
json!({"turn": 1, "ok": true}),
),
event(1, 50_000, "t1", "turn_started", json!({"turn": 2})),
event(
2,
40_000,
"t1",
"said",
json!({"text": "Checking the reader."}),
),
event(
3,
30_000,
"t1",
"tool",
json!({"name": "Read", "detail": "/w/src/reader.rs"}),
),
event(
3,
30_000,
"t1",
"tool",
json!({"name": "shell", "detail": PWSH}),
),
event(
4,
20_000,
"t1",
"said",
json!({"text": "No bugs. ↵ - checked the reader…(+19 chars)"}),
),
event(
5,
20_000,
"t1",
"turn_ended",
json!({"turn": 2, "ok": true}),
),
event(6, 10_000, "t2", "said", json!({"text": "Running them."})),
] {
store.append(&e).unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
assert_eq!(view.find("review").unwrap(), "t1");
assert_eq!(view.find("t3").unwrap(), "t3");
assert_eq!(view.find("nope").unwrap_err().to_string(), "no task nope");
assert_eq!(
view.find("tests").unwrap_err().to_string(),
"2 tasks are named tests; give one of their IDs: t2, t3"
);
let frame = view.task_frame("t1", NOW, None, false);
let text = frame.join("\n");
assert_eq!(
frame,
[
"review t1 codex/work idle 2 turn(s), last change 10m00s ago",
"",
"› Review the parser.",
" Report findings.",
"",
"• Read it.",
" All of it.",
"",
"── turn 2, 50s ago",
"",
"• Checking the reader.",
" └ Read src/reader.rs",
" Run git status --short; echo 'done'",
"",
"• No bugs.",
"",
" • checked the reader",
" • and the writer",
],
"{text}"
);
assert!(view.task_frame("t1", NOW, None, true)[0].ends_with(" ago Esc back"));
let fitted: Vec<String> = view
.task_frame("t1", NOW, Some((60, 7)), false)
.iter()
.map(|l| strip_sgr(l))
.collect();
assert_eq!(fitted[2..], frame[13..], "{fitted:#?}");
assert_eq!(fitted[1], "… Run git status --short; echo 'done'");
let roomy = view.task_frame("t1", NOW, Some((60, 20)), false);
assert_eq!(roomy.len(), frame.len(), "{roomy:#?}");
let short: Vec<String> = view
.task_frame("t1", NOW, Some((60, 3)), false)
.iter()
.map(|l| strip_sgr(l))
.collect();
let path = store.turn_path("t1", 2).display().to_string();
assert_eq!(short[1], " 4 line(s); all in:", "{short:#?}");
assert!(path.starts_with(short[2].trim_start()), "{short:#?}");
assert!(short.iter().all(|l| columns(l) <= 59), "{short:#?}");
std::fs::remove_dir_all(h.0.join("tasks").join("t1")).unwrap();
view.refresh();
assert_eq!(
view.task_frame("t1", NOW, None, false),
["t1 is gone: it was removed, by gc or by hand"]
);
assert_eq!(
view.task_frame("t1", NOW, None, true),
["t1 is gone: it was removed, by gc or by hand Esc back"]
);
}
#[test]
fn turns_follow_the_daemon_account() {
let h = home();
let store = Store::new(&h.0);
let save = |turns: u32| {
store
.save(&task(
"t1",
"codex:s",
"running",
NOW,
json!({"turns": turns}),
))
.unwrap()
};
save(0);
let mut view = View::new(&h.0, false);
let mut state = |e: Event| {
store.append(&e).unwrap();
view.refresh();
view.load_list(NOW);
let t = &view.tasks["t1"];
let tail = view.tail("t1");
let lines: Vec<String> = details(t, tail)
.iter()
.map(|d| format!("{} {}", d.label, d.text))
.collect();
(
meta(t, tail, NOW),
lines,
words(t, tail).unwrap_or_default(),
)
};
assert_eq!(
state(event(1, 9_000, "t1", "turn_started", json!({"turn": 1}))),
(
"turn 1, 9s, 0 tool call(s)".to_string(),
vec![],
String::new()
)
);
let waits = state(event(
2,
8_000,
"t1",
"approval_request",
json!({"id": "r9", "summary": "push"}),
));
assert_eq!(waits.1, ["needs approval r9: push"]);
state(event(3, 7_000, "t1", "denied", json!({"id": "r9"})));
assert_eq!(
state(event(4, 7_000, "t1", "said", json!({"text": "Done."}))),
(
"turn 1, 9s, 0 tool call(s)".to_string(),
vec![],
"Done.".to_string()
)
);
save(1);
assert_eq!(
state(event(
5,
6_000,
"t1",
"turn_ended",
json!({"turn": 1, "ok": true})
))
.0,
"turn 1 ended 6s ago; background work still runs"
);
state(event(
6,
3_000,
"t1",
"said",
json!({"text": "The build finished."}),
));
assert_eq!(
state(event(
7,
2_000,
"t1",
"tool",
json!({"name": "monitor", "detail": ""})
)),
(
"turn 2, 3s, 1 tool call(s)".to_string(),
vec![],
"The build finished.".to_string()
)
);
let next = state(event(
8,
1_500,
"t1",
"tool",
json!({"name": "Read", "detail": "x"}),
));
assert_eq!(next.2, "The build finished.");
assert!(
state(event(
9,
1_000,
"t1",
"turn_ended",
json!({"turn": 2, "ok": false, "error": "boom"})
))
.1
.is_empty()
);
state(event(10, 900, "t1", "turn_started", json!({"turn": 3})));
let (_, lines, text) = state(event(
11,
800,
"t1",
"tool",
json!({"name": "Read", "detail": "y"}),
));
assert_eq!((lines.len(), &text[..]), (0, "The build finished."));
store
.save(&task("t1", "codex:s", "failed", NOW, json!({"turns": 3})))
.unwrap();
store
.append(&event(
12,
700,
"t1",
"turn_ended",
json!({"turn": 3, "ok": false, "error": "boom"}),
))
.unwrap();
view.refresh();
view.load_list(NOW);
let t = &view.tasks["t1"];
assert_eq!(details(t, view.tail("t1"))[0].text, "boom");
let turns: Vec<_> = view
.tail("t1")
.log
.iter()
.filter_map(|l| match &l.what {
What::Said { text, turn } => Some((text.as_str(), *turn)),
_ => None,
})
.collect();
assert_eq!(
turns,
[("Done.", Some(1)), ("The build finished.", Some(2))]
);
}
#[test]
fn a_fitted_frame_stays_inside_the_window() {
let h = home();
let store = Store::new(&h.0);
for i in 0..30 {
store
.save(&task(
&format!("t{i:02}"),
"codex:s",
"running",
NOW,
json!({}),
))
.unwrap();
}
let detail = "printf '\x1b[2J\x1b[H'\r\nrm -rf build";
store
.append(&event(0, 2_000, "t00", "turn_started", json!({"turn": 1})))
.unwrap();
store
.append(&event(1, 1_000, "t00", "said", json!({"text": detail})))
.unwrap();
for i in 2..10 {
store
.append(&event(
i,
1_000,
"t00",
"tool",
json!({"name": "Bash", "detail": "cargo build"}),
))
.unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let frame = view.frame(NOW, Some((40, 12)), None);
assert_eq!(frame.len(), 12, "{frame:#?}");
let plain: Vec<String> = frame.iter().map(|l| strip_sgr(l)).collect();
assert_eq!(plain[2], "codex session s");
assert!(plain[3].starts_with(" t22 "), "{plain:#?}");
assert_eq!(plain[11], " …and 22 more task(s)", "{plain:#?}");
for (line, plain) in frame.iter().zip(&plain) {
assert!(!plain.contains('\x1b'), "{line:?}");
assert!(columns(plain) <= 39, "{plain:?}");
}
let all = view.frame(NOW, Some((100, 40)), None);
let t00 = line_of(&all, "t00 ");
assert!(
t00.ends_with("\x1b[0m printf ' [2J [H' rm -rf build"),
"{t00:?}"
);
store
.append(&event(10, 0, "t00", "said", json!({"text": "Building."})))
.unwrap();
view.refresh();
assert_eq!(view.frame(NOW, Some((40, 12)), None), frame);
}
fn strip_sgr(line: &str) -> String {
let mut out = String::new();
let mut rest = line;
while let Some(start) = rest.find("\x1b[") {
out.push_str(&rest[..start]);
let after = &rest[start + 2..];
match after.find(|c: char| !c.is_ascii_digit() && c != ';') {
Some(end) if after[end..].starts_with('m') => rest = &after[end + 1..],
_ => {
out.push_str(&rest[start..]);
return out;
}
}
}
out.push_str(rest);
out
}
#[test]
fn wide_characters_take_two_columns() {
assert_eq!(fit("审查任务", 5), ("审查…".to_string(), true));
assert_eq!(fit("审查", 4), ("审查".to_string(), false));
assert_eq!(pad("审", 4), "审 ");
assert_eq!(fit("abc", 0), (String::new(), true));
assert_eq!(columns("🚀⏳✅"), 6);
}
#[test]
fn ages_past_two_days_count_days() {
assert_eq!(age(47 * HOUR + 60_000), "47h01m");
assert_eq!(age(435 * HOUR + 54 * 60_000), "18d03h");
}
#[test]
fn the_daemon_can_write_while_top_holds_the_files_open() {
let h = home();
let store = Store::new(&h.0);
let t = task("t1", "user", "running", NOW, json!({}));
store.save_prompt("t1", "x").unwrap();
store.save(&t).unwrap();
store
.append(&event(1, 0, "t1", "spawned", json!({})))
.unwrap();
let _task = File::open(h.0.join("tasks").join("t1").join("task.json")).unwrap();
let _events = File::open(store.events_path("t1")).unwrap();
let _prompt = File::open(store.prompt_path("t1")).unwrap();
store.save(&t).unwrap();
store
.append(&event(2, 0, "t1", "turn_started", json!({"turn": 1})))
.unwrap();
}
#[test]
fn a_task_that_cannot_be_read_for_a_moment_keeps_its_line() {
let h = home();
let store = Store::new(&h.0);
store
.save(&task("t1", "user", "running", NOW, json!({})))
.unwrap();
store
.save(&task("t2", "user", "idle", NOW, json!({})))
.unwrap();
let mut view = View::new(&h.0, false);
view.refresh();
let before = view.frame(NOW, None, None);
std::fs::write(h.0.join("tasks").join("t1").join("task.json"), "{").unwrap();
view.refresh();
assert_eq!(view.frame(NOW, None, None), before);
store.remove("t1").unwrap();
view.refresh();
let after = view.frame(NOW, None, None).join("\n");
assert!(!after.contains("t1 ") && after.contains("t2 "), "{after}");
}
#[test]
fn a_short_window_keeps_what_waits_for_someone_and_what_works() {
let h = home();
let store = Store::new(&h.0);
for i in 0..8 {
let id = format!("t{i}");
store
.save(&task(&id, "user", "idle", NOW - 50_000 + i, json!({})))
.unwrap();
store.save_turn(&id, 1, "Done.").unwrap();
}
store
.save(&task("tp", "user", "idle", NOW - 40_000, json!({})))
.unwrap();
store
.save(&task("tr", "task:tp", "running", NOW - 30_000, json!({})))
.unwrap();
store
.save(&task(
"tw",
"codex:s",
"waiting",
NOW - 20_000,
json!({"questions": [
{"id": "q1", "text": "Which port?", "answer": null, "asked_ms": NOW - 9_000}
]}),
))
.unwrap();
for e in [
event(1, 9_000, "tr", "turn_started", json!({"turn": 1})),
event(2, 8_000, "tr", "said", json!({"text": "Pushing."})),
event(
3,
7_000,
"tr",
"approval_request",
json!({"id": "r1", "summary": "push"}),
),
] {
store.append(&e).unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let frame = view.frame(NOW, Some((100, 10)), None);
let plain: Vec<String> = frame.iter().map(|l| strip_sgr(l)).collect();
let text = plain.join("\n");
assert_eq!(plain.len(), 10, "{text}");
assert_eq!(cells(&plain, "tw"), ["tw", "waiting", "Which port?"]);
assert_eq!(cells(&plain, "tr"), ["tr", "approval", "Pushing."]);
assert!(text.contains("\n tp "), "{text}");
assert!(text.contains("\ncodex session s\n"), "{text}");
assert!(
text.contains("\n t6 ") && !text.contains("\n t5 "),
"{text}"
);
assert_eq!(plain[9], " …and 6 more task(s)", "{text}");
let at = |s: &str| text.find(s).unwrap();
assert!(at("\n tp ") < at("\n tr ") && at("\n tr ") < at("\n t7 "));
assert!(at("codex session s") < at("\n tr "), "{text}");
assert!(line_of(&frame, "tw ").contains("\x1b[33mwaiting"));
assert!(line_of(&frame, "tr ").contains("\x1b[33mapproval"));
assert!(line_of(&frame, "t7 ").contains("\x1b[2midle"));
store
.append(&event(4, 0, "t0", "said", json!({"text": "Late words."})))
.unwrap();
view.refresh();
assert_eq!(view.frame(NOW, Some((100, 10)), None), frame);
store
.save(&task(
"t0",
"user",
"cancelled",
NOW - 50_000,
json!({"stalled": true}),
))
.unwrap();
view.refresh();
assert_eq!(view.frame(NOW, Some((100, 10)), None), frame);
view.load_list(NOW);
assert_eq!(state(&view.tasks["t0"], view.tail("t0")).0, "cancelled");
}
#[test]
fn messages_given_after_the_task_show_where_they_were_given() {
let h = home();
let store = Store::new(&h.0);
let mut t1 = task(
"t1",
"claude:s1",
"running",
NOW - 600_000,
json!({"name": "review"}),
);
t1.turns = 5;
store.save_prompt("t1", "Review the parser.").unwrap();
store.save(&t1).unwrap();
store
.save_turn("t1", 4, "Reader checked.\nAll fine.")
.unwrap();
let given = [
(0, "Review the parser.\n\nAlso the lexer."),
(6, "Check the writer too."),
(10, "Now the tests.\nAll of them."),
(12, "Skip the fixtures."),
(13, "And the reader."),
(16, "Try once more."),
];
for (seq, text) in given {
store.save_message("t1", seq, text).unwrap();
}
for e in [
event(
0,
95_000,
"t1",
"turn_started",
json!({"turn": 1, "chars": 36}),
),
event(1, 90_000, "t1", "said", json!({"text": "Read it."})),
event(
2,
90_000,
"t1",
"turn_ended",
json!({"turn": 1, "ok": true}),
),
event(3, 55_000, "t1", "turn_started", json!({"turn": 2})),
event(4, 50_000, "t1", "said", json!({"text": "Read it again."})),
event(
5,
50_000,
"t1",
"turn_ended",
json!({"turn": 2, "ok": true}),
),
event(6, 45_000, "t1", "steered", json!({"queued": true})),
event(7, 40_000, "t1", "turn_started", json!({"turn": 3})),
event(8, 35_000, "t1", "said", json!({"text": "Writer checked."})),
event(
9,
35_000,
"t1",
"turn_ended",
json!({"turn": 3, "ok": true}),
),
event(13, 34_000, "t1", "steered", json!({"queued": true})),
event(14, 33_000, "t1", "said", json!({"text": "Reader checked."})),
event(
15,
33_000,
"t1",
"turn_ended",
json!({"turn": 4, "ok": true}),
),
event(16, 32_000, "t1", "steered", json!({"queued": true})),
event(
17,
31_000,
"t1",
"turn_ended",
json!({"turn": 5, "ok": false, "error": "boom"}),
),
event(
10,
30_000,
"t1",
"turn_started",
json!({"turn": 6, "chars": 28}),
),
event(
11,
20_000,
"t1",
"tool",
json!({"name": "Read", "detail": "src/w.rs"}),
),
event(12, 10_000, "t1", "steered", json!({"queued": false})),
] {
store.append(&e).unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let frame = view.task_frame("t1", NOW, None, false);
assert_eq!(
frame[2..],
[
"› Review the parser.",
"",
" Also the lexer.",
"",
"• Read it.",
"",
"── turn 2, 55s ago",
"",
"• Read it again.",
"",
"── turn 3, 40s ago",
"",
"› Check the writer too.",
"",
"• Writer checked.",
"",
"› And the reader.",
"",
"• Reader checked.",
" All fine.",
"",
"› Try once more.",
"",
"── turn 6, 30s ago",
"",
"› Now the tests.",
" All of them.",
" └ Read src/w.rs",
"",
"› Skip the fixtures.",
],
"{frame:#?}"
);
}
#[test]
fn a_turn_that_says_nothing_has_no_result_of_the_one_before() {
let h = home();
let store = Store::new(&h.0);
let mut t1 = task("t1", "claude:s1", "idle", NOW - 600_000, json!({}));
t1.turns = 3;
store.save(&t1).unwrap();
store.save_turn("t1", 1, "Done.\nFully.").unwrap();
store.save_turn("t1", 3, "").unwrap();
for e in [
event(0, 60_000, "t1", "turn_started", json!({"turn": 1})),
event(1, 50_000, "t1", "said", json!({"text": "Done."})),
event(
2,
50_000,
"t1",
"turn_ended",
json!({"turn": 1, "ok": true}),
),
event(
3,
50_000,
"t1",
"turn_ended",
json!({"turn": 2, "ok": false}),
),
event(4, 50_000, "t1", "turn_started", json!({"turn": 3})),
event(
5,
40_000,
"t1",
"turn_ended",
json!({"turn": 3, "ok": true}),
),
] {
store.append(&e).unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let frame = view.task_frame("t1", NOW, None, false);
assert_eq!(
frame[2..],
["• Done.", " Fully.", "", "── turn 3, 50s ago"],
"{frame:#?}"
);
}
#[test]
fn a_session_is_shown_with_the_projects_its_tasks_work_in() {
let h = home();
let store = Store::new(&h.0);
let dir = |path: &str| {
let dir = h.0.join(path);
std::fs::create_dir_all(&dir).unwrap();
dir
};
let worktree_of = |dir: &Path, gitdir: &Path| {
let text = format!("gitdir: {}\n", gitdir.display());
std::fs::write(dir.join(".git"), text).unwrap();
};
let src = dir("Axiopera/src");
let worktree = dir("wt/x");
worktree_of(&worktree, &dir("Axiopera/.git/worktrees/x"));
let third = dir("Third");
dir("Third/.git");
let other = dir("Other");
dir("Other/.git");
let bare = dir("wt/y");
worktree_of(&bare, &dir("Bare.git/worktrees/y"));
for (id, caller, cwd) in [
("a1", "codex:a", &src),
("a2", "codex:a", &worktree),
("a3", "task:a1", &third),
("b1", "codex:b", &other),
("b2", "codex:b", &bare),
] {
let more = json!({"cwd": cwd});
store.save(&task(id, caller, "idle", NOW, more)).unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let text = view.frame(NOW, None, None).join("\n");
assert!(
text.contains("\nAxiopera, Third · codex session a\n"),
"{text}"
);
assert!(text.contains("\nOther, Bare · codex session b\n"), "{text}");
}
#[test]
fn sessions_follow_latest_spawns_and_can_be_told_apart() {
let h = home();
let store = Store::new(&h.0);
let a = "codex:019a2b3c-1111";
let b = "codex:019a2b3c-2222";
store
.save(&task("a1", a, "idle", NOW - 3 * HOUR, json!({})))
.unwrap();
store
.save(&task("b1", b, "idle", NOW - 2_000, json!({})))
.unwrap();
store
.save(&task("a2", a, "idle", NOW - 1_000, json!({})))
.unwrap();
let mut view = View::new(&h.0, false);
view.refresh();
let text = view.frame(NOW, None, None).join("\n");
assert!(!text.contains("a1 "), "{text}");
let at = |s: &str| text.find(s).unwrap_or_else(|| panic!("{s} in {text}"));
assert!(
at("\ncodex session 019a2b3c-1111\n") < at("\ncodex session 019a2b3c-2222\n"),
"{text}"
);
let frame: Vec<String> = view
.frame(NOW, Some((100, 5)), None)
.iter()
.map(|l| strip_sgr(l))
.collect();
assert_eq!(
frame[2..],
[
"codex session 019a2b3c-1111",
line_of(&frame, "a2 "),
" …and 1 more task(s)"
],
"{frame:#?}"
);
let before = view.frame(NOW, None, None);
store.remove("a1").unwrap();
store
.save(&task("b2", "task:b1", "idle", NOW, json!({})))
.unwrap();
store
.save(&task(
"b3",
"task:b2",
"idle",
NOW,
json!({"name": "a name longer than the column"}),
))
.unwrap();
view.refresh();
let wide = view.frame(NOW, None, None);
let b3 = cells(&wide, "a name");
assert_eq!(b3[0], "a name longer than …", "{wide:#?}");
for (height, more) in [(4, Some(" …and 3 more task(s)")), (3, None)] {
let short = view.frame(NOW, Some((100, height)), Some("b3"));
assert!(
short[2].starts_with("\x1b[7m a name longer than …"),
"{short:#?}"
);
assert_eq!(short.get(3).map(|l| strip_sgr(l)).as_deref(), more);
}
store.remove("b3").unwrap();
store.remove("b2").unwrap();
view.refresh();
let after = view.frame(NOW, None, None);
assert_eq!(after.len(), before.len());
assert_eq!(line_of(&after, "a2 "), line_of(&wide, "a2 "));
assert_ne!(line_of(&after, "a2 "), line_of(&before, "a2 "));
assert!(after[2].ends_with("019a2b3c-2222"), "{after:#?}");
}
#[test]
fn recent_spawns_order_sessions_and_siblings_without_detaching_children() {
let h = home();
let store = Store::new(&h.0);
for (id, parent, at) in [
("a-old", "codex:a", NOW - 3 * HOUR),
("a-new", "codex:a", NOW - 100),
("b", "codex:b", NOW - 50),
("child-old", "task:a-old", NOW - 20),
("child-new", "task:a-old", NOW - 10),
("grandchild", "task:child-old", NOW),
] {
store
.save(&task(id, parent, "idle", at, json!({})))
.unwrap();
}
let expected = [
"a-new",
"a-old",
"child-new",
"child-old",
"grandchild",
"b",
];
for all in [false, true] {
let mut view = View::new(&h.0, all);
view.refresh();
assert_eq!(view.order(NOW), expected);
store
.append(&event(1, 0, "b", "said", json!({"text": "Working"})))
.unwrap();
let mut b = view.tasks["b"].clone();
b.updated_ms = NOW + 1;
b.status = Status::Running;
store.save(&b).unwrap();
view.refresh();
assert_eq!(view.order(NOW), expected);
}
}
#[test]
fn list_follows_new_tasks_until_browsing_and_reveals_session_headers() {
let h = home();
let store = Store::new(&h.0);
for i in 0..8 {
store
.save(&task(
&format!("t{i}"),
"codex:a",
"idle",
NOW - 100 - i,
json!({}),
))
.unwrap();
}
let mut view = View::new(&h.0, true);
view.refresh();
let mut ui = Ui {
keys: true,
..Ui::default()
};
let draw = |ui: &mut Ui, view: &mut View| {
ui.draw(view, NOW, (80, 6))
.iter()
.map(|s| strip_sgr(s))
.collect::<Vec<_>>()
};
assert!(draw(&mut ui, &mut view)[2].contains("codex session a"));
store
.save(&task("new", "codex:b", "idle", NOW, json!({})))
.unwrap();
view.refresh();
let frame = draw(&mut ui, &mut view);
assert_eq!(ui.chosen.as_deref(), Some("new"));
assert!(frame[2].contains("codex session b"));
ui.press(Key::Down, &view, NOW);
draw(&mut ui, &mut view);
ui.press(Key::Down, &view, NOW);
draw(&mut ui, &mut view);
assert_eq!(ui.chosen.as_deref(), Some("t1"));
store
.save(&task("newer", "codex:b", "idle", NOW + 1, json!({})))
.unwrap();
view.refresh();
draw(&mut ui, &mut view);
assert_eq!(ui.chosen.as_deref(), Some("t1"));
ui.press(Key::Up, &view, NOW);
let frame = draw(&mut ui, &mut view);
assert!(frame[2].contains("codex session a"), "{frame:?}");
ui.press(Key::Home, &view, NOW);
draw(&mut ui, &mut view);
assert!(!ui.list_paused);
store
.save(&task("latest", "codex:c", "idle", NOW + 2, json!({})))
.unwrap();
view.refresh();
let frame = draw(&mut ui, &mut view);
assert_eq!(ui.chosen.as_deref(), Some("latest"));
assert!(frame[2].contains("codex session c"));
}
#[test]
fn new_spawns_keep_the_selected_task_on_its_screen_row() {
let h = home();
let store = Store::new(&h.0);
for i in 0..12 {
store
.save(&task(
&format!("t{i}"),
"user",
"idle",
NOW - 100 + i,
json!({}),
))
.unwrap();
}
store
.save(&task("old", "codex:old", "idle", NOW - 3 * HOUR, json!({})))
.unwrap();
let mut view = View::new(&h.0, true);
view.refresh();
let mut ui = Ui {
keys: true,
..Ui::default()
};
let selected_row = |ui: &mut Ui, view: &mut View| {
ui.draw(view, NOW, (80, 9))
.iter()
.position(|line| line.contains("\x1b[7m"))
.unwrap()
};
selected_row(&mut ui, &mut view);
for _ in 0..3 {
ui.press(Key::Down, &view, NOW);
selected_row(&mut ui, &mut view);
}
assert_eq!(ui.chosen.as_deref(), Some("t8"));
let before = selected_row(&mut ui, &mut view);
for (id, parent, at) in [("new", "user", NOW), ("revived", "codex:old", NOW + 1)] {
store
.save(&task(id, parent, "idle", at, json!({})))
.unwrap();
view.refresh();
assert_eq!(selected_row(&mut ui, &mut view), before);
assert_eq!(ui.chosen.as_deref(), Some("t8"));
}
assert_eq!(view.order(NOW)[0], "revived");
ui.press(Key::Home, &view, NOW);
selected_row(&mut ui, &mut view);
assert_eq!(ui.chosen.as_deref(), Some("revived"));
assert_eq!(ui.list_top, 0);
store.remove("revived").unwrap();
view.refresh();
selected_row(&mut ui, &mut view);
assert_eq!(ui.chosen.as_deref(), Some("old"));
}
#[test]
fn a_result_being_written_is_read_again() {
let h = home();
let store = Store::new(&h.0);
store
.save(&task("t1", "user", "idle", NOW, json!({})))
.unwrap();
store.save_turn("t1", 1, "").unwrap();
let mut view = View::new(&h.0, false);
view.refresh();
assert_eq!(cells(&view.frame(NOW, None, None), "t1"), ["t1", "idle"]);
store.save_turn("t1", 1, "All tests pass.").unwrap();
view.refresh();
assert_eq!(
cells(&view.frame(NOW, None, None), "t1"),
["t1", "idle", "All tests pass."]
);
let said = |seq, turn| {
store
.append(&event(seq, 1_000, "t1", "said", json!({"text": "Part"})))
.unwrap();
let ended = json!({"turn": turn, "ok": true});
store
.append(&event(seq + 1, 1_000, "t1", "turn_ended", ended))
.unwrap();
};
store.save_turn("t1", 1, "Part").unwrap();
view.refresh();
view.refresh();
said(1, 1);
said(3, 2);
store
.save(&task("t1", "user", "idle", NOW, json!({"turns": 2})))
.unwrap();
store.save_turn("t1", 1, "Part one.\nPart two.").unwrap();
store.save_turn("t1", 2, "Done.").unwrap();
view.refresh();
let text = view.task_frame("t1", NOW, None, false).join("\n");
assert!(
text.contains("\n• Part one.\n Part two.\n\n• Done."),
"{text}"
);
}
#[test]
fn a_message_too_long_for_the_window_says_where_it_all_is() {
let h = home();
let store = Store::new(&h.0);
let prompt: Vec<String> = (1..=30).map(|i| format!("line {i}")).collect();
let mut long = "word ".repeat(20);
long.push_str("end");
store
.save_prompt("t1", &format!("{long}\n{}", prompt.join("\n")))
.unwrap();
store
.save(&task("t1", "user", "idle", NOW, json!({})))
.unwrap();
let mut view = View::new(&h.0, false);
view.refresh();
let plain = view.task_frame("t1", NOW, None, false).join("\n");
assert!(
plain.contains(&format!("\n› {long}\n line 1\n")) && plain.ends_with("\n line 30"),
"{plain}"
);
let frame: Vec<String> = view
.task_frame("t1", NOW, Some((40, 8)), false)
.iter()
.map(|l| strip_sgr(l))
.collect();
let text = frame.join("\n");
assert_eq!(frame.len(), 8, "{text}");
assert_eq!(frame[1], format!("› {}word", "word ".repeat(6)));
assert!(frame[2].starts_with(" word "), "{text}");
let path = store.prompt_path("t1").display().to_string();
let pieces = path.chars().count().div_ceil(37);
let note = frame.len() - 1 - pieces;
assert_eq!(
frame[note],
format!(" …{} more line(s); all in:", 33 - (note - 1)),
"{text}"
);
let shown: String = frame[note + 1..]
.iter()
.map(|l| l.strip_prefix(" ").unwrap())
.collect();
assert_eq!(shown, path, "{text}");
assert!(frame.iter().all(|l| columns(l) <= 39), "{text}");
}
#[test]
fn the_latest_messages_fill_the_window() {
let h = home();
let store = Store::new(&h.0);
store.save_prompt("t1", "Fix the parser.").unwrap();
store
.save(&task("t1", "user", "running", NOW, json!({"turns": 0})))
.unwrap();
for e in [
event(1, 60_000, "t1", "turn_started", json!({"turn": 1})),
event(
2,
50_000,
"t1",
"said",
json!({"text": "Reading. ↵ Then **fixing**."}),
),
event(3, 40_000, "t1", "tool", json!({"name": "Read"})),
event(
4,
30_000,
"t1",
"said",
json!({"text": "Fixed the reader."}),
),
event(
5,
10_000,
"t1",
"said",
json!({"text": "**Done**: all tests pass."}),
),
event(
6,
5_000,
"t1",
"approval_request",
json!({"id": "r1", "summary": "push"}),
),
] {
store.append(&e).unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let frame = view.task_frame("t1", NOW, Some((60, 11)), false);
let plain: Vec<String> = frame.iter().map(|l| strip_sgr(l)).collect();
assert_eq!(
plain[1..],
[
" needs approval r1: push",
"› Fix the parser.",
"",
"• Reading.",
" Then fixing.",
" └ Read",
"",
"• Fixed the reader.",
"",
"• Done: all tests pass.",
],
"{plain:#?}"
);
assert!(
frame[1].starts_with("\x1b[33m needs \x1b[0m"),
"{frame:#?}"
);
assert_eq!(frame[5], " Then \x1b[1mfixing\x1b[0m.");
assert_eq!(
cells(&view.frame(NOW, None, None), "t1"),
["t1", "approval", "Done: all tests pass."]
);
let short: Vec<String> = view
.task_frame("t1", NOW, Some((60, 8)), false)
.iter()
.map(|l| strip_sgr(l))
.collect();
assert_eq!(
short[2..],
[
"… Then fixing.",
" └ Read",
"",
"• Fixed the reader.",
"",
"• Done: all tests pass.",
],
"{short:#?}"
);
store.save_turn("t1", 1, "").unwrap();
store
.save(&task("t1", "user", "failed", NOW, json!({"turns": 1})))
.unwrap();
store
.append(&event(
7,
1_000,
"t1",
"turn_ended",
json!({"turn": 1, "ok": false, "error": "max turns"}),
))
.unwrap();
view.refresh();
let ended = view.task_frame("t1", NOW, None, false).join("\n");
assert!(ended.ends_with("\n• Done: all tests pass."), "{ended}");
assert!(ended.contains("\n error max turns\n"), "{ended}");
}
#[test]
fn a_result_without_its_message_still_shows() {
let h = home();
let store = Store::new(&h.0);
store
.save(&task("t1", "user", "idle", NOW - 60_000, json!({})))
.unwrap();
store.save_turn("t1", 1, "All done.\nNo bugs.").unwrap();
let mut view = View::new(&h.0, false);
view.refresh();
assert_eq!(
view.task_frame("t1", NOW, None, false)[1..],
[
"",
"› not recorded: spawned before axiopera kept it",
"",
"• All done.",
" No bugs.",
]
);
}
#[test]
fn a_task_view_counts_what_waits_past_the_window_and_skips_what_is_not_there() {
let h = home();
let store = Store::new(&h.0);
let questions: Vec<Value> = (0..25)
.map(|i| json!({"id": format!("q{i}"), "text": "Which?", "answer": null, "asked_ms": NOW}))
.collect();
store
.save(&task(
"t1",
"user",
"waiting",
NOW,
json!({"questions": questions}),
))
.unwrap();
let mut view = View::new(&h.0, false);
view.refresh();
let frame: Vec<String> = view
.task_frame("t1", NOW, Some((80, 24)), false)
.iter()
.map(|l| strip_sgr(l))
.collect();
assert_eq!(frame.len(), 24, "{frame:#?}");
assert!(frame[22].contains("q21: Which?"), "{frame:#?}");
assert_eq!(frame[23], " …and 3 more");
let frame = view.task_frame("t1", NOW, None, false).join("\n");
assert!(
frame.ends_with("\n\n› not recorded: spawned before axiopera kept it"),
"{frame}"
);
}
#[test]
fn redraw_keeps_selection_atomic_and_clears_rows_when_the_view_shrinks() {
fn apply(screen: &mut [Vec<(char, bool)>], output: &str) -> usize {
let (mut row, mut col, mut reverse, mut synced) = (0, 0, false, false);
let mut written = 0;
let mut chars = output.chars();
while let Some(c) = chars.next() {
if c == '\x1b' {
assert_eq!(chars.next(), Some('['));
let mut params = String::new();
let end = loop {
let c = chars.next().unwrap();
if ('@'..='~').contains(&c) {
break c;
}
params.push(c);
};
match end {
'h' | 'l' if params == "?2026" => synced = end == 'h',
'H' => {
let mut pos = params.split(';').map(|s| s.parse::<usize>().unwrap());
row = pos.next().unwrap() - 1;
col = pos.next().unwrap() - 1;
}
'm' => {
for code in params.split(';') {
match code {
"0" | "27" => reverse = false,
"7" => reverse = true,
_ => {}
}
}
}
'K' => screen[row][col..].fill((' ', reverse)),
'J' => {
screen[row][col..].fill((' ', reverse));
for line in &mut screen[row + 1..] {
line.fill((' ', reverse));
}
}
_ => panic!("unexpected sequence {params}{end}"),
}
} else {
screen[row][col] = (c, reverse);
col += 1;
written += 1;
}
if !synced {
assert_eq!(
screen
.iter()
.filter(|line| line.iter().any(|(_, selected)| *selected))
.count(),
1,
"a partial frame became visible"
);
}
}
assert!(!synced, "output left suspended");
written
}
let frame = |chosen: usize, count: usize| {
(0..count)
.map(|i| {
let mut segs = vec![(format!("task-{i}"), "")];
if i == chosen {
segs.insert(0, (String::new(), CHOSEN));
}
paint(&segs, Some(30))
})
.collect::<Vec<_>>()
};
let mut screen = vec![vec![(' ', false); 30]; 8];
let mut previous = Vec::new();
for (chosen, count, resized, height) in [
(0, 7, true, 8),
(1, 7, false, 8),
(0, 7, false, 8),
(2, 3, false, 8),
(1, 2, true, 2),
(1, 2, true, 8),
] {
let lines = frame(chosen, count);
let written = apply(
&mut screen[..height],
&redraw(&previous, &lines, resized, height),
);
assert!(screen[chosen].iter().any(|(_, selected)| *selected));
if !resized && previous.len() == lines.len() {
assert!(written < 60, "unchanged rows were redrawn");
}
for (i, row) in screen.iter().enumerate().take(height).skip(count) {
assert!(
row.iter().all(|cell| *cell == (' ', false)),
"stale row {i}"
);
}
assert!(redraw(&lines, &lines, false, height).is_empty());
previous = lines;
}
}
#[test]
fn keys_choose_a_task_open_it_and_go_back() {
use Key::*;
let mut input = Input::default();
assert_eq!(
input.feed(b"\x1b[A\x1b[B\x1bOC\x1b[1;5D\x1b[5~\rkjq\x1b\x03\x7fx"),
[
Up, Down, Open, Back, PageUp, Open, Up, Down, Q, Back, Quit, Back
]
);
assert_eq!(
input.feed(b"\x1b[6~\x1b[H\x1b[F\x1bOH\x1bOF\x1b[1~\x1b[4~\x1b[7~\x1b[8~"),
[PageDown, Home, End, Home, End, Home, End, Home, End]
);
assert!(input.feed(b"\x1b[6").is_empty());
assert_eq!(input.feed(b"~"), [PageDown]);
assert!(input.feed(b"\x1b").is_empty() && input.waiting());
assert_eq!(input.feed(b"[B"), [Down]);
assert_eq!(input.feed(b"j\x1b[1;"), [Down]);
assert_eq!(input.feed(b"5A"), [Up]);
assert!(!input.waiting());
input.feed(b"\x1b");
assert_eq!(input.flush(), [Back]);
input.feed(b"\x1bO");
assert!(input.flush().is_empty() && !input.waiting());
for start in [&b"\x1b["[..], b"\x1b[1;", b"\x1bO"] {
assert!(input.feed(start).is_empty());
assert_eq!(input.feed(b"\x03"), [Quit]);
assert!(!input.waiting());
}
let h = home();
let store = Store::new(&h.0);
for i in 0..6 {
store
.save(&task(
&format!("t{i}"),
"user",
"idle",
NOW - 1_000 - i,
json!({}),
))
.unwrap();
}
store
.save(&task(
"tw",
"user",
"waiting",
NOW - 50_000,
json!({"name": "ask"}),
))
.unwrap();
let mut view = View::new(&h.0, false);
view.refresh();
let mut ui = Ui {
open: None,
chosen: None,
keys: true,
..Ui::default()
};
let plain = |ui: &mut Ui, view: &mut View| -> Vec<String> {
ui.draw(view, NOW, (80, 6))
.iter()
.map(|l| strip_sgr(l))
.collect()
};
let frame = ui.draw(&mut view, NOW, (80, 6));
assert_eq!(ui.chosen.as_deref(), Some("t0"));
assert!(frame[3].starts_with("\x1b[7m t0 "), "{frame:#?}");
let shown = plain(&mut ui, &mut view);
assert!(
shown[0].ends_with(" ↑↓ choose Enter open q quit"),
"{shown:#?}"
);
assert_eq!(columns(&shown[3]), 79, "{shown:#?}");
assert_eq!(shown[2], "user: terminals and unrecognized agents");
assert!(shown[4].starts_with(" t1 "));
assert!(shown[5].starts_with(" rows 1–3/8"));
ui.press(PageDown, &view, NOW);
let shown = plain(&mut ui, &mut view);
assert_eq!(ui.chosen.as_deref(), Some("t3"));
assert!(shown[2].starts_with(" t2 ") && shown[4].starts_with(" t4 "));
ui.press(End, &view, NOW);
let shown = plain(&mut ui, &mut view);
assert!(shown[2].starts_with(" t4 ") && shown[4].starts_with(" ask "));
ui.press(PageUp, &view, NOW);
let shown = plain(&mut ui, &mut view);
assert_eq!(ui.chosen.as_deref(), Some("t3"));
assert!(shown[2].starts_with(" t1 ") && shown[4].starts_with(" t3 "));
ui.press(Home, &view, NOW);
plain(&mut ui, &mut view);
for (key, chosen) in [(Down, "t1"), (Up, "t0"), (Up, "t0")] {
assert!(ui.press(key, &view, NOW));
assert_eq!(ui.chosen.as_deref(), Some(chosen));
}
for _ in 0..10 {
ui.press(Down, &view, NOW);
}
assert_eq!(ui.chosen.as_deref(), Some("tw"));
ui.press(Open, &view, NOW);
let one = plain(&mut ui, &mut view);
assert!(
one[0].starts_with("ask tw codex/work waiting") && one[0].ends_with(" Esc back")
);
ui.press(Down, &view, NOW);
assert_eq!(ui.open.as_deref(), Some("tw"));
ui.press(Back, &view, NOW);
assert_eq!(
(ui.open.as_deref(), ui.chosen.as_deref()),
(None, Some("tw"))
);
ui.press(Open, &view, NOW);
assert!(ui.press(Q, &view, NOW) && ui.open.is_none());
assert!(!ui.press(Q, &view, NOW));
ui.press(Open, &view, NOW);
assert!(!ui.press(Quit, &view, NOW));
ui.open = None;
store.remove("tw").unwrap();
view.refresh();
plain(&mut ui, &mut view);
assert_eq!(ui.chosen.as_deref(), Some("t0"));
ui.keys = false;
let frame = ui.draw(&mut view, NOW, (80, 6));
assert!(!frame.iter().any(|l| l.contains("\x1b[7m")), "{frame:#?}");
let shown = plain(&mut ui, &mut view);
assert!(!shown[0].contains("choose"), "{shown:#?}");
assert!(!shown.iter().any(|l| columns(l) == 79), "{shown:#?}");
}
#[test]
fn list_pages_cross_session_headers_and_fit_after_resize() {
let h = home();
let store = Store::new(&h.0);
for (i, id) in ["a0", "a1", "a2", "a3", "b0", "b1", "b2", "b3"]
.into_iter()
.enumerate()
{
store
.save(&task(
id,
if i < 4 { "codex:a" } else { "codex:b" },
"idle",
NOW - 100 - i as u64,
json!({}),
))
.unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let mut ui = Ui {
keys: true,
..Ui::default()
};
ui.draw(&mut view, NOW, (80, 5));
assert_eq!(ui.chosen.as_deref(), Some("a0"));
ui.press(Key::PageDown, &view, NOW);
ui.draw(&mut view, NOW, (80, 5));
assert_eq!(ui.chosen.as_deref(), Some("a2"));
ui.press(Key::PageDown, &view, NOW);
ui.draw(&mut view, NOW, (80, 5));
assert_eq!(ui.chosen.as_deref(), Some("b0"));
ui.press(Key::Up, &view, NOW);
assert_eq!(ui.chosen.as_deref(), Some("a3"));
for height in [1, 2, 3, 4, 30] {
let frame = ui.draw(&mut view, NOW, (40, height));
assert!(frame.len() <= height);
if height >= 3 {
assert!(
frame.iter().any(|s| strip_sgr(s).starts_with(" a3 ")),
"{frame:?}"
);
}
}
for id in ["a0", "a1", "a2", "a3", "b0", "b1", "b2", "b3"] {
store.remove(id).unwrap();
}
view.refresh();
for key in [Key::PageUp, Key::PageDown, Key::Home, Key::End] {
ui.press(key, &view, NOW);
assert!(ui.chosen.is_none());
assert!(
ui.draw(&mut view, NOW, (80, 5))
.iter()
.any(|s| s.contains("no tasks"))
);
}
}
#[test]
fn task_pages_pause_on_old_output_and_resume_at_the_end() {
let h = home();
let store = Store::new(&h.0);
let prompt = format!(
"```\n{}\n```",
(0..40)
.map(|i| format!("prompt-{i:02}"))
.collect::<Vec<_>>()
.join("\n")
);
store.save_prompt("t1", &prompt).unwrap();
store
.save(&task("t1", "user", "running", NOW, json!({"turns": 0})))
.unwrap();
store
.append(&event(
1,
1000,
"t1",
"said",
json!({"text": "latest before"}),
))
.unwrap();
let mut view = View::new(&h.0, false);
view.refresh();
let mut ui = Ui {
open: Some("t1".into()),
chosen: Some("t1".into()),
keys: true,
..Ui::default()
};
let draw = |ui: &mut Ui, view: &mut View| {
ui.draw(view, NOW, (80, 8))
.iter()
.map(|s| strip_sgr(s))
.collect::<Vec<_>>()
};
let live = draw(&mut ui, &mut view);
assert!(live.iter().any(|s| s.contains("latest before")));
assert!(live[7].contains("live"));
ui.press(Key::PageUp, &view, NOW);
let paused = draw(&mut ui, &mut view);
assert!(!paused.iter().any(|s| s.contains("latest before")));
assert!(paused[7].contains("paused"));
store
.append(&event(2, 0, "t1", "said", json!({"text": "latest after"})))
.unwrap();
view.refresh();
let refreshed = draw(&mut ui, &mut view);
assert_eq!(paused[1..7], refreshed[1..7]);
ui.press(Key::Home, &view, NOW);
let mut read = String::new();
for _ in 0..10 {
read.push_str(&draw(&mut ui, &mut view).join("\n"));
ui.press(Key::PageDown, &view, NOW);
}
for i in 0..40 {
assert!(read.contains(&format!("prompt-{i:02}")), "missing line {i}");
}
assert!(ui.detail.top.is_none());
assert!(
draw(&mut ui, &mut view)
.iter()
.any(|s| s.contains("latest after"))
);
ui.press(Key::Home, &view, NOW);
for height in [1, 2, 3, 8, 80] {
let frame = ui.draw(&mut view, NOW, (24, height));
assert!(frame.len() <= height);
assert!(frame.iter().all(|s| columns(&strip_sgr(s)) < 24));
assert_eq!(ui.detail.top, Some(0));
}
ui.press(Key::End, &view, NOW);
assert!(ui.detail.top.is_none());
ui.press(Key::Home, &view, NOW);
ui.press(Key::Back, &view, NOW);
ui.press(Key::Open, &view, NOW);
assert!(ui.detail.top.is_none());
store.remove("t1").unwrap();
view.refresh();
assert!(draw(&mut ui, &mut view)[0].contains("is gone"));
ui.press(Key::Back, &view, NOW);
assert!(ui.open.is_none());
}
#[test]
fn task_pages_include_all_waiting_requests() {
let h = home();
let store = Store::new(&h.0);
let questions: Vec<_> = (0..20).map(|i| json!({"id": format!("q{i}"), "text": format!("question-{i:02}"), "answer": null, "asked_ms": NOW})).collect();
store
.save(&task(
"t1",
"user",
"waiting",
NOW,
json!({"questions": questions}),
))
.unwrap();
let mut view = View::new(&h.0, false);
view.refresh();
let mut ui = Ui {
open: Some("t1".into()),
keys: true,
..Ui::default()
};
let live: Vec<String> = ui
.draw(&mut view, NOW, (80, 6))
.iter()
.map(|s| strip_sgr(s))
.collect();
assert!(live[1].contains("q0: question-00"), "{live:#?}");
assert_eq!(
live[2].trim_end(),
" …and 19 more above the conversation"
);
ui.press(Key::Home, &view, NOW);
let mut read = String::new();
for _ in 0..10 {
read.push_str(&ui.draw(&mut view, NOW, (80, 6)).join("\n"));
ui.press(Key::PageDown, &view, NOW);
}
for i in 0..20 {
assert!(
read.contains(&format!("question-{i:02}")),
"missing question {i}"
);
}
}
#[test]
fn a_pending_approval_stays_in_sight_while_the_conversation_scrolls() {
let h = home();
let store = Store::new(&h.0);
let prompt: Vec<String> = (0..40).map(|i| format!("prompt-{i:02}")).collect();
store.save_prompt("t1", &prompt.join("\n\n")).unwrap();
store
.save(&task("t1", "user", "running", NOW, json!({"turns": 0})))
.unwrap();
for e in [
event(1, 60_000, "t1", "turn_started", json!({"turn": 1})),
event(2, 30_000, "t1", "said", json!({"text": "Pushing now."})),
event(
3,
5_000,
"t1",
"approval_request",
json!({"id": "r1", "summary": "git push origin main"}),
),
] {
store.append(&e).unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let mut ui = Ui {
open: Some("t1".into()),
keys: true,
..Ui::default()
};
let draw = |ui: &mut Ui, view: &mut View| {
ui.draw(view, NOW, (80, 10))
.iter()
.map(|s| strip_sgr(s))
.collect::<Vec<_>>()
};
let live = draw(&mut ui, &mut view);
assert!(live[0].contains("approval"), "{live:#?}");
assert!(
live[1].starts_with(" needs approval r1: git push origin main"),
"{live:#?}"
);
assert!(live.iter().any(|s| s.contains("Pushing now.")), "{live:#?}");
assert!(live[9].contains("live"), "{live:#?}");
ui.press(Key::Home, &view, NOW);
let top = draw(&mut ui, &mut view);
assert!(top[1].starts_with(" needs approval r1"), "{top:#?}");
assert!(top.iter().any(|s| s.contains("prompt-00")), "{top:#?}");
store
.append(&event(4, 0, "t1", "approved", json!({"id": "r1"})))
.unwrap();
view.refresh();
ui.press(Key::End, &view, NOW);
let decided = draw(&mut ui, &mut view);
assert!(!decided.iter().any(|s| s.contains("needs")), "{decided:#?}");
assert!(decided[0].contains("running"), "{decided:#?}");
assert!(decided[9].contains("live"), "{decided:#?}");
}
#[test]
fn metadata_refresh_retries_bad_snapshots_and_detects_same_size_changes() {
let h = home();
let store = Store::new(&h.0);
let mut t = task("t1", "user", "idle", NOW, json!({"name": "old"}));
store.save(&t).unwrap();
let path = h.0.join("tasks/t1/task.json");
let mut view = View::new(&h.0, false);
view.refresh();
let stamp = FileStamp::of(&path).unwrap();
let allocation = view.tasks["t1"].id.as_ptr();
view.refresh();
assert_eq!(view.tasks["t1"].id.as_ptr(), allocation);
t.name = Some("new".into());
let bytes = serde_json::to_vec_pretty(&t).unwrap();
assert_eq!(bytes.len() as u64, stamp.len);
let changed = stamp.modified + Duration::from_secs(2);
let write = |bytes: &[u8]| {
fs::write(&path, bytes).unwrap();
File::options()
.write(true)
.open(&path)
.unwrap()
.set_times(fs::FileTimes::new().set_modified(changed))
.unwrap();
};
write(&vec![b'!'; bytes.len()]);
view.refresh();
assert_eq!(view.tasks["t1"].name.as_deref(), Some("old"));
assert_eq!(view.task_stamps["t1"], stamp);
write(&bytes);
view.refresh();
assert_eq!(view.tasks["t1"].name.as_deref(), Some("new"));
view.frame(NOW, None, None);
view.task_frame("t1", NOW, None, false);
store.remove("t1").unwrap();
view.refresh();
assert!(view.tasks.is_empty() && view.task_stamps.is_empty() && view.tails.is_empty());
assert!(view.detail.is_none());
store.save(&t).unwrap();
view.refresh();
assert_eq!(view.find("new").unwrap(), "t1");
}
#[test]
fn filtered_logs_and_detail_files_load_when_needed_and_catch_up_on_return() {
let h = home();
let store = Store::new(&h.0);
for (id, parent, status, at) in [
("old", "user", "idle", NOW - 2 * HOUR),
("ancestor", "user", "idle", NOW - 2 * HOUR),
("child", "task:ancestor", "running", NOW),
] {
store
.save(&task(id, parent, status, at, json!({})))
.unwrap();
store.save_prompt(id, &format!("prompt {id}")).unwrap();
store
.append(&event(
1,
0,
id,
"said",
json!({"text": format!("said {id}")}),
))
.unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
assert_eq!(view.find("old").unwrap(), "old");
assert!(view.tails.is_empty() && view.detail.is_none());
let list = view.frame(NOW, None, None).join("\n");
assert!(list.contains("said ancestor") && list.contains("said child"));
assert!(!view.tails.contains_key("old"));
assert!(
view.tails
.values()
.all(|t| t.prompt.is_none() && t.first.is_none() && t.results.is_empty())
);
let old = view.task_frame("old", NOW, None, false).join("\n");
assert!(old.contains("prompt old") && old.contains("said old"));
assert_eq!(view.detail.as_ref().unwrap().0, "old");
store
.append(&event(
2,
0,
"child",
"approval_request",
json!({"id": "r1", "summary": "push"}),
))
.unwrap();
view.refresh();
view.task_frame("old", NOW, None, false);
assert!(view.tail("child").approvals.is_empty());
assert!(
view.frame(NOW, None, None)
.join("\n")
.contains("1 approval(s)")
);
let child = view.task_frame("child", NOW, None, false).join("\n");
assert!(child.contains("prompt child") && child.contains("approval r1: push"));
assert_eq!(view.detail.as_ref().unwrap().0, "child");
view.all = true;
view.refresh();
assert!(view.frame(NOW, None, None).join("\n").contains("said old"));
view.all = false;
view.refresh();
view.frame(NOW, None, None);
assert!(!view.tails.contains_key("old"));
let mut child = view.tasks["child"].clone();
child.status = Status::Idle;
child.updated_ms = NOW - 2 * HOUR;
store.save(&child).unwrap();
view.refresh();
assert!(view.frame(NOW, None, None).join("\n").contains("no tasks"));
assert!(view.tails.is_empty());
}
#[test]
fn keys_redraw_cached_files_until_refresh_or_a_view_switch() {
let h = home();
let store = Store::new(&h.0);
store
.save(&task("t1", "user", "running", NOW, json!({})))
.unwrap();
store
.append(&event(1, 0, "t1", "said", json!({"text": "before"})))
.unwrap();
let mut view = View::new(&h.0, false);
let mut ui = Ui {
keys: true,
..Ui::default()
};
view.refresh();
ui.draw(&mut view, NOW, (80, 20));
store
.append(&event(2, 0, "t1", "said", json!({"text": "after"})))
.unwrap();
for key in [Key::Down, Key::Up, Key::Home, Key::End] {
ui.press(key, &view, NOW);
assert!(
!ui.draw(&mut view, NOW, (80, 20))
.join("\n")
.contains("after")
);
}
ui.press(Key::Open, &view, NOW);
assert!(
ui.draw(&mut view, NOW, (80, 20))
.join("\n")
.contains("after")
);
store
.append(&event(3, 0, "t1", "said", json!({"text": "latest"})))
.unwrap();
for key in [Key::PageUp, Key::PageDown, Key::Home, Key::End] {
ui.press(key, &view, NOW);
assert!(
!ui.draw(&mut view, NOW, (80, 20))
.join("\n")
.contains("latest")
);
}
view.refresh();
assert!(
ui.draw(&mut view, NOW, (80, 20))
.join("\n")
.contains("latest")
);
store
.append(&event(4, 0, "t1", "said", json!({"text": "returned"})))
.unwrap();
ui.press(Key::Back, &view, NOW);
assert!(
ui.draw(&mut view, NOW, (80, 20))
.join("\n")
.contains("returned")
);
}
#[test]
fn streamed_events_retry_partial_lines_skip_bad_records_and_reset_after_rewrite() {
let h = home();
let path = h.0.join("events.jsonl");
let first =
serde_json::to_vec(&event(1, 0, "t1", "said", json!({"text": "first"}))).unwrap();
let second =
serde_json::to_vec(&event(2, 0, "t1", "said", json!({"text": "other"}))).unwrap();
let mut bytes = first.clone();
bytes.extend_from_slice(b"\ninvalid\n");
bytes.extend_from_slice(&second[..second.len() / 2]);
fs::write(&path, &bytes).unwrap();
let mut tail = Tail::default();
tail.read(&path, |_| None);
assert_eq!(tail.words.as_ref().unwrap().0, "first");
assert_eq!(tail.offset, first.len() as u64 + 9);
tail.read(&path, |_| panic!("unchanged events must not be replayed"));
assert_eq!(tail.log.len(), 1);
let mut append = File::options().append(true).open(&path).unwrap();
append.write_all(&second[second.len() / 2..]).unwrap();
append.write_all(b"\n").unwrap();
drop(append);
tail.read(&path, |_| None);
assert_eq!(tail.words.as_ref().unwrap().0, "other");
assert_eq!(tail.log.len(), 2);
fs::write(&path, [&first[..], b"\n"].concat()).unwrap();
tail.read(&path, |_| None);
assert_eq!(tail.words.as_ref().unwrap().0, "first");
assert_eq!(tail.log.len(), 1);
let changed = tail.stamp.as_ref().unwrap().modified + Duration::from_secs(2);
fs::write(&path, [&second[..], b"\n"].concat()).unwrap();
File::options()
.write(true)
.open(&path)
.unwrap()
.set_times(fs::FileTimes::new().set_modified(changed))
.unwrap();
tail.read(&path, |_| None);
assert_eq!(tail.words.as_ref().unwrap().0, "other");
assert_eq!(tail.log.len(), 1);
}
fn measure_scale(tasks: usize, records: usize, recent: usize, detail: bool) {
use std::hint::black_box;
use std::io::BufWriter;
use std::time::Instant;
let h = home();
let store = Store::new(&h.0);
let record =
serde_json::to_string(&event(1, 0, "t0", "said", json!({"text": "x".repeat(256)})))
.unwrap();
for i in 0..tasks {
let id = format!("t{i}");
store
.save(&task(
&id,
"user",
"idle",
if i < recent { NOW } else { NOW - 2 * HOUR },
json!({}),
))
.unwrap();
store
.save_prompt(&id, &"prompt paragraph\n\n".repeat(50))
.unwrap();
let mut file = BufWriter::new(File::create(store.events_path(&id)).unwrap());
for _ in 0..records {
writeln!(file, "{record}").unwrap();
}
file.flush().unwrap();
}
let mut view = View::new(&h.0, false);
let draw = |view: &mut View| {
if detail {
black_box(view.task_view(
"t0",
NOW,
Some((100, 30)),
true,
Some(&mut Scroll::default()),
));
} else {
black_box(view.frame(NOW, Some((100, 30)), None));
}
};
let started = Instant::now();
view.refresh();
draw(&mut view);
let cold = started.elapsed();
let started = Instant::now();
for _ in 0..20 {
view.refresh();
draw(&mut view);
}
let warm = started.elapsed() / 20;
let started = Instant::now();
for _ in 0..20 {
draw(&mut view);
}
let draw = started.elapsed() / 20;
println!(
"tasks={tasks} records/task={records} recent={recent} detail={detail} cold={cold:?} warm={warm:?} draw={draw:?}"
);
}
#[test]
#[ignore = "repeatable scale measurement"]
fn scale_many_tasks() {
measure_scale(1000, 1000, 10, false);
}
#[test]
#[ignore = "repeatable scale measurement"]
fn scale_large_log() {
measure_scale(1, 200_000, 1, false);
}
#[test]
#[ignore = "repeatable scale measurement"]
fn scale_detail() {
measure_scale(1000, 300, 1000, true);
}
fn wrap(line: &str, room: usize) -> Vec<String> {
let chars: Vec<char> = line.chars().collect();
breaks(&chars, room)
.into_iter()
.map(|r| chars[r].iter().collect())
.collect()
}
#[test]
fn a_command_is_shown_without_its_shell_and_what_was_cut_is_not_counted() {
for (command, shown) in [
(PWSH, "git status --short; echo 'done'"),
("bash -lc 'cargo test'", "cargo test"),
(r#"/bin/zsh -lc "echo \"hi\"""#, r#"echo "hi""#),
("cmd.exe /c dir", "dir"),
(
r#""C:\pwsh.exe" -Command 'git log --oneline…(+20 chars)"#,
"git log --oneline…",
),
("cargo test", "cargo test"),
("git log…(+20 chars)", "git log…"),
("sh script.sh", "sh script.sh"),
("bash", "bash"),
] {
assert_eq!(unshelled(uncounted(command)), shown, "{command}");
}
}
#[test]
fn paths_are_written_from_the_task_directory_only_where_they_start() {
for (text, shown) in [
("/work/a.rs", "a.rs"),
(r"D:\work\src\a.rs", r"src\a.rs"),
(
"cat /work/a /backup/work/b '/work/c'",
"cat a /backup/work/b 'c'",
),
("--file=/work/x", "--file=x"),
("/workshop/a /work", "/workshop/a /work"),
(
"cat '/backup(2025)/work/a.rs'",
"cat '/backup(2025)/work/a.rs'",
),
("see (/work/a.rs)", "see (a.rs)"),
] {
let cwd = if text.starts_with('D') {
r"D:\work"
} else {
"/work"
};
assert_eq!(from_dir(text, cwd), shown, "{text}");
}
}
#[test]
fn a_task_view_without_a_window_keeps_the_latest_messages_and_what_came_between() {
let h = home();
let store = Store::new(&h.0);
store.save_prompt("t1", "Go.").unwrap();
store
.save(&task("t1", "user", "running", NOW, json!({"turns": 0})))
.unwrap();
for i in 1..=25 {
let at = 100_000 - i * 1_000;
let said = json!({"text": format!("m{i}")});
store.append(&event(2 * i, at, "t1", "said", said)).unwrap();
let tool = json!({"name": "Bash", "detail": format!("c{i}")});
store
.append(&event(2 * i + 1, at, "t1", "tool", tool))
.unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let text = view.task_frame("t1", NOW, None, false).join("\n");
assert!(
text.contains("\n\n› Go.\n\n• m6\n └ Run c6\n\n• m7\n"),
"{text}"
);
assert!(text.ends_with("\n\n• m25\n └ Run c25"), "{text}");
assert!(!text.contains("c5"), "{text}");
}
#[test]
fn tool_updates_replace_the_matching_row_without_counting_again() {
let mut tail = Tail::default();
for (seq, kind, data) in [
(
1,
"tool",
json!({"id": "a", "name": "use_tool", "detail": ""}),
),
(
2,
"tool",
json!({"id": "b", "name": "read_file", "detail": "src/main.rs"}),
),
(
3,
"tool_updated",
json!({"id": "a", "name": "web__search", "detail": "pi rpc"}),
),
(
4,
"tool_updated",
json!({"id": "missing", "name": "ignored", "detail": ""}),
),
] {
tail.absorb(&event(seq, seq, "t1", kind, data), || None);
}
assert_eq!(tail.tool_calls, 2);
assert_eq!(tail.log.len(), 2);
assert!(matches!(&tail.log[0].what, What::Tool { name, detail, .. }
if name == "web__search" && detail == "pi rpc"));
assert!(matches!(&tail.log[1].what, What::Tool { name, detail, .. }
if name == "read_file" && detail == "src/main.rs"));
assert_eq!(tail.log[0].at, event(1, 1, "t1", "tool", json!({})).ts);
}
#[test]
fn the_latest_tool_calls_show_when_they_fill_the_window() {
let h = home();
let store = Store::new(&h.0);
store
.save(&task("t1", "user", "running", NOW, json!({"turns": 0})))
.unwrap();
let said = json!({"text": "Working."});
store.append(&event(1, 20_000, "t1", "said", said)).unwrap();
for i in 1..=10 {
let tool = json!({"name": "Bash", "detail": format!("c{i}")});
store
.append(&event(i + 1, 10_000, "t1", "tool", tool))
.unwrap();
}
let mut view = View::new(&h.0, false);
view.refresh();
let frame: Vec<String> = view
.task_frame("t1", NOW, Some((60, 5)), false)
.iter()
.map(|l| strip_sgr(l))
.collect();
assert_eq!(
frame[1..],
["… Run c7", " Run c8", " Run c9", " Run c10"],
"{frame:#?}"
);
}
#[test]
fn wrapping_breaks_between_words_when_it_can() {
assert_eq!(wrap("aaa bbb ccc", 7), ["aaa bbb", "ccc"]);
assert_eq!(wrap("aaaaaaaaaa", 4), ["aaaa", "aaaa", "aa"]);
assert_eq!(wrap("审查审查审查", 5), ["审查", "审查", "审查"]);
assert_eq!(wrap("审查 abc 审查审查", 6), ["审查", "abc 审", "查审查"]);
assert_eq!(wrap("审查。审查", 4), ["审", "查。", "审查"]);
assert_eq!(wrap("", 5), [""]);
}
}