Tickets carry a Tags field, but ls could not select on it: finding what is tagged bug meant reading the board. Step 1 of the plan was already done by e41802b, which put tags: Vec<String> on TicketItem through parse_tags, so this is the flag, the filter and the tests. Whole values, not the field. parse_tags has already split and trimmed the comma-separated field, so filter_by_tag compares against those values: --tag bug is not answered by a ticket tagged bugfix, --tag "cli, filter" matches nothing because the field as written is not itself a tag, and a ticket with no tags matches none, however it spells it. Case sensitive, which is the opinion the field already takes everywhere else. tag_color draws Bug and bug in two colours because they are two tags to the field, and a filter that folded them would list tickets carrying a tag nobody asked for while hiding exactly the split a grooming sweep is looking for. One tag per invocation. Several would have to decide between and and or, and that decision is its own ticket, along with substring or regex matching and a tag filter on the board. A tag nothing carries lists nothing rather than being refused, deliberately the opposite of --campaign. A campaign is an object that exists or does not, so it is resolved before anything is read; a tag is free text with no registry, and refusing an unknown one would mean maintaining a vocabulary the format does not have. An emptied status keeps the message ls already gives rather than one per filter naming what excluded them, which is what --priority and --campaign already do. The filter goes through filtered, the one call the three collect sites share, so the counts are filtered by the same set as the rows. Every filter is an Option and none asked for keeps everything, which is what makes them compose in any combination. cmd_ls is now at four filters and the directory, two of them adjacent &Option<String> parameters a caller can swap silently: left as positionals rather than refactored mid-feature, with AGENTS.md recording that the next filter takes an LsArgs struct the way add took AddArgs. assets/PLAN.md said in as many words that there was no tag filter yet, so it would have been actively wrong. It now says what --tag can and cannot answer: it finds what is tagged bug, it does not enumerate the vocabulary, which is the question a grooming sweep starts from. The README's ls row also gained --campaign, which had never been documented there. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
233 lines
10 KiB
Rust
233 lines
10 KiB
Rust
use anyhow::Result;
|
|
use clap::Parser;
|
|
|
|
mod campaign;
|
|
mod clipboard;
|
|
mod command;
|
|
mod handlers;
|
|
mod install;
|
|
mod tui;
|
|
mod util;
|
|
|
|
use command::*;
|
|
use handlers::*;
|
|
use util::*;
|
|
|
|
/// Die quietly when stdout is closed early, the way every other Unix tool does.
|
|
///
|
|
/// Rust sets `SIGPIPE` to `SIG_IGN` at startup, which turns a closed pipe into an
|
|
/// io error that `println!` panics on. So `worklane ls | head -3` printed a panic
|
|
/// and a backtrace instead of three lines, which is both alarming and easy to
|
|
/// mistake for a real fault. Restoring the default handler makes `| head` behave.
|
|
///
|
|
/// The cost is that a truncated pipe now kills the process with signal 13 rather
|
|
/// than returning a code, so `pipefail` sees 141 instead of 101. That is what
|
|
/// `head` and `sort` do, and it is recorded in the README.
|
|
fn quiet_broken_pipe() {
|
|
// SAFETY: setting a signal disposition to the default is always valid, and
|
|
// this runs before any thread is spawned.
|
|
unsafe {
|
|
libc::signal(libc::SIGPIPE, libc::SIG_DFL);
|
|
}
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
// Before any output, so no write can beat it to a closed pipe.
|
|
quiet_broken_pipe();
|
|
|
|
let cli = Cli::parse();
|
|
|
|
let start = std::env::current_dir()?;
|
|
|
|
match cli.command {
|
|
// 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),
|
|
Some(Command::Add(args)) => cmd_add(&args, &start),
|
|
Some(Command::Ls {
|
|
status,
|
|
priority,
|
|
tag,
|
|
campaign,
|
|
}) => {
|
|
let worklane_dir = find_worklane_dir(&start)?;
|
|
cmd_ls(&status, priority, &tag, &campaign, &worklane_dir)
|
|
}
|
|
Some(Command::Show { id }) => {
|
|
let worklane_dir = find_worklane_dir(&start)?;
|
|
cmd_show(&id, &worklane_dir)
|
|
}
|
|
Some(Command::Mv {
|
|
ticket,
|
|
status,
|
|
force,
|
|
}) => cmd_mv(&ticket, &status, force, &start),
|
|
Some(Command::Set(args)) => cmd_set(&args, &start),
|
|
Some(Command::Append(args)) => cmd_append(&args, &start),
|
|
Some(Command::Relate(args)) => cmd_relate(&args, &start),
|
|
Some(Command::Chown { user, ticket }) => cmd_chown(&user, &ticket, &start),
|
|
Some(Command::Check(args)) => cmd_check(&args, true, &start),
|
|
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
|
|
Some(Command::Comment {
|
|
ticket,
|
|
body,
|
|
owner,
|
|
}) => cmd_comment(&ticket, &body, &owner, &start),
|
|
Some(Command::Campaign { command }) => match command {
|
|
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
|
|
CampaignCommand::Ls => {
|
|
let worklane_dir = find_worklane_dir(&start)?;
|
|
cmd_campaign_ls(&worklane_dir)
|
|
}
|
|
CampaignCommand::Show { campaign } => {
|
|
let worklane_dir = find_worklane_dir(&start)?;
|
|
cmd_campaign_show(&campaign, &worklane_dir)
|
|
}
|
|
},
|
|
Some(Command::Assign { campaign, ticket }) => cmd_assign(&campaign, &ticket, &start),
|
|
// 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)
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------- tui --
|
|
|
|
/// Restore the terminal whatever happens.
|
|
///
|
|
/// A panic inside the draw loop with raw mode still on leaves the shell unusable and
|
|
/// the backtrace unreadable, so the hook runs before the default one.
|
|
fn install_panic_hook() {
|
|
let previous = std::panic::take_hook();
|
|
std::panic::set_hook(Box::new(move |info| {
|
|
let _ = restore_terminal();
|
|
previous(info);
|
|
}));
|
|
}
|
|
|
|
fn restore_terminal() -> std::io::Result<()> {
|
|
crossterm::terminal::disable_raw_mode()?;
|
|
crossterm::execute!(
|
|
std::io::stdout(),
|
|
crossterm::terminal::LeaveAlternateScreen
|
|
)
|
|
}
|
|
|
|
fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()> {
|
|
use crossterm::event::{self, Event, KeyCode, KeyEventKind, KeyModifiers};
|
|
use std::io::IsTerminal;
|
|
|
|
// The boards are looked for before the terminal is, so running this outside a
|
|
// worklane directory gives the same message every other command gives rather than
|
|
// a complaint about the terminal.
|
|
let projects = tui::projects(paths, start)?;
|
|
|
|
// Without this, entering raw mode on a pipe fails with a bare "No such device or
|
|
// address (os error 6)", which says nothing about the actual mistake. A bare
|
|
// `worklane` is how the board is opened, so a script that reaches it by accident
|
|
// has to be pointed at a subcommand.
|
|
if !std::io::stdin().is_terminal() {
|
|
return Err(anyhow::anyhow!(
|
|
"`worklane` with no subcommand opens the board, which needs a terminal.\n\
|
|
For scripted use try `worklane ls` or `worklane show`; `worklane --help` \
|
|
lists everything."
|
|
));
|
|
}
|
|
|
|
let mut board = tui::Board::new(projects)?;
|
|
|
|
install_panic_hook();
|
|
crossterm::terminal::enable_raw_mode()?;
|
|
crossterm::execute!(std::io::stdout(), crossterm::terminal::EnterAlternateScreen)?;
|
|
let mut terminal =
|
|
ratatui::Terminal::new(ratatui::backend::CrosstermBackend::new(std::io::stdout()))?;
|
|
|
|
let result = (|| -> Result<()> {
|
|
while !board.should_quit {
|
|
board.tick()?;
|
|
terminal.draw(|frame| tui::draw(frame, &board))?;
|
|
|
|
// Taken after the draw, so a scroll measures the overlay that is on screen.
|
|
let screen = terminal.size()?;
|
|
|
|
// Bounded, so the tick still runs when nobody is typing.
|
|
if !event::poll(tui::POLL)? {
|
|
continue;
|
|
}
|
|
let Event::Key(key) = event::read()? else {
|
|
continue;
|
|
};
|
|
if key.kind != KeyEventKind::Press {
|
|
continue;
|
|
}
|
|
|
|
// Every keypress takes away what the last one said, so a notice never
|
|
// outlives the moment it belongs to. Ahead of the prompt as well as the
|
|
// arms: a key typed into a query is still a key. The rule is
|
|
// `Board::clear_notice`, where a test can reach it, and the arm below that
|
|
// sets one runs after this.
|
|
board.clear_notice();
|
|
|
|
// Ahead of the arms, because a prompt has to swallow every key it is
|
|
// given: typing `d` into a query must not toggle the done column and `q`
|
|
// must not quit. It reports what it took, so the arms below stay a plain
|
|
// match on the keys it did not, and it takes nothing when no prompt is open.
|
|
// The rule is `Board::search_key`, where a test can reach it.
|
|
if board.search_key(key, screen) {
|
|
continue;
|
|
}
|
|
|
|
match key.code {
|
|
// One arm, because the two keys mean one thing: close what is open, and
|
|
// quit when there is nothing left to close. Two arms carrying one rule
|
|
// is how a later edit changes it for one key and not the other, which is
|
|
// what `q` quitting out from under an open ticket already was. The rule
|
|
// itself is `Board::dismiss`, where a test can reach it.
|
|
KeyCode::Esc | KeyCode::Char('q') => board.dismiss(),
|
|
// The only key that leaves the board from an open ticket, which is why
|
|
// the footer names it there.
|
|
KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
|
board.should_quit = true
|
|
}
|
|
KeyCode::Enter | KeyCode::Char(' ') => board.toggle_detail(),
|
|
KeyCode::Left | KeyCode::Char('h') => board.select_column(-1, screen),
|
|
KeyCode::Right | KeyCode::Char('l') => board.select_column(1, screen),
|
|
// Up and down stay on the selection, open detail view or not, so a
|
|
// column can be read through without closing the modal. Scrolling the
|
|
// open ticket is a page at a time.
|
|
KeyCode::Up | KeyCode::Char('k') => board.select_card(-1, screen),
|
|
KeyCode::Down | KeyCode::Char('j') => board.select_card(1, screen),
|
|
KeyCode::PageUp => board.scroll_detail(-1, screen),
|
|
KeyCode::PageDown => board.scroll_detail(1, screen),
|
|
// Tabs cycle rather than clamp, the way tabs everywhere do, and are
|
|
// a no-op with a single board. Free of every other binding: the
|
|
// columns took hjkl and the arrows.
|
|
KeyCode::Tab => board.select_tab(1, screen),
|
|
KeyCode::BackTab => board.select_tab(-1, screen),
|
|
// Free of the other bindings, and the footer names it in both states.
|
|
KeyCode::Char('d') => board.toggle_done(screen),
|
|
// An ordinary single-shot action like the rest: it opens the prompt, and
|
|
// from the next keypress on `search_key` above has the keyboard. A `/`
|
|
// typed into an open prompt is taken there as a character, so this arm
|
|
// is only ever the way in.
|
|
KeyCode::Char('/') => board.open_search(),
|
|
// `y` as in yank, for the readers this board is for, and the only letter
|
|
// left that a vim hand would reach for. The clipboard is handed in rather
|
|
// than reached for inside `Board`, so the suite can drive both answers.
|
|
KeyCode::Char('y') => board.copy_selected_id(clipboard::copy),
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
})();
|
|
|
|
// Before the error surfaces, so a failure does not leave the shell in raw mode.
|
|
restore_terminal()?;
|
|
result
|
|
}
|