277 lines
13 KiB
Rust
277 lines
13 KiB
Rust
use anyhow::Result;
|
|
use clap::Parser;
|
|
|
|
mod campaign;
|
|
mod clipboard;
|
|
mod command;
|
|
mod completions;
|
|
mod handlers;
|
|
mod history;
|
|
mod install;
|
|
mod tag;
|
|
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(args)) => {
|
|
let worklane_dir = find_worklane_dir(&start)?;
|
|
cmd_ls(&args, &worklane_dir)
|
|
}
|
|
Some(Command::Show { id }) => {
|
|
let worklane_dir = find_worklane_dir(&start)?;
|
|
cmd_show(&id, &worklane_dir)
|
|
}
|
|
Some(Command::Mv(args)) => cmd_mv(&args, &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(args)) => cmd_chown(&args, &start),
|
|
Some(Command::Check(args)) => cmd_check(&args, true, &start),
|
|
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
|
|
Some(Command::Comment {
|
|
ticket,
|
|
body,
|
|
actor,
|
|
actor_from_git,
|
|
}) => cmd_comment(&ticket, &body, &actor, actor_from_git, &start),
|
|
Some(Command::Campaign { command }) => match command {
|
|
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
|
|
CampaignCommand::Ls { ids } => {
|
|
let worklane_dir = find_worklane_dir(&start)?;
|
|
cmd_campaign_ls(&worklane_dir, ids)
|
|
}
|
|
CampaignCommand::Set(args) => cmd_campaign_set(&args, &start),
|
|
CampaignCommand::Append(args) => cmd_campaign_append(&args, &start),
|
|
CampaignCommand::Show { campaign } => {
|
|
let worklane_dir = find_worklane_dir(&start)?;
|
|
cmd_campaign_show(&campaign, &worklane_dir)
|
|
}
|
|
},
|
|
Some(Command::Assign {
|
|
campaign,
|
|
ticket,
|
|
actor,
|
|
actor_from_git,
|
|
}) => cmd_assign(&campaign, &ticket, &actor, actor_from_git, &start),
|
|
// 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)
|
|
}
|
|
Some(TagCommand::Add(args)) => cmd_tag_add(&args, &start),
|
|
Some(TagCommand::Set(args)) => cmd_tag_set(&args, &start),
|
|
},
|
|
// 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, &mut std::io::stdout()).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)
|
|
}
|
|
// 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),
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------- 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;
|
|
}
|
|
|
|
// The same contract for the campaign picker, which is the other mode that owns
|
|
// the keyboard while it is open. Two calls rather than one combined pre-branch,
|
|
// because only one of the two can be open at a time and each reports for
|
|
// itself; the rules are `Board::search_key` and `Board::picker_key`, where a
|
|
// test can reach them.
|
|
if board.picker_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(screen),
|
|
// 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
|
|
}
|
|
// The frame's own height while it holds the selection, and the detail
|
|
// overlay on a card. `Board::toggle_focused` rather than a condition here,
|
|
// for the reason the scroll keys route there.
|
|
KeyCode::Enter | KeyCode::Char(' ') => board.toggle_focused(screen),
|
|
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, and so is scrolling the campaign
|
|
// frame that up reaches from the top card of a column.
|
|
KeyCode::Up | KeyCode::Char('k') => board.select_card(-1, screen),
|
|
KeyCode::Down | KeyCode::Char('j') => board.select_card(1, screen),
|
|
// The open ticket first and the campaign frame behind it, which is
|
|
// `Board::scroll_page` rather than a condition written here: the arms in
|
|
// this dispatch are not reachable from a test.
|
|
KeyCode::PageUp => board.scroll_page(-1, screen),
|
|
KeyCode::PageDown => board.scroll_page(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 what the next press
|
|
// does in every state of the rotation.
|
|
KeyCode::Char('d') => board.rotate_visibility(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, and one pressed
|
|
// at an open picker is taken by `picker_key` to open the picker's own
|
|
// query, so this arm is only ever the way in to the board's prompt.
|
|
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),
|
|
// The way in to the campaign picker, like `/` is to the search prompt: from
|
|
// the next keypress on `picker_key` above has the keyboard. Free of every
|
|
// other binding, and `ctrl-c` is matched above this so quitting still wins.
|
|
KeyCode::Char('c') => board.open_picker(tui::PickerKind::Campaign, screen),
|
|
// The other axis the board is cut along, and the one `ls --tag` has
|
|
// answered since 2f3796e. Free of every other binding: `tab` is its own
|
|
// key code, not this letter.
|
|
KeyCode::Char('t') => board.open_picker(tui::PickerKind::Tag, screen),
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
})();
|
|
|
|
// Before the error surfaces, so a failure does not leave the shell in raw mode.
|
|
restore_terminal()?;
|
|
result
|
|
}
|