diff --git a/AGENTS.md b/AGENTS.md index 928068a..f0f1cc3 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -3,6 +3,7 @@ ## Project Structure - `src/main.rs` - dispatch, the SIGPIPE reset, and the TUI event loop - `src/command.rs` - CLI argument definitions using clap derive +- `src/completions.rs` - the generated completion script and the fish half that asks the board - `src/handlers.rs` - one `cmd_*` per subcommand - `src/util.rs` - the ticket format, resolution, rendering and the palette - `src/campaign.rs` - the campaign file format, its resolution, its index and its members @@ -58,12 +59,22 @@ and this file is for what someone changing worklane's own code needs. - **The shape is checked before chrono is asked.** `%Y-%m-%d` accepts an unpadded `2026-8-9`, which would be stored exactly as typed and sort before `2026-10-01` in any string comparison. Checking the length and the two dashes first is what lets a valid date be stored unchanged instead of normalised on the way in, which is the difference between validating and rewriting - **Strict on the way in, tolerant on the way out.** `util::due_date` still cuts `2026-12-31T09:30:00Z` down to its date. A file written before the parser existed, or by hand, can hold one and still has to render; refusing to display what is already stored would punish the reader for the writer's mistake - An empty `--due` keeps `non_empty`'s message about clearing rather than the date message. Somebody typing it is reaching for a way to clear the field, and the useful answer is that clearing is not supported yet +- **A status is a `util::Status`, not a string.** `mv --status` and the `ls` positional take the value enum, so an unknown status is a usage error at parse time naming the four, exit 2, and no handler checks. That is the same bargain `--due` and `--priority` take, and it is what lets the shells complete the four for free. `Status::ALL` is the flow order, which `status_dirs()` and `cmd_mv` both read rather than spelling the names again, and `DONE` is defined from it - The ticket positionals (`show `, `mv `, `comment `) are also left alone, so a search term starting with a hyphen is a usage error. Reachable now that a hyphen-leading title can be stored: use the UUID, or put the flags first and separate with `--`, as in `mv --status committed -- -leading-title` - A bare `--` is a value when it follows an option (`--title -- ` stores `--`) and clap's end-of-options marker when it sits in a positional. So a `comment` body of exactly `--` needs its own separator, `comment -- --`. Without it the body is reported missing and nothing is written, which is a clear failure rather than a silent drop - `add` has no positionals, so anything after a bare `--` is an unexpected argument and fails - **A paragraph break in a description is an empty `--description` value.** `cmd_add` joins the values with a single newline, so `-d "First." -d "" -d "Second."` writes the blank line. `trim_blank_ends()` drops blank values at either end, so a break never lands against a section heading, and an all-blank description reads as no description. Interior runs are kept verbatim rather than collapsed - `--acceptance` and `--plan` are lists, one criterium or step per value, so a blank there is spacing rather than content and the opencode wrapper drops it. Only `--description` preserves blanks +### Completions + +- **Two halves, and the split is the point.** `clap_complete` generates the structure from the clap definition, so a new flag or subcommand is completed without anyone touching `completions.rs`. Only fish gets the second half, appended by `fish_dynamic()`, and it holds exactly what clap cannot know: the tickets on the board +- **The dynamic values come from worklane itself**, as `worklane ls --ids` in a command substitution, one run per keypress at 2.5ms in release. So the completions are only as current as the binary on PATH: an older one without `--ids` completes nothing, which is a reinstall rather than a bug +- **What clap does and does not emit.** It emits the possible values of an *option*, which is why `mv --status ` needs nothing here, and nothing for a *positional*, which is why the `ls` status and the `completions` shell are listed in the fish half. Both lists are read off the enums with `possible_values`, never written out, so a fifth status appears in the script on its own +- **Position is counted, not inferred.** `__worklane_first_arg_of` and `__worklane_second_arg_of` check `$tokens[2]` and the token count rather than using `__fish_seen_subcommand_from`, because `campaign ls` and `campaign show` are also an `ls` and a `show` that fish has seen, and because matching against the ticket list would run worklane again inside the condition +- **`TICKET_COMMANDS`, `TICKET_SECOND_COMMANDS` and `TICKET_FLAGS` are kept honest by tests**, which walk the clap definition and fail on a ticket-taking subcommand that is in neither list, or in the list for the wrong position. A nested subcommand is not walked: `campaign` is the only one, none of its three takes a ticket, and the token counting could not tell them apart if one did +- **`ls --ids` is the machine-readable listing**, and the only output in the tree meant to be parsed: the short id, a tab, the title, unstyled. Two fields because fish reads what follows a tab as the description and a script reads `cut -f1`. It includes done, which the decorated listing leaves out, because a completion has to be able to name a finished ticket, and it skips a missing status directory rather than refusing, because an error printed over a shell prompt is worse than no candidates. The filters still apply, and an unknown `--campaign` is still refused + ### Filtering the Listing - **The filters are one call, `filtered`,** because `ls` collects a column in three places (a named status, the counts, and the grouped listing) and three call sites are three chances to apply a different set. Every filter is an `Option` and none asked for keeps everything, which is what makes them compose in any combination without a rule per pair - **`--tag` matches whole values, not the field.** `parse_tags` has already split the comma-separated field, so the filter compares against those trimmed values: `--tag bug` is not answered by a ticket tagged `bugfix`, and `--tag "cli, filter"` matches nothing, because the field as written is not itself a tag. A ticket with no tags matches none @@ -71,7 +82,7 @@ and this file is for what someone changing worklane's own code needs. - **One tag per invocation.** Several would have to decide between and and or, and neither reading is obviously right for a board this size. That decision is its own ticket, along with a substring or regex match and a tag filter on the tui - **A tag nothing carries lists nothing rather than being refused**, which is the opposite of `--campaign`. A campaign is an object that either exists or does not, so it is resolved before anything is read and an unknown one is an error. A tag is free text with no registry: there is nothing to resolve against, and refusing an unknown one would mean maintaining a vocabulary the format deliberately does not have. `assets/PLAN.md` tells the agent to check the spelling when a listing comes back empty, since that is the failure this trades for - An emptied status keeps the message `ls` already gives, `No tickets in '' status.`, rather than one per filter naming what excluded them. That is pre-existing behaviour for `--priority` and `--campaign`, and one message for every filter is the consistent half of it. If it should name the filter, that is a change to what the CLI prints for three flags at once and belongs in its own ticket -- **`cmd_ls` is now at the boundary the Rust Style rule names:** four filters and the directory. Two of them are adjacent `&Option` parameters, which a caller can swap silently, so the next filter added here takes an `LsArgs` struct the way `add` took `AddArgs`, rather than a fifth positional +- **`cmd_ls` takes an `LsArgs`**, which is what the boundary in the Rust Style rule came to: four filters, an output mode and the directory, two of them adjacent `Option` values a caller could swap silently. `--ids` was the argument that tipped it, the way `add` became `AddArgs`. A new filter is a field there, not a parameter ### Editing a Ticket - `set` replaces a field, `append` adds to a section. The verb carries the meaning, so no flag needs a replace-or-append prefix, and `append` only offers the sections that hold multiple lines diff --git a/Cargo.lock b/Cargo.lock index 0edf4ab..e100763 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -208,6 +208,15 @@ dependencies = [ "strsim", ] +[[package]] +name = "clap_complete" +version = "4.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3be2ad0423bdbbb0e25bc89add796f3559706d4a95e1bc98e4d9662a957b6a19" +dependencies = [ + "clap", +] + [[package]] name = "clap_derive" version = "4.6.1" @@ -1494,13 +1503,14 @@ dependencies = [ [[package]] name = "worklane" -version = "0.16.1" +version = "0.17.0" dependencies = [ "anyhow", "assert_cmd", "assert_fs", "chrono", "clap", + "clap_complete", "crossterm", "libc", "ratatui", diff --git a/Cargo.toml b/Cargo.toml index 4315946..bcbb7b1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "worklane" -version = "0.16.1" +version = "0.17.0" edition = "2024" [dependencies] @@ -14,6 +14,7 @@ libc = "0.2" # widget until one of us changed. ratatui = { version = "0.29", features = ["unstable-rendered-line-info"] } crossterm = "0.28" +clap_complete = "4.6.9" [dev-dependencies] assert_cmd = "2" diff --git a/README.md b/README.md index 414b9b5..cf08be8 100644 --- a/README.md +++ b/README.md @@ -8,7 +8,7 @@ Worklane is a local Kanban flow for agentic software development. | `worklane` or `worklane tui [path...]` | Opens the board: four status columns, redrawn when the tree changes. Read only. Opens on backlog, committed and reviewing; `d` shows or hides done, whose count stays in the footer either way. Arrows or `hjkl` to move, `enter` for detail, `pgup`/`pgdn` to scroll an open ticket, whose border carries a page indicator while there is more of it than fits, `/` to jump to the first ticket whose id or title matches, `y` to copy the selected ticket's short id to the clipboard, `q` to quit. Each path opens the first `.worklane` at or above it, the working directory by default. Several paths are monitored together, as a tab per project plus an `all` tab that merges them, with `tab` and `shift+tab` between them | | `worklane init` | Creates `.worklane/` with backlog, committed, reviewing, done directories | | `worklane add` | Creates a ticket in backlog with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--owner`, `--priority` flags. `--due` takes `YYYY-MM-DD` and refuses anything else at parse time | -| `worklane ls [status]` | Lists tickets, sorted by priority then title. Optional positional status, and `--priority <1-5>`, `--tag ` and `--campaign `, which compose in any combination. `--tag` matches a whole value of the comma-separated Tags field, case sensitively, so `--tag bug` does not list a ticket tagged `bugfix` or one tagged `Bug` | +| `worklane ls [status]` | Lists tickets, sorted by priority then title. Optional positional status, and `--priority <1-5>`, `--tag ` and `--campaign `, which compose in any combination. `--tag` matches a whole value of the comma-separated Tags field, case sensitively, so `--tag bug` does not list a ticket tagged `bugfix` or one tagged `Bug`. `--ids` prints one ticket per line as its short id, a tab and its title, unstyled, done included, for a script or a completion | | `worklane show ` | Shows ticket by UUID prefix (4+ chars), title substring, or filename substring | | `worklane mv --status [-f]` | Moves ticket between statuses. Default: forward only, one stage at a time. `-f` bypasses both restrictions | | `worklane set ` | Replaces fields with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--priority`. At least one required. Changing the title renames the file, keeping the UUID | @@ -18,14 +18,42 @@ Worklane is a local Kanban flow for agentic software development. | `worklane check [criteria...]` | Ticks acceptance criteria, each by number as shown by `show` or by a substring. Several in one call, or `all` for every one of them. Prompts with the numbered list if none is given, or errors with it when there is no terminal | | `worklane uncheck [criteria...]` | Unticks acceptance criteria, addressed the same way | | `worklane comment ` | Adds a comment to a ticket by UUID or title | +| `worklane completions ` | Prints a completion script for `fish`, `bash`, `zsh`, `elvish` or `powershell`. See below | | `worklane install-skill [skill]` | Writes the embedded agent skills to `~/.claude/skills//SKILL.md`, which Claude Code and opencode both read. Three ship: `worklane` teaches the CLI, `worklane-review` reviews a finished ticket against the code that claims to close it, `worklane-plan` grooms the board as a whole, its priorities, due dates, tags and campaigns. Every document unless one is named. Leaves a modified copy alone unless `--force`; `--print` writes one to stdout instead and needs the name | +## Completions + +```sh +worklane completions fish > ~/.config/fish/completions/worklane.fish +``` + +Also `bash`, `zsh`, `elvish` and `powershell`, though only fish gets the dynamic half. + +The structure comes from clap, so new flags appear without anyone remembering to add them. The four +statuses come with it, because a status is a value enum rather than a string. On top of that, fish +asks worklane for the one thing only the board knows: + +``` +worklane show every ticket, id and title, done included +worklane mv the same, then --status for the four +worklane chown alice the ticket, which is the second argument here +worklane relate x --blocked-by +``` + +The tickets come from `worklane ls --ids`, one run per keypress, 2.5ms in release on a board of +seventy-five tickets. Since fish runs whatever `worklane` is on PATH, **completions need the +installed binary to be current**: an older one without `--ids` completes nothing. Re-run +`cargo install --path .` after pulling. + +`tui` is the one command whose argument is a path, so it is the one place fish still offers +directories. + ## Exit codes | Code | Meaning | |------|---------| | 0 | Success | | 1 | An error, such as no matching ticket or an ambiguous search | -| 2 | A usage mistake, such as an unknown flag | +| 2 | A usage mistake, such as an unknown flag, an unreal `--due` date, a priority out of range or a status that is not one of the four | | 141 | Output was piped to a reader that stopped early, for example `worklane ls \| head -3` | 141 is 128 + 13, the shell's way of reporting death by `SIGPIPE`. Worklane restores diff --git a/assets/SKILL.md b/assets/SKILL.md index 4f048a3..9dbffb8 100644 --- a/assets/SKILL.md +++ b/assets/SKILL.md @@ -47,6 +47,11 @@ worklane show 1b78a24 # one ticket, body and comments `ls` prints a seven-character id per ticket. That is what you address it by. +`worklane ls --ids` prints the same tickets as an id, a tab and a title, one per line and +unstyled, with done included and the filters still applying. That is the form to parse +when you want the ids themselves: `worklane ls --ids | cut -f1`. The decorated listing is +for reading, not for cutting up. + The filters compose in any combination, with each other and with the status positional: `worklane ls backlog --tag bug --priority 1`. `--tag` takes one tag and matches it against the whole values of the comma-separated `Tags` field, case sensitively, so @@ -214,6 +219,16 @@ existing ticket will have been written from a different angle. - Related but not the same: file it, and record it with `relate --relates-to ` rather than only mentioning the id in prose. +## Shell completions + +``` +worklane completions fish > ~/.config/fish/completions/worklane.fish +``` + +For the person's shell, not for you, and `bash`, `zsh`, `elvish` and `powershell` are +there too. Only fish completes ticket ids, which it does by running `worklane ls --ids`, +so a stale binary on PATH completes nothing and the fix is to reinstall it. + ## Addressing a ticket Every command that takes a ticket accepts, in this order of precedence: diff --git a/src/command.rs b/src/command.rs index 282bd99..2778c7c 100644 --- a/src/command.rs +++ b/src/command.rs @@ -4,7 +4,7 @@ use std::sync::LazyLock; use chrono::NaiveDate; -use crate::util::{PRIORITY_RANGE, RelationKind, priority_legend}; +use crate::util::{PRIORITY_RANGE, RelationKind, Status, priority_legend}; /// clap wants a `&str` with a long enough lifetime, and the legend is built from /// the same ramp the listing uses rather than spelled out a second time. @@ -112,22 +112,7 @@ pub enum Command { /// List tickets, optionally filtered by status #[command(after_help = PRIORITY_LEGEND.as_str())] - Ls { - /// Filter by status (backlog, committed, reviewing, done) - status: Option, - - /// Only show tickets at this priority, 1 (most urgent) to 5 (least) - #[arg(long, value_parser = priority_level)] - priority: Option, - - /// Only show tickets carrying this tag, matched whole - #[arg(long, value_parser = non_empty)] - tag: Option, - - /// Only show the members of this campaign, by UUID or title - #[arg(long, value_parser = non_empty)] - campaign: Option, - }, + Ls(LsArgs), /// Show a ticket by UUID or title Show { @@ -140,9 +125,9 @@ pub enum Command { /// Ticket UUID or title ticket: String, - /// Target status (backlog, committed, reviewing, done) + /// Target status #[arg(short, long)] - status: String, + status: Status, /// Force move (allows backward or non-sequential moves) #[arg(short, long)] @@ -227,6 +212,16 @@ pub enum Command { ticket: String, }, + /// Print a shell completion script + /// + /// The structure comes from the clap definition, so a flag added here appears + /// without anyone remembering to. Fish gets a hand-written half appended for the + /// values only the board knows, see `completions.rs`. + Completions { + /// fish, bash, zsh, elvish or powershell + shell: clap_complete::Shell, + }, + /// Install the agent skills that teach an agent to use worklane /// /// Every shipped document by default. The optional name narrows it to one, and @@ -288,6 +283,33 @@ pub struct CampaignAddArgs { pub owner: Option, } +/// `ls` holds four filters, an output mode and nothing else, which is the boundary the +/// Rust Style rule in AGENTS.md names: two of the filters are adjacent `Option` +/// values that a caller can swap silently, so the mode that joined them came as a +/// struct rather than a sixth parameter, the way `add` became [`AddArgs`]. +#[derive(clap::Args)] +pub struct LsArgs { + /// Filter by status + pub status: Option, + + /// Only show tickets at this priority, 1 (most urgent) to 5 (least) + #[arg(long, value_parser = priority_level)] + pub priority: Option, + + /// Only show tickets carrying this tag, matched whole + #[arg(long, value_parser = non_empty)] + pub tag: Option, + + /// Only show the members of this campaign, by UUID or title + #[arg(long, value_parser = non_empty)] + pub campaign: Option, + + /// Print one ticket per line as its id and title, tab separated, for a script or a + /// completion. Done included, and the filters still apply + #[arg(long)] + pub ids: bool, +} + /// `add` carries every field a new ticket can hold, so it is a struct rather than an /// inline variant: nine parameters at the call site is what `too_many_arguments` is /// for, and `set`, `append` and `check` already pass their arguments this way. diff --git a/src/completions.rs b/src/completions.rs new file mode 100644 index 0000000..b4c2f05 --- /dev/null +++ b/src/completions.rs @@ -0,0 +1,293 @@ +//! Shell completions. +//! +//! Two halves, because neither alone is enough. +//! +//! `clap_complete` generates the structure (subcommands, flags, their arguments) +//! straight from the clap definition, so a new flag never needs remembering here. But it +//! can only offer values it knows at compile time, and the value worth completing for +//! worklane is the ticket, which lives in the board the command is run above. +//! +//! So the fish output gets a hand-written block appended that asks worklane itself. That +//! costs one `worklane ls --ids` per keypress, which measured at 2.5ms in release on a +//! board of seventy-five tickets, comfortably below anything a person notices. +//! +//! The four statuses are half clap's: `Status` is a `ValueEnum`, so it emits them for +//! `mv --status`, but the fish generator does not emit possible values for a *positional* +//! and `ls ` gets nothing. Same for `completions `. So the block below +//! lists those two, from the enums rather than by hand. + +use std::io; + +use clap::{CommandFactory, ValueEnum}; +use clap_complete::Shell; + +use crate::install::SKILLS; +use crate::util::Status; + +/// Subcommands whose first positional is a ticket. +/// +/// Kept honest by a test rather than by memory: a new ticket-taking subcommand that is +/// missing here silently loses completion, which nothing else would catch. +pub const TICKET_COMMANDS: [&str; 8] = [ + "show", "mv", "comment", "set", "append", "relate", "check", "uncheck", +]; + +/// Subcommands whose *second* positional is the ticket, because they name two things. +/// +/// `chown alice ` and `assign "v1 release" `, which put the ticket +/// second deliberately, see AGENTS.md. The first argument of each is a user or a +/// campaign, and neither is completed. +pub const TICKET_SECOND_COMMANDS: [&str; 2] = ["chown", "assign"]; + +/// Options whose value is a ticket, as `relate` takes three of. +pub const TICKET_FLAGS: [&str; 3] = ["blocked-by", "regression-of", "relates-to"]; + +pub fn generate(shell: Shell, out: &mut dyn io::Write) -> io::Result<()> { + let mut command = crate::command::Cli::command(); + clap_complete::generate(shell, &mut command, "worklane", out); + + if shell == Shell::Fish { + write!(out, "{}", fish_dynamic())?; + } + Ok(()) +} + +/// The dynamic half, appended to what clap generated. +/// +/// Fish merges completions from every `complete` call, so these add to the generated +/// rules rather than replacing them. +fn fish_dynamic() -> String { + let ticket_commands = TICKET_COMMANDS.join(" "); + let ticket_second_commands = TICKET_SECOND_COMMANDS.join(" "); + let ticket_flags = TICKET_FLAGS + .iter() + .map(|flag| format!("-l {flag}")) + .collect::>() + .join(" "); + let statuses = possible_values(Status::value_variants()); + let shells = possible_values(Shell::value_variants()); + let skills = SKILLS + .iter() + .map(|skill| skill.name) + .collect::>() + .join(" "); + + format!( + r#" +# --------------------------------------------------------------------------- +# Dynamic values, appended by `worklane completions fish`. Fish accumulates +# completions, so these add to the generated rules above. +# --------------------------------------------------------------------------- + +# Almost every argument worklane takes names something on the board rather than +# something on disk, so stop fish falling back to the directory listing. Without this, +# `worklane show 1b78a24 ` offers Cargo.toml and src/. +complete -c worklane -f + +# The exception, and the reason the line above is not the whole story: `tui` takes +# project paths, as many as you like. Directories only, since each is resolved to the +# first `.worklane` at or above it. +complete -c worklane -n '__fish_seen_subcommand_from tui' \ + -a '(__fish_complete_directories)' -d project + +# Position is counted rather than inferred from what has been typed: matching against +# the ticket list would run worklane again inside the condition, and would also keep +# offering tickets after one had been chosen. +# +# The subcommand is the second token, so its first argument is being typed once two +# tokens are there. `$tokens[2]` rather than `__fish_seen_subcommand_from`, because +# `campaign ls` and `campaign show` are also an `ls` and a `show` that fish has seen, +# and their arguments are not what these complete. +function __worklane_first_arg_of + set -l tokens (commandline -opc) + test (count $tokens) -eq 2; and contains -- $tokens[2] $argv +end + +function __worklane_second_arg_of + set -l tokens (commandline -opc) + test (count $tokens) -eq 3; and contains -- $tokens[2] $argv +end + +# No `-d`: `ls --ids` prints the id and the title separated by a tab, which is fish's +# own form for a candidate and its description, so every ticket carries its own. +complete -c worklane \ + -n '__worklane_first_arg_of {ticket_commands}; or __worklane_second_arg_of {ticket_second_commands}' \ + -a '(worklane ls --ids)' + +# `relate` takes its targets as option values, so they are completed by flag rather +# than by position. +complete -c worklane {ticket_flags} -x -a '(worklane ls --ids)' + +# clap emits the four for `mv --status`, which is an option, but the fish generator +# emits nothing for the possible values of a positional. So the one place a status is +# positional needs them listed, and the same goes for the shell below. +complete -c worklane -n '__worklane_first_arg_of ls' -a '{statuses}' -d status +complete -c worklane -n '__worklane_first_arg_of completions' -a '{shells}' -d shell + +# Shipped with the binary, so this list comes from `install::SKILLS` and cannot fall +# behind it. +complete -c worklane -n '__worklane_first_arg_of install-skill' -a '{skills}' -d skill +"# + ) +} + +/// The names a `ValueEnum` accepts, for a fish `-a` list. +/// +/// Read off the enum rather than written out, so a status or a shell added to either one +/// is offered without anybody remembering this file. A variant marked hidden is left out, +/// which is what `to_possible_value` returning `None` means. +fn possible_values(variants: &[T]) -> String { + variants + .iter() + .filter_map(|variant| variant.to_possible_value()) + .map(|value| value.get_name().to_string()) + .collect::>() + .join(" ") +} + +#[cfg(test)] +mod tests { + use super::*; + + /// Built, not just derived: an index is assigned when the command is built, and the + /// positionals of an unbuilt one all report `None`. + fn command() -> clap::Command { + let mut cli = crate::command::Cli::command(); + cli.build(); + cli + } + + /// Every subcommand that takes a ticket must be listed, at the position it takes it, + /// or it silently loses completion. + /// + /// The nested subcommands are not walked. `campaign` is the only one, none of its + /// three takes a ticket, and the token counting above could not tell them apart if + /// one did. A ticket argument added under `campaign` needs the fish block reworked, + /// not another name in a list. + #[test] + fn no_ticket_taking_subcommand_is_missing() { + for subcommand in command().get_subcommands() { + let name = subcommand.get_name(); + for positional in subcommand.get_positionals() { + // `show` calls it `id`; everything else calls it `ticket`. + if !matches!(positional.get_id().as_str(), "ticket" | "id") { + continue; + } + match positional.get_index() { + Some(1) => assert!( + TICKET_COMMANDS.contains(&name), + "`worklane {name}` takes a ticket first but is not in TICKET_COMMANDS" + ), + Some(2) => assert!( + TICKET_SECOND_COMMANDS.contains(&name), + "`worklane {name}` takes a ticket second but is not in \ + TICKET_SECOND_COMMANDS" + ), + index => panic!("`worklane {name}` takes a ticket at position {index:?}"), + } + } + } + } + + #[test] + fn every_listed_command_is_a_real_subcommand() { + let cli = command(); + let known: Vec<&str> = cli.get_subcommands().map(|c| c.get_name()).collect(); + for name in TICKET_COMMANDS.iter().chain(TICKET_SECOND_COMMANDS.iter()) { + assert!(known.contains(name), "no such subcommand: {name}"); + } + } + + /// The flags completed as tickets have to be `relate`'s actual flags, or the rule + /// completes an option nothing accepts. + #[test] + fn every_ticket_flag_is_a_real_option() { + let relate = command() + .find_subcommand("relate") + .expect("relate exists") + .clone(); + let known: Vec = relate + .get_arguments() + .filter_map(|arg| arg.get_long().map(str::to_string)) + .collect(); + for flag in TICKET_FLAGS { + assert!( + known.contains(&flag.to_string()), + "`relate` has no --{flag}" + ); + } + } + + #[test] + fn the_fish_script_asks_worklane_for_its_tickets() { + let script = fish_dynamic(); + assert!(script.contains("worklane ls --ids")); + // Both positions, in one rule. + assert!(script.contains("__worklane_first_arg_of show")); + assert!(script.contains("__worklane_second_arg_of chown assign")); + // Nothing here takes a file, bar the one that does. + assert!(script.contains("complete -c worklane -f\n")); + assert!(script.contains("__fish_complete_directories")); + // Generated from `install::SKILLS`, so every shipped skill is in it. + assert!(script.contains("worklane-review")); + } + + /// The one status positional and the one shell positional, which clap does not emit + /// possible values for. Read off the enums, so a fifth status would appear here on + /// its own. + #[test] + fn the_fish_script_lists_the_statuses_and_the_shells() { + let script = fish_dynamic(); + for status in Status::ALL { + assert!( + script.contains(status.as_str()), + "the ls positional is never offered {}", + status.as_str() + ); + } + assert!(script.contains("-a 'backlog committed reviewing done' -d status")); + for shell in ["fish", "bash", "zsh", "elvish", "powershell"] { + assert!(script.contains(shell), "the shell positional is never offered {shell}"); + } + } + + /// The four for `mv --status` are clap's, which is half of why `Status` is a + /// `ValueEnum`. If clap ever stops emitting them, the fish half has to carry them + /// too, and this is what says so. + #[test] + fn clap_emits_the_statuses_for_the_status_flag() { + let mut out = Vec::new(); + generate(Shell::Fish, &mut out).expect("generates"); + let script = String::from_utf8(out).expect("utf8"); + let flag = script + .lines() + .find(|line| line.contains("using_subcommand mv") && line.contains("-l status")) + .expect("mv --status has a rule of its own"); + assert!(flag.contains("backlog"), "{flag}"); + } + + #[test] + fn generating_fish_produces_both_halves() { + let mut out = Vec::new(); + generate(Shell::Fish, &mut out).expect("generates"); + let script = String::from_utf8(out).expect("utf8"); + // clap's half. + assert!(script.contains("complete -c worklane")); + assert!(script.contains("install-skill")); + // Ours. + assert!(script.contains("__worklane_first_arg_of")); + } + + #[test] + fn other_shells_get_only_the_generated_half() { + for shell in [Shell::Bash, Shell::Zsh] { + let mut out = Vec::new(); + generate(shell, &mut out).expect("generates"); + let script = String::from_utf8(out).expect("utf8"); + assert!( + !script.contains("__worklane_first_arg_of"), + "fish-only helpers leaked into {shell}" + ); + } + } +} diff --git a/src/handlers.rs b/src/handlers.rs index ce3aec2..deb330b 100644 --- a/src/handlers.rs +++ b/src/handlers.rs @@ -5,7 +5,9 @@ use std::io::{BufRead, IsTerminal, Write}; use std::path::Path; use crate::campaign::*; -use crate::command::{AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, RelateArgs, SetArgs}; +use crate::command::{ + AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, LsArgs, RelateArgs, SetArgs, +}; use crate::install; use crate::util::*; @@ -23,8 +25,7 @@ pub fn cmd_init(start: &Path) -> Result<()> { fs::create_dir_all(&worklane_dir)?; - let folders = ["backlog", "committed", "reviewing", "done"]; - for folder in &folders { + for folder in status_dirs() { fs::create_dir_all(worklane_dir.join(folder))?; } @@ -37,21 +38,22 @@ pub fn cmd_init(start: &Path) -> Result<()> { Ok(()) } -pub fn cmd_ls( - status_filter: &Option, - priority_filter: Option, - tag_filter: &Option, - campaign_filter: &Option, - worklane_dir: &Path, -) -> Result<()> { +pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> { // Resolved before anything is read, so an unknown campaign is refused rather than - // silently listing nothing, and the name is available for the heading. - let campaign = match campaign_filter { + // silently listing nothing, and the name is available for the heading. Ahead of the + // `--ids` branch too: a completion that quietly listed the whole board because the + // campaign was misspelled would be worse than one that printed nothing. + let campaign = match &args.campaign { Some(search) => Some(resolve_campaign(search, worklane_dir)?), None => None, }; let uuid = campaign.as_ref().map(|campaign| campaign.uuid.as_str()); - let tag = tag_filter.as_deref(); + let tag = args.tag.as_deref(); + let priority_filter = args.priority; + + if args.ids { + return list_ids(args.status, priority_filter, uuid, tag, worklane_dir); + } if let Some(campaign) = &campaign { println!( @@ -61,12 +63,18 @@ pub fn cmd_ls( ); } - if let Some(status) = status_filter { + if let Some(status) = args.status { + let status = status.as_str(); let status_path = worklane_dir.join(status); if !status_path.exists() { + // The status itself is clap's to reject now, so reaching here means the + // board is missing a directory it should have rather than that the name was + // mistyped. `init` will not repair it: it leaves an existing `.worklane` + // alone. return Err(anyhow!( - "Status '{}' not found. Valid statuses: backlog, committed, reviewing, done", - status + "No '{}' directory in {}. Every board has all four; creating it is enough.", + status, + worklane_dir.display() )); } @@ -119,6 +127,47 @@ pub fn cmd_ls( Ok(()) } +/// The machine-readable listing: one ticket per line, its short id then its title, +/// separated by a tab and unstyled. +/// +/// Two fields rather than the id alone because both readers want both. Fish takes what +/// follows the tab as the description, which is what makes `worklane show ` a list +/// of titles rather than of hex, and a script takes the id back out with `cut -f1`. The +/// id is the same seven characters the listing prints, which is what a ticket is +/// addressed by. +/// +/// Every status, done included, where the listing above leaves done out. A completion has +/// to be able to name a finished ticket, since `show` and `comment` are most often +/// pointed at one, and the status positional still narrows it. +/// +/// A missing status directory is skipped rather than refused, which is the one place this +/// parts company with the listing. The caller is usually a shell filling in a candidate +/// list, and an error printed over the prompt is worse there than no candidates. +fn list_ids( + status: Option, + level: Option, + campaign: Option<&str>, + tag: Option<&str>, + worklane_dir: &Path, +) -> Result<()> { + let statuses = match status { + Some(status) => vec![status.as_str()], + None => status_dirs(), + }; + + for status in statuses { + let status_path = worklane_dir.join(status); + if !status_path.exists() { + continue; + } + for item in filtered(collect_ticket_items(&status_path)?, level, campaign, tag) { + println!("{}\t{}", item.id, item.title); + } + } + + Ok(()) +} + /// The listing filters in one call, so the three places `ls` collects a column cannot /// end up applying a different set of them. /// @@ -562,29 +611,20 @@ fn check_blockers(worklane_dir: &Path, content: &str, title: &str) -> Result<()> )) } -pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -> Result<()> { - let valid_statuses = ["backlog", "committed", "reviewing", "done"]; - let forward_order = ["backlog", "committed", "reviewing", "done"]; - - if !valid_statuses.contains(&target_status) { - return Err(anyhow!( - "Invalid target status '{}'. Valid statuses: {}", - target_status, - valid_statuses.join(", ") - )); - } +/// A status is a [`Status`] rather than a string, so an unknown one is clap's to refuse +/// and nothing here has to check. What is left is the order of the flow, which is +/// `Status::ALL`. +pub fn cmd_mv(ticket_id: &str, target: Status, force: bool, start: &Path) -> Result<()> { + let target_status = target.as_str(); let worklane_dir = find_worklane_dir(start)?; let (current_status, title, resolved) = resolve_ticket(ticket_id, &worklane_dir)?; - let current_idx = forward_order + let current_idx = Status::ALL .iter() - .position(|&s| s == current_status) - .unwrap(); - let target_idx = forward_order - .iter() - .position(|&s| s == target_status) + .position(|status| status.as_str() == current_status) .unwrap(); + let target_idx = Status::ALL.iter().position(|status| *status == target).unwrap(); if !force && target_idx < current_idx { return Err(anyhow!( diff --git a/src/main.rs b/src/main.rs index e9511a9..8abcf33 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,6 +4,7 @@ use clap::Parser; mod campaign; mod clipboard; mod command; +mod completions; mod handlers; mod install; mod tui; @@ -46,14 +47,9 @@ fn main() -> Result<()> { 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, - }) => { + Some(Command::Ls(args)) => { let worklane_dir = find_worklane_dir(&start)?; - cmd_ls(&status, priority, &tag, &campaign, &worklane_dir) + cmd_ls(&args, &worklane_dir) } Some(Command::Show { id }) => { let worklane_dir = find_worklane_dir(&start)?; @@ -63,7 +59,7 @@ fn main() -> Result<()> { ticket, status, force, - }) => cmd_mv(&ticket, &status, force, &start), + }) => 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), @@ -87,6 +83,11 @@ fn main() -> Result<()> { } }, Some(Command::Assign { campaign, ticket }) => cmd_assign(&campaign, &ticket, &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 }) => { diff --git a/src/util.rs b/src/util.rs index 2107b76..82fa77b 100644 --- a/src/util.rs +++ b/src/util.rs @@ -2162,8 +2162,48 @@ pub fn trim_blank_ends(values: &[String]) -> &[String] { } } +/// A status, as clap accepts it and as the directory is named. +/// +/// An enum rather than the string it was, so an unknown status is a usage error at parse +/// time with the four listed, the way `priority_level` and `iso_date` refuse a bad level +/// or date. That is the bargain the scalars already take, see AGENTS.md: nothing is +/// written, the exit code is 2, and no handler has to check. It also gives every shell +/// that completes possible values the four names for free. +/// +/// The variants are in flow order, which is the order `mv` reads to decide whether a +/// move goes forward, and the order [`status_dirs`] hands the two views. +#[derive(Debug, Clone, Copy, PartialEq, Eq, clap::ValueEnum)] +pub enum Status { + Backlog, + Committed, + Reviewing, + Done, +} + +impl Status { + /// Every status, in flow order. The one list, which [`status_dirs`] and `mv` both + /// read rather than spelling the four names again. + pub const ALL: [Status; 4] = [ + Status::Backlog, + Status::Committed, + Status::Reviewing, + Status::Done, + ]; + + /// The directory name, which is also what clap accepts and what the `Status` field + /// holds. A `const fn` so [`DONE`] can be defined from it. + pub const fn as_str(self) -> &'static str { + match self { + Status::Backlog => "backlog", + Status::Committed => "committed", + Status::Reviewing => "reviewing", + Status::Done => "done", + } + } +} + pub fn status_dirs() -> Vec<&'static str> { - vec!["backlog", "committed", "reviewing", DONE] + Status::ALL.iter().map(|status| status.as_str()).collect() } /// The end of the flow, and the one status both views treat differently: `ls` counts it @@ -2173,7 +2213,7 @@ pub fn status_dirs() -> Vec<&'static str> { /// It is deliberately last in `status_dirs()`. The board leans on that: hiding done drops /// the final column, so the other three keep their indices and the selection only has to /// be handled when it is sitting on done itself. -pub const DONE: &str = "done"; +pub const DONE: &str = Status::Done.as_str(); /// Lowest and highest level a ticket can carry. 1 is the most urgent, which is /// what the `p1` to `p3` tags this replaced already meant. diff --git a/tests/cmd_completions.rs b/tests/cmd_completions.rs new file mode 100644 index 0000000..086291b --- /dev/null +++ b/tests/cmd_completions.rs @@ -0,0 +1,83 @@ +use assert_cmd::Command; + +const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane"); + +fn script(shell: &str) -> String { + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + let assert = cmd.arg("completions").arg(shell).assert().success(); + String::from_utf8(assert.get_output().stdout.clone()).unwrap() +} + +/// Every shell clap can generate for, since the README names all five. +#[test] +fn completions_prints_a_script_for_every_shell() { + for shell in ["fish", "bash", "zsh", "elvish", "powershell"] { + let out = script(shell); + assert!( + out.contains("worklane"), + "the {shell} script never names the command" + ); + // Long enough to be a script rather than an empty file with a comment in it. + assert!(out.len() > 500, "the {shell} script is {} bytes", out.len()); + } +} + +/// No board is looked for, the way `install-skill` looks for none: the script comes off +/// the clap definition and is the same wherever it is run. Run from a temp directory +/// with no `.worklane` above it, which every other command refuses. +#[test] +fn completions_needs_no_board() { + let temp = assert_fs::TempDir::new().unwrap(); + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + cmd.current_dir(temp.path()) + .arg("completions") + .arg("fish") + .assert() + .success(); +} + +#[test] +fn fish_gets_both_halves() { + let out = script("fish"); + // clap's, which is where the subcommands and the flags come from. + assert!(out.contains("__fish_worklane_needs_command")); + assert!(out.contains("install-skill")); + // Ours, which is where the tickets come from. + assert!(out.contains("__worklane_first_arg_of")); + assert!(out.contains("worklane ls --ids")); +} + +/// The fish half is fish syntax, so it must not reach any other shell's output. +#[test] +fn no_other_shell_gets_the_fish_half() { + for shell in ["bash", "zsh", "elvish", "powershell"] { + let out = script(shell); + assert!( + !out.contains("__worklane_first_arg_of"), + "fish-only helpers leaked into {shell}" + ); + assert!( + !out.contains("worklane ls --ids"), + "the dynamic half leaked into {shell}" + ); + } +} + +/// The four statuses reach fish twice over, from clap for the `mv` option and from the +/// appended half for the `ls` positional, which clap emits nothing for. +#[test] +fn fish_is_offered_every_status() { + let out = script("fish"); + for status in ["backlog", "committed", "reviewing", "done"] { + assert!(out.contains(status), "fish is never offered {status}"); + } + assert!(out.contains("-a 'backlog committed reviewing done' -d status")); +} + +#[test] +fn an_unknown_shell_is_a_usage_error() { + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + let assert = cmd.arg("completions").arg("tcsh").assert().code(2); + let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap(); + assert!(stderr.contains("invalid value 'tcsh'"), "{stderr}"); +} diff --git a/tests/cmd_ls.rs b/tests/cmd_ls.rs index 5b1c13e..4ce79ed 100644 --- a/tests/cmd_ls.rs +++ b/tests/cmd_ls.rs @@ -470,3 +470,195 @@ fn ls_with_a_tag_nothing_carries_lists_nothing() { assert!(stdout.contains("[BACKLOG] 0 tickets"), "{stdout}"); assert!(!stdout.contains("Tagged bug"), "{stdout}"); } + +/// A ticket with an id of its own, since `create_ticket` gives every fixture the same +/// uuid and `--ids` is the one output where the id is the whole point. +fn create_ticket_with_id( + worklane_dir: &std::path::Path, + status: &str, + title: &str, + uuid: &str, + tags: &str, +) { + let ticket_body = format!( + "# {title}\n\n## Metadata\n\n- **ID**: {uuid}\n- **Tags**: {tags}\n- **Owner**: alice\n- **Status**: {status}\n" + ); + let filename = format!("{uuid}_{}.md", slug(title)); + fs::write(worklane_dir.join(status).join(filename), ticket_body).unwrap(); +} + +/// The slug rule, as AGENTS.md requires: derived, never written by hand. +fn slug(title: &str) -> String { + title + .to_lowercase() + .chars() + .filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_') + .map(|c| if c == ' ' { '-' } else { c }) + .collect() +} + +/// One ticket per line, the seven-character id then a tab then the title, and nothing +/// else: no heading, no counts, no owner or due column. +#[test] +fn ls_ids_prints_the_id_and_the_title_and_nothing_else() { + let temp = TempDir::new().unwrap(); + let worklane = setup_worklane(&temp); + + create_ticket_with_id( + &worklane, + "backlog", + "Feature A", + "1b78a24c-0000-0000-0000-000000000001", + "bug", + ); + + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + cmd.current_dir(temp.path()).args(["ls", "--ids"]); + cmd.assert().success(); + + let stdout = get_stdout(&mut cmd); + assert_eq!(stdout, "1b78a24\tFeature A\n", "{stdout:?}"); +} + +/// Every status, done included, where the decorated listing leaves done out. A +/// completion has to be able to name a finished ticket. +#[test] +fn ls_ids_includes_done_and_narrows_to_a_named_status() { + let temp = TempDir::new().unwrap(); + let worklane = setup_worklane(&temp); + + create_ticket_with_id( + &worklane, + "backlog", + "Still open", + "aaaaaaa1-0000-0000-0000-000000000001", + "bug", + ); + create_ticket_with_id( + &worklane, + "done", + "Finished", + "bbbbbbb2-0000-0000-0000-000000000002", + "bug", + ); + + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + cmd.current_dir(temp.path()).args(["ls", "--ids"]); + let stdout = get_stdout(&mut cmd); + assert!(stdout.contains("Still open"), "{stdout}"); + assert!(stdout.contains("Finished"), "a done ticket cannot be named: {stdout}"); + + // The decorated listing is unchanged: done is counted, not listed. + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + cmd.current_dir(temp.path()).arg("ls"); + let stdout = get_stdout(&mut cmd); + assert!(!stdout.contains("Finished"), "{stdout}"); + + // The positional still narrows it. + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + cmd.current_dir(temp.path()).args(["ls", "done", "--ids"]); + let stdout = get_stdout(&mut cmd); + assert_eq!(stdout, "bbbbbbb\tFinished\n", "{stdout:?}"); +} + +/// The filters apply to `--ids` exactly as they do to the listing, so a completion can +/// be narrowed the same way. +#[test] +fn ls_ids_still_takes_the_filters() { + let temp = TempDir::new().unwrap(); + let worklane = setup_worklane(&temp); + + create_ticket_with_id( + &worklane, + "backlog", + "Tagged bug", + "aaaaaaa1-0000-0000-0000-000000000001", + "bug", + ); + create_ticket_with_id( + &worklane, + "backlog", + "Tagged cli", + "bbbbbbb2-0000-0000-0000-000000000002", + "cli", + ); + + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + cmd.current_dir(temp.path()).args(["ls", "--ids", "--tag", "cli"]); + let stdout = get_stdout(&mut cmd); + assert_eq!(stdout, "bbbbbbb\tTagged cli\n", "{stdout:?}"); +} + +/// An unknown campaign is refused before anything is read, even here. A completion that +/// listed the whole board because the name was misspelled would be worse than one that +/// printed nothing. +#[test] +fn ls_ids_still_refuses_an_unknown_campaign() { + let temp = TempDir::new().unwrap(); + let worklane = setup_worklane(&temp); + + create_ticket_with_id( + &worklane, + "backlog", + "Feature A", + "aaaaaaa1-0000-0000-0000-000000000001", + "bug", + ); + + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + cmd.current_dir(temp.path()) + .args(["ls", "--ids", "--campaign", "no such campaign"]); + cmd.assert().failure(); +} + +/// A status the board is missing is skipped rather than refused, unlike the listing: +/// the caller is a shell filling in candidates, and an error printed over the prompt is +/// worse there than no candidates. +#[test] +fn ls_ids_is_quiet_about_a_missing_status_directory() { + let temp = TempDir::new().unwrap(); + let worklane = temp.child(".worklane"); + worklane.create_dir_all().unwrap(); + worklane.child("backlog").create_dir_all().unwrap(); + + create_ticket_with_id( + worklane.path(), + "backlog", + "Feature A", + "aaaaaaa1-0000-0000-0000-000000000001", + "bug", + ); + + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + cmd.current_dir(temp.path()).args(["ls", "--ids"]); + cmd.assert().success(); + let stdout = get_stdout(&mut cmd); + assert_eq!(stdout, "aaaaaaa\tFeature A\n", "{stdout:?}"); + + // The listing still says so, since a person reading it can act on it. + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + cmd.current_dir(temp.path()).args(["ls", "done"]); + let assert = cmd.assert().failure(); + let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap(); + assert!(stderr.contains("No 'done' directory"), "{stderr}"); +} + +/// A status outside the four is clap's to refuse now, so it is a usage error naming the +/// four rather than a runtime one. +#[test] +fn ls_names_the_four_statuses_when_given_another() { + let temp = TempDir::new().unwrap(); + setup_worklane(&temp); + + let mut cmd = Command::cargo_bin(BIN_NAME).unwrap(); + let assert = cmd + .current_dir(temp.path()) + .args(["ls", "nonexistent"]) + .assert() + .code(2); + let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap(); + assert!(stderr.contains("invalid value 'nonexistent'"), "{stderr}"); + for status in ["backlog", "committed", "reviewing", "done"] { + assert!(stderr.contains(status), "{status} is not offered: {stderr}"); + } +} diff --git a/tests/cmd_mv.rs b/tests/cmd_mv.rs index 4b57ff1..6390f8f 100644 --- a/tests/cmd_mv.rs +++ b/tests/cmd_mv.rs @@ -277,13 +277,16 @@ fn mv_ignores_already_in_same_status() { assert!(worklane.join("reviewing").join(&filename).exists()); } +/// A status is a value enum, so an unknown one is clap's to refuse: exit 2, the four +/// named, and the ticket untouched. The same bargain `--due` and `--priority` take, and +/// the reason `cmd_mv` no longer checks. #[test] fn mv_rejects_invalid_status() { let temp = TempDir::new().unwrap(); let worklane = setup_worklane(&temp); let id = "abc123def456789012345678901234567890"; - let _filename = create_ticket( + let filename = create_ticket( &worklane, "backlog", "Invalid Target", @@ -301,10 +304,17 @@ fn mv_rejects_invalid_status() { .arg("--status") .arg("invalid") .assert() - .failure(); + .code(2); let stderr = get_stderr(&mut cmd); - assert!(stderr.contains("Invalid target status")); + assert!(stderr.contains("invalid value 'invalid'"), "{stderr}"); + for status in ["backlog", "committed", "reviewing", "done"] { + assert!(stderr.contains(status), "{status} is not offered: {stderr}"); + } + assert!( + worklane.join("backlog").join(&filename).exists(), + "the ticket moved anyway" + ); } #[test]