(53ffb94) Run the command the prompt parsed, and redraw the board on what it wrote, and bump to 0.32.16

The prompt parsed a line and named what it resolved to. This is the half
that does it: the parsed command goes to the same cmd_* handler main.rs
hands it to, against the selected tab's own .worklane, with a Sink over a
buffer collecting what the handler says instead of stdout.

One dispatch table, not two. main.rs's match on Command is lifted into
`dispatch`, over the command, the start path and the sink, and both
callers go through it. A second copy in tui.rs would drift the first time
a command was added and would drift silently, since both halves go on
compiling; the match is exhaustive so a new verb cannot fall into an `_`
arm either. Only `tui` is matched outside it, in main, because the board
is that table's caller rather than an entry in it, and reached from the
prompt it is refused in those words.

Two things the board has to do that the CLI never had to. It reloads
unconditionally after a command returns rather than waiting for the
digest, so a reader does not watch their own mv take up to a poll
interval to appear, and either way, since a handler that failed part way
through has still written. And the selection is restored by uuid across
that reload: mv puts the card in another column, set --title renames its
file, and a filter can drop it out of view, so the slot is not the
ticket. Where the board cannot follow it, the notice says so and which
key shows it.

What the handler says is what the board reports, word for word. Notice
therefore holds as many lines as the command used, and notice_on_row is
the one rule for where they go: one line on the footer row where a copy's
notice has always gone, anything else as a box at the foot of the
columns. A box rather than more rows of footer, because a footer that
grew and shrank as notices came and went would reflow the columns on
every keypress. A handler that errors leaves the prompt open with the
line intact, the usual cause being an ambiguous id.

`without_escapes` in util.rs is the guard at the seam. A handler's own
output is plain because the sink is, but an error message is built with
color_text, which asks the process about its stdout and under the board
answers yes about a terminal the message is not going to; a ratatui
paragraph prints an escape rather than obeying it. That is 6d327df's
fault on a new path.

The merge tab is refused for now, resolved by index rather than by the
tab's name, which is a label two projects can share. Routing by the card
a command names is ebc5755.

Not done here, and both tracked: check with no criterion still reaches
ask_which_criterion and reads a raw-mode stdin, which is 6d37042's
criterion 4 and commented there; and check_blockers warns about a
dangling blocker with eprintln!, which reaches the alternate screen
because it never passes through dispatch's result, filed as c680e24.
This commit is contained in:
Ansho Rei
2026-08-27 23:38:02 +02:00
parent f16e2aba0c
commit 96cddc14ad
6 changed files with 894 additions and 155 deletions
+99 -69
View File
@@ -1,3 +1,5 @@
use std::path::Path;
use anyhow::Result;
use clap::Parser;
@@ -50,76 +52,16 @@ fn main() -> Result<()> {
let mut sink = Sink::std();
let result = match cli.command {
// The board is the one thing `dispatch` does not run, and it is matched here
// rather than there because it is the *caller* of that table rather than an entry
// in it: a `tui` reached from the command prompt would enter the alternate screen
// a second time from inside the draw loop. `dispatch` refuses it in those words.
//
// No subcommand opens the board, the way a bare `frig` does, and with no path
// it opens the board above the working directory.
None => run_tui(&[], &start),
Some(Command::Tui { paths }) => run_tui(&paths, &start),
Some(Command::Init) => cmd_init(&start, &mut sink),
Some(Command::Add(args)) => cmd_add(&args, &start, &mut sink),
Some(Command::Ls(args)) => {
let worklane_dir = find_worklane_dir(&start)?;
cmd_ls(&args, &worklane_dir, &mut sink)
}
Some(Command::Show { id }) => {
let worklane_dir = find_worklane_dir(&start)?;
cmd_show(&id, &worklane_dir, &mut sink)
}
Some(Command::Mv(args)) => cmd_mv(&args, &start, &mut sink),
Some(Command::Set(args)) => cmd_set(&args, &start, &mut sink),
Some(Command::Append(args)) => cmd_append(&args, &start, &mut sink),
Some(Command::Relate(args)) => cmd_relate(&args, &start, &mut sink),
Some(Command::Chown(args)) => cmd_chown(&args, &start, &mut sink),
Some(Command::Check(args)) => cmd_check(&args, true, &start, &mut sink),
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start, &mut sink),
Some(Command::Comment {
ticket,
body,
actor,
actor_from_git,
}) => cmd_comment(&ticket, &body, &actor, actor_from_git, &start, &mut sink),
Some(Command::Campaign { command }) => match command {
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start, &mut sink),
CampaignCommand::Ls { ids } => {
let worklane_dir = find_worklane_dir(&start)?;
cmd_campaign_ls(&worklane_dir, ids, &mut sink)
}
CampaignCommand::Set(args) => cmd_campaign_set(&args, &start, &mut sink),
CampaignCommand::Append(args) => cmd_campaign_append(&args, &start, &mut sink),
CampaignCommand::Show { campaign } => {
let worklane_dir = find_worklane_dir(&start)?;
cmd_campaign_show(&campaign, &worklane_dir, &mut sink)
}
},
Some(Command::Assign {
campaign,
ticket,
actor,
actor_from_git,
}) => cmd_assign(&campaign, &ticket, &actor, actor_from_git, &start, &mut sink),
// The bare form and `ls` are one arm: `worklane tags` was the listing before the
// group existed and the fish completion still calls it that way, so the two
// spellings cannot be allowed to drift into two behaviours.
Some(Command::Tags { command }) => match command {
None | Some(TagCommand::Ls) => {
let worklane_dir = find_worklane_dir(&start)?;
cmd_tags(&worklane_dir, &mut sink)
}
Some(TagCommand::Add(args)) => cmd_tag_add(&args, &start, &mut sink),
Some(TagCommand::Set(args)) => cmd_tag_set(&args, &start, &mut sink),
},
// No board either, for the reason `install-skill` has none: a completion script
// is generated from the clap definition and is the same wherever it is run.
Some(Command::Completions { shell }) => {
completions::generate(shell, sink.as_write()).map_err(Into::into)
}
// No board is looked for: the point of the skill is to teach an agent worklane
// before there is a `.worklane` anywhere.
Some(Command::InstallSkill { skill, force, print }) => {
cmd_install_skill(skill.as_deref(), force, print, &mut sink)
}
// No board either, and one agent rather than both: opencode loads the tool file,
// Claude Code has no path for one.
Some(Command::InstallTool { force, print }) => cmd_install_tool(force, print, &mut sink),
Some(command) => dispatch(&command, &start, &mut sink),
};
// The board (and every handler) own their own writing, so flush what the last one
@@ -128,6 +70,93 @@ fn main() -> Result<()> {
result
}
/// Run one parsed command against the board at or above `start`, saying what it did
/// through `sink`.
///
/// **The one mapping from a parsed command to the function that performs it.** `main`
/// calls it with the process's stdout and the working directory; the command prompt on
/// the board calls it with a buffer and the selected tab's own root, and reads back what
/// the handler said. A second copy of this match inside `tui.rs` would be a copy that
/// drifted the first time a command was added, and it would drift *silently*, since both
/// halves would go on compiling.
///
/// A command added to [`Command`] therefore lands here once and is runnable from both.
/// The match is exhaustive for exactly that reason: there is no `_` arm for a new verb to
/// fall into and do nothing.
pub fn dispatch(command: &Command, start: &Path, sink: &mut Sink) -> Result<()> {
match command {
// Reachable only from the prompt, since `main` takes this arm before it gets
// here. A board is not something a board can open.
Command::Tui { .. } => Err(anyhow::anyhow!("`tui` opens a board, and you are on one")),
Command::Init => cmd_init(start, sink),
Command::Add(args) => cmd_add(args, start, sink),
Command::Ls(args) => {
let worklane_dir = find_worklane_dir(start)?;
cmd_ls(args, &worklane_dir, sink)
}
Command::Show { id } => {
let worklane_dir = find_worklane_dir(start)?;
cmd_show(id, &worklane_dir, sink)
}
Command::Mv(args) => cmd_mv(args, start, sink),
Command::Set(args) => cmd_set(args, start, sink),
Command::Append(args) => cmd_append(args, start, sink),
Command::Relate(args) => cmd_relate(args, start, sink),
Command::Chown(args) => cmd_chown(args, start, sink),
Command::Check(args) => cmd_check(args, true, start, sink),
Command::Uncheck(args) => cmd_check(args, false, start, sink),
Command::Comment {
ticket,
body,
actor,
actor_from_git,
} => cmd_comment(ticket, body, actor, *actor_from_git, start, sink),
Command::Campaign { command } => match command {
CampaignCommand::Add(args) => cmd_campaign_add(args, start, sink),
CampaignCommand::Ls { ids } => {
let worklane_dir = find_worklane_dir(start)?;
cmd_campaign_ls(&worklane_dir, *ids, sink)
}
CampaignCommand::Set(args) => cmd_campaign_set(args, start, sink),
CampaignCommand::Append(args) => cmd_campaign_append(args, start, sink),
CampaignCommand::Show { campaign } => {
let worklane_dir = find_worklane_dir(start)?;
cmd_campaign_show(campaign, &worklane_dir, sink)
}
},
Command::Assign {
campaign,
ticket,
actor,
actor_from_git,
} => cmd_assign(campaign, ticket, actor, *actor_from_git, start, sink),
// The bare form and `ls` are one arm: `worklane tags` was the listing before the
// group existed and the fish completion still calls it that way, so the two
// spellings cannot be allowed to drift into two behaviours.
Command::Tags { command } => match command {
None | Some(TagCommand::Ls) => {
let worklane_dir = find_worklane_dir(start)?;
cmd_tags(&worklane_dir, sink)
}
Some(TagCommand::Add(args)) => cmd_tag_add(args, start, sink),
Some(TagCommand::Set(args)) => cmd_tag_set(args, start, sink),
},
// No board either, for the reason `install-skill` has none: a completion script
// is generated from the clap definition and is the same wherever it is run.
Command::Completions { shell } => {
completions::generate(*shell, sink.as_write()).map_err(Into::into)
}
// No board is looked for: the point of the skill is to teach an agent worklane
// before there is a `.worklane` anywhere.
Command::InstallSkill { skill, force, print } => {
cmd_install_skill(skill.as_deref(), *force, *print, sink)
}
// No board either, and one agent rather than both: opencode loads the tool file,
// Claude Code has no path for one.
Command::InstallTool { force, print } => cmd_install_tool(*force, *print, sink),
}
}
// ---------------------------------------------------------------------- tui --
/// Restore the terminal whatever happens.
@@ -222,9 +251,10 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
// And the command prompt, third, on the same contract: while a command is being
// typed `q` is a letter, `d` leaves the columns alone and `tab` stays out of the
// project tabs. No screen, because nothing it does measures the board yet. The
// rule is `Board::prompt_key`, where a test can reach it.
if board.prompt_key(key) {
// project tabs. It takes the screen because enter runs the command and then has
// to bring the ticket it moved back into view. The rule is `Board::prompt_key`,
// where a test can reach it.
if board.prompt_key(key, screen) {
continue;
}