Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
3892afe819 | ||
|
|
c81838efc6 | ||
|
|
cd7c99fe39 | ||
|
|
b63b60eefc | ||
|
|
7470255a22 | ||
|
|
b4534eb86d | ||
|
|
96cddc14ad | ||
|
|
f16e2aba0c | ||
|
|
bf7d8e05d8 | ||
|
|
30a2b3429e | ||
|
|
69bc2feef5 | ||
|
|
8675f22209 | ||
|
|
f183d4635a | ||
|
|
668263605c |
@@ -1,7 +1,7 @@
|
||||
# AGENTS.md
|
||||
|
||||
## Project Structure
|
||||
- `src/main.rs` - dispatch, the SIGPIPE reset, and the TUI event loop
|
||||
- `src/main.rs` - `dispatch`, the one mapping from a parsed command to its handler, 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
|
||||
@@ -9,6 +9,7 @@
|
||||
- `src/campaign.rs` - the campaign file format, its resolution, its index and its members
|
||||
- `src/history.rs` - the history log: the path, the kinds, the reader, the writer, the card's counter and the block `show` and the board both render
|
||||
- `src/tui.rs` - board state, the change digest, and the ratatui draw
|
||||
- `src/split.rs` - one pure function turning a typed line into arguments the way a shell does, plus what the half-typed line is still inside and where the cursor sits among them
|
||||
- `src/clipboard.rs` - the OSC 52 write and the base64 it carries, the board's only way out to the clipboard
|
||||
- `src/install.rs` - the embedded agent assets and the compare-and-refuse install
|
||||
- `assets/SKILL.md` - the agent skill for the CLI itself, embedded with `include_str!`
|
||||
@@ -28,7 +29,7 @@
|
||||
- Metadata fields parsed by `parse_ticket_field()`: `ID`, `Priority`, `Tags`, `Due`, `Owner`, `Created At`, `Committed On`, `Submitted On`, `Completed On`, `Discarded On`, `Campaign`, `Status`. The last five are the ones no ticket is born with: `add` writes none of them, so they are inserted on demand, against `METADATA_ORDER`, which is also what keeps `Status` last
|
||||
- The four stamps are `mv`'s, written by `set_status_stamp` from `Status::stamp_field`, and they **accumulate**: entering a status writes its field, re-entering restamps, and arriving anywhere removes the fields of every status *after* the target. One arrival rule keyed off `Status::ALL`, not a case per move, which is why a backward move truncates the journey at the target (`done` back to `reviewing` drops `Completed On`, anything back to `backlog` drops all three) and a forward skip under `-f` stamps only where it lands rather than fabricating the stages it jumped. A ticket that walks the whole flow ends with `Created At`, `Committed On`, `Submitted On` and `Completed On` side by side, so presence means *got this far and has not been sent back past it*, not *is here now* — `Status` is what says where it is. Not the history log either: these answer how far and when, once per stage, and every change along the way is the log's. `backlog` has no stamp, `Created At` already answers for it
|
||||
- **`Discarded` is last in `Status::ALL`, and that placement is what makes the stamp rule fall out right.** Nothing sits after it, so a discard clears nothing: a ticket abandoned from reviewing keeps `Committed On` and `Submitted On`, and the file still says how far it got before it was dropped. It also makes every move out of discarded a backward move, so un-discarding needs `-f` without a rule of its own. `Discarded On` is its stamp, and `Completed On` stays untouched, because a discarded ticket was never done
|
||||
- **Each status column is ordered by its own entry stamp, through `by_status_order`.** Priority is the clock in the backlog and that column keeps priority then title; past it the question changes, so committed sorts by `Committed On` ascending, reviewing by `Submitted On` ascending, and done and discarded by their stamp descending. Said once: the head of every column is what the reader acts on next. An unstamped ticket sinks below every stamped one in its column, because a missing time is unknown rather than ancient and unknown must not claim the head of a queue; equal stamps and both-unstamped fall through to `by_priority_then_title`. One function keyed on the `Status`, taken by both `cmd_ls` branches, `list_ids`, `columns_of` and `campaign::members`, which is why those loops walk `Status::ALL` rather than `status_dirs()`. The stamps are read in `collect_ticket_items`' existing pass, the rule `criteria` and `tags` already hold, and compared as strings: `%Y-%m-%d %H:%M:%S` is lexicographic in chronological order, the property `Due` already relies on, so nothing parses a date at sort time
|
||||
- **Each status column is ordered by its own date, through `by_status_order`.** Past the backlog that date is the entry stamp, so committed sorts by `Committed On` ascending, reviewing by `Submitted On` ascending, and done and discarded by their stamp descending. The backlog has no stamp of its own, so it sorts by `Due` ascending, through `TicketItem::due_key`. Said once: the head of every column is what the reader acts on next, and in the backlog that is the nearest deadline rather than the loudest priority — priority alone sat a p1 nobody had promised above a p3 due tomorrow. A ticket carrying no date sinks below every dated one in its column, because a missing time is unknown rather than ancient and unknown must not claim the head of a queue; equal dates and both-undated fall through to `by_priority_then_title`, which is still the whole order among undated backlog tickets. One function keyed on the `Status`, taken by both `cmd_ls` branches, `list_ids`, `columns_of` and `campaign::members`, which is why those loops walk `Status::ALL` rather than `status_dirs()`. The dates are read in `collect_ticket_items`' existing pass, the rule `criteria` and `tags` already hold, and compared as strings: `%Y-%m-%d %H:%M:%S` and `%Y-%m-%d` are both lexicographic in chronological order, so nothing parses a date at sort time. `due_key` answers `None` for a `Due` that is not a plain `YYYY-MM-DD` after `due_date` has cut a legacy datetime back — free text is unknown, not a date, and sorting on its spelling would rank it against real deadlines
|
||||
- Format: `**Field Name**: value`
|
||||
- Ticket structure: `# Title` → `## Description` → `## Acceptance Criteria` → `## Implementation Plan` → `## Metadata`
|
||||
- A **campaign** file carries `ID`, `Codename`, `Owner` and `Created At`, in that order, and no `Status`. `Codename` sits directly under the ID because that is what it is, a second way to say which campaign this is; it is written by `campaign add --codename` alone and is `_Not set_` when the flag was not given. It is not in `METADATA_ORDER`, which is the anchor list for the *upsert* on a ticket, and nothing upserts a campaign
|
||||
@@ -52,7 +53,8 @@ repo. Do not restate any of it in this file: a second copy is a copy that goes s
|
||||
and this file is for what someone changing worklane's own code needs.
|
||||
|
||||
## Testing
|
||||
- Run: `cargo test`
|
||||
- **Run `make check` before committing**: `cargo fmt --check`, then `cargo clippy --all-targets -- -D warnings`, then `cargo test`, cheapest first. That is the whole of the enforcement, and it is deliberate rather than a stopgap: this repo has no CI and does not want any, and a git hook is a per-clone opt-in the way `blame.ignoreRevsFile` is, so neither can be relied on. What was missing was one name to type, so the two rules below are a command and not a memory. `-D warnings` is what makes clippy's opinion an exit code; a warning printed into a wall of cargo output is unread, not clean. The completion checks are inside `cargo test` rather than a target of their own, since a second thing to remember is the problem this solves
|
||||
- Run one suite: `cargo test`
|
||||
- Tests use `assert_cmd` and `assert_fs` for CLI testing
|
||||
- `setup_worklane()` creates temp `.worklane/` with the four flow status folders pre-created, plus `campaigns/` in `cmd_campaign.rs`, which is also where the on-demand creation is tested from a board without it. **The fixtures deliberately do not create `discarded/`**, so every discard test runs against a board that predates the status and `mv_creates_the_discarded_directory_on_a_board_that_predates_it` is not the only thing exercising the on-demand creation
|
||||
- `create_ticket()` writes fully-formed markdown files directly (no `--` separator for positional args in test commands)
|
||||
@@ -61,8 +63,8 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **`WORKLANE_KEEP_FIXTURES=1 cargo test` keeps the fixtures and prints each path.** Opt-in rather than kept-automatically-on-failure, because the assertions here carry the state they are about: a failing board test prints the rendered rows. The flag is read once when a fixture is made rather than at drop time, so the answer cannot change mid-test, and `Fixture::swept()` turns it off for the three tests that are about the guard itself and must not be failed by a reader's environment
|
||||
- **Verify a claim about leaked fixtures against a clean temp dir, not against `/tmp`.** `TMPDIR=/tmp/scratch cargo test` then count what is left in it: `/tmp` still holds the historical leak, so counting there measures the past rather than the change
|
||||
- In `tui.rs`, `write_member_card` is `write_tagged_card` plus a Campaign field and `write_campaign` puts a campaign on disk, creating the campaigns directory as it goes — `board_dir()` deliberately does not, so every test that does not write one is also the test that a board with no campaigns draws. `picker_rows` cuts the picker's list out of the frame by its own geometry, for the reason `overlay_title_row` exists: a card carries the same campaign label, so a search over every row finds the board rather than the list
|
||||
- **`cargo clippy --all-targets` is clean. Keep it clean**, and do not silence a lint that is pointing at something real. The only two `allow`s in the tree sit on the `create_ticket` fixtures in `cmd_mv.rs` and `cmd_show.rs`, each carrying the reason and what would replace it
|
||||
- **`cargo fmt --check` is clean too, and `rustfmt.toml` is what makes that affordable.** rustfmt is the formatter here, run it. The config is four stable width settings and nothing else:
|
||||
- **`cargo clippy --all-targets` is clean, and `make check` is what says so. Keep it clean**, and do not silence a lint that is pointing at something real. The only two `allow`s in the tree sit on the `create_ticket` fixtures in `cmd_mv.rs` and `cmd_show.rs`, each carrying the reason and what would replace it
|
||||
- **`cargo fmt --check` is clean too, `make check` runs it first, and `rustfmt.toml` is what makes that affordable.** rustfmt is the formatter here, run it. The config is four stable width settings and nothing else:
|
||||
|
||||
| setting | value | why |
|
||||
|---|---|---|
|
||||
@@ -95,7 +97,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **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 the clearing message rather than the date message. Somebody typing it is reaching for a way to clear the field, and the useful answer is the flag that does it
|
||||
- **`campaign add --codename` is validated at parse time by `codename`**, which is `non_empty` plus one word. The board draws it as a label with a mark and no quoting, so `~beaver release` on that row reads as two labels and the second one is not a campaign; a title is where a sentence goes. Nothing else is checked: there is no registry of codenames, the same reason `ls --tag` refuses to validate a tag, and a length limit would be a number invented in the parser when the row that draws it already drops a label it cannot hold
|
||||
- **There are two empty-value parsers, and which one an argument takes is the point.** `non_empty` says only that the value cannot be empty, for the arguments with no empty form: the `ls` filters, `relate`'s targets, and `set --title`, which addresses the ticket and names its file. `clearable` names `--clear`, for the arguments whose field does have one: `set --tags`, `--due` through `iso_date`, and the `chown` user. One message for both would either lie about `ls --tag` or leave the useful half unsaid. `add --due` takes the second one because `iso_date` is shared, and the answer it points at is a command later rather than the omission that would do it now, which is close enough to be worth the shared parser
|
||||
- **There are two empty-value parsers, and which one an argument takes is the point.** `non_empty` says only that the value cannot be empty, for the arguments with no empty form: the `ls` filters, `relate`'s targets, and `set --title`, which addresses the ticket and names its file. `clearable` names `--clear`, for the arguments whose field does have one: `set --tags`, `--due` through `iso_date`, and the `chown` user. One message for both would either lie about `ls --tag` or leave the useful half unsaid. `add --due` takes the second one because `iso_date` is shared, and the answer it points at is a command later rather than the omission that would do it now, which is close enough to be worth the shared parser. **`append --tags` is the one place the field has an empty form and the argument still takes `non_empty`**: `append` has no `--clear` of its own, so naming one would send the caller looking on this command for a flag that is `set`'s
|
||||
- **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 <id>`, `mv <ticket>`, `comment <ticket>`) 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 <ticket> -- --`. Without it the body is reported missing and nothing is written, which is a clear failure rather than a silent drop
|
||||
@@ -110,8 +112,12 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **What clap does and does not emit.** It emits the possible values of an *option*, which is why `mv --status <TAB>` 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.** The four `__worklane_*` predicates all read `$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. `first_arg_of` and `second_arg_of` count a top-level command's arguments, `nested_arg_of` matches a parent and a child so `campaign show <TAB>` can be told from `chown alice <TAB>`, which sit at the same token count, and `command_is` asks only which command this is, at any position in it
|
||||
- **Every rule carrying `-l` needs a `__worklane_command_is`, and `every_rule_naming_an_option_is_scoped_to_a_command` is what enforces it.** A bare `complete -c worklane -l tag` does not just complete that option's values, it tells fish the whole tool accepts `--tag`: `worklane init --<TAB>` offered six options that only `relate` and `ls` have. Fixed in 55ee6e3. `__fish_seen_subcommand_from ls` is not the scope to use, for the nesting reason above
|
||||
- **The five completion lists are kept honest by tests** that walk the clap definition and fail on an argument left out of them. `TICKET_COMMANDS` and `TICKET_SECOND_COMMANDS` by position, `TICKET_FLAGS`, `CAMPAIGN_COMMANDS`, `CAMPAIGN_NESTED_COMMANDS`, `CAMPAIGN_FLAGS` and `TAG_FLAGS` likewise. The walk is one function, `every_argument`, since the tests differ only in the id they look for. Each also asserts *how many* it found, so a walker that stopped finding arguments fails rather than passing every assertion by never running them
|
||||
- **The strongest completion check loads the script into fish and asks it for candidates.** `fish_offers_the_commands_the_statuses_and_the_values` in `tests/cmd_completions.rs` sources the generated script into a throwaway shell standing in a real board, with this build's directory on the front of PATH, and compares `complete -C` against the ticket and the tag it put there. Every other test in the file reads the script as text, which cannot tell a rule that fires from one whose condition stopped matching, and that is how a completion actually breaks. **Assert the values, not the flag names**: clap emits every option's name on its own, so `--tags` and `--blocked-by` are offered with every hand-written rule deleted; what the dynamic half adds is what comes *after* the flag. Two traps, both paid for once: the shell must have `fish_complete_path` emptied, or `complete -C` autoloads `~/.config/fish/completions/worklane.fish` and answers from whatever version wrote that, which is a guard that cannot fail; and the script is written beside the board rather than in it, since a rule that fires nothing falls back to listing the directory
|
||||
- **`fish --no-execute` is the floor under that, not an oracle.** It catches a script that does not parse, quotes still open at the end of the file or an unclosed block. Measured, not assumed: an apostrophe interpolated into a `-d` description partway down re-balances against the next quote and parses, corrupting every rule in between while the check passes; the same apostrophe in the last rule reaches the end unbalanced and is caught. Only fish gets this, because only fish gets a hand-written half
|
||||
- **The rule counts in the completion tests are hardcoded on purpose.** The walkers go clap → list and never see an entry naming something that does not exist, so a bogus pair in `TAG_FLAGS` is caught by `every_tag_rule_takes_the_annotation_as_its_description` counting one rule too many. Deriving that number from the lists it checks would grow with the bogus entry and pass. The `seen` totals in the walkers are hardcoded for the mirror reason, and both carry the note
|
||||
- **The five completion lists are kept honest by tests** that walk the clap definition and fail on an argument left out of them. `TICKET_COMMANDS` and `TICKET_SECOND_COMMANDS` by position, `TICKET_FLAGS`, `CAMPAIGN_COMMANDS`, `CAMPAIGN_NESTED_COMMANDS`, `CAMPAIGN_FLAGS` and `TAG_FLAGS` likewise, the last against the test-local `TAG_LIST_FLAGS` and `TAG_NEW_COMMANDS` for the tag arguments that deliberately get no rule. The walk is one function, `every_argument`, since the tests differ only in the id they look for. Each also asserts *how many* it found, so a walker that stopped finding arguments fails rather than passing every assertion by never running them
|
||||
- **A campaign is named in three shapes and a tag in one**, which is why the lists are not one list: a campaign is `assign`'s first positional, the first argument of `campaign show` and `campaign set`, and `ls --campaign`'s value, and each needs a different fish rule. A tag is only ever an option value, and its values come from a different command
|
||||
- **`TAG_FLAGS` holds pairs where the others hold names**, because the two options that take one tag are spelled differently: `ls --tag` filters on one and `append --tags` adds them, so a single rule naming both would tell fish that each command accepts the other's flag. One rule per pair, generated in `fish_dynamic`. `add --tags` and `set --tags` are in the test's `TAG_LIST_FLAGS` instead and get no rule: they take the *whole* list, so the token at the cursor is `bug,tui` and fish replaces a token entire, which would throw away what is already typed. The test walks both `tag` and `tags`, so the next one has to say which of the two it is
|
||||
- **`ls --ids` is the machine-readable listing**, and one of the three outputs 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
|
||||
- **`campaign ls --ids` is the same flag and the same two fields for the other object**, and it deliberately skips the member counting the decorated listing does: `members()` reads every ticket on the board, and the caller here is a shell filling in candidates on a keypress. It also prints nothing on an empty board, where the decorated listing prints a sentence, because a sentence offered as a candidate is worse than no candidates
|
||||
- **`worklane tags` is the third, and it is a command rather than a mode on `ls`.** Two reasons: `ls --tag <tag>` answers what carries a tag and cannot answer what tags exist, which is the question a grooming sweep starts from, and a `--tags` beside a `--tag` is one letter from a filter that means something else. Alphabetical and case sensitive, matching the filter, so `bug` and `Bug` list separately and land next to each other, which is where a near-duplicate is spotted. Every status, done included: a tag that has fallen out of use is still part of what the vocabulary has been. `assets/PLAN.md` used to tell the agent to count tags with a `show` per ticket, and now points here
|
||||
@@ -312,6 +318,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **A query turns the truncation off**, which is the point of having one: the campaign a reader is searching for is exactly the one the truncation hid
|
||||
- **The query is a layer, and `esc` takes it off before it takes the picker off**, the order `dismiss` closes the board's own layers in. So the list is whole again after that press, not still filtered with nothing on screen saying why. Movement and `enter` stay live under an open query, because a filtered list nothing can move in is a list nothing can be chosen from; every *printable* key goes into the buffer, so `q` types and so does `j`
|
||||
- **The highlight follows its row, not its row number.** `place_picker` takes a key — whichever answer `PickerRow::key` hands back, the same shape `Tab::filter` holds for any of them: typing, clearing the query and a tick that finishes a campaign all reshape the list, and a number kept across that names whichever campaign now sits at it. One the list no longer holds drops the highlight to the first row that does, which is where an incremental filter puts it. `reload` reads the highlighted key before the lists are rebuilt and puts it back after
|
||||
- **Both ends bring the highlight into the window.** Opening aligns against the screen the dispatch hands `open_picker`, and the draw follows the highlight again through `aligned_offset` on the geometry it is actually drawing — a resize between that keypress and the frame, or a tick that put the highlight back without touching the scroll, cannot leave it below the fold until some later keypress fixes it. The stored offset is left alone, the way a column's is: what is drawn is corrected immediately and the next navigation writes the correction back
|
||||
- **A miss is a row in the box, `no match` in brightred**, where the search prompt puts its own, and `enter` on it leaves the picker and the query exactly as they are so the query can be corrected in place. An empty box says nothing about why it is empty
|
||||
- **The picker's footer becomes its query**, the trade `draw_search` makes: with every printable key going into a buffer, a list of keys describes nothing that works. `/ search` is named only on the closed query, and the open one names what `esc` does to *it* rather than what it does to the picker
|
||||
- **The title says both counts while a query is open**, `campaigns (2 of 6)`. The bare total is what the box is, but over a list a query has cut down it is a lie about what is on screen
|
||||
@@ -349,6 +356,44 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- Both closed footers name `/`, since the jump works with a ticket open as well: it moves the selection and the overlay follows
|
||||
- Out of scope on purpose, each its own ticket once the input mode exists: `n` and `N` for the next and previous match, searching the description, tags or owner, regex, and filtering the board down to matches rather than selecting one
|
||||
|
||||
### The Command Prompt
|
||||
- **`prompt: Option<Prompt>` is the whole mode**, the shape `search` and `detail` use: open and content cannot disagree, and closing it leaves nothing to reset. `Prompt` carries the line, the cursor as a byte offset into it, and `refused`, which is `Search::missed` with something to say
|
||||
- **`Board::prompt_key` is third in the pre-dispatch**, beside `search_key` and `picker_key` and 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, and `ctrl-c` is the one key declined. It takes a `Size` for enter's sake: running a command reloads the board and then has to bring the ticket it moved back into view, which is the measurement `follow_selection` takes. Only one of the two prompts can be open at once: `:` is reachable from the action arms alone, and while either has the keyboard the other's key is a character in a line
|
||||
- **`esc` and `enter` are the mode's own keys and are answered in `prompt_key`; everything else belongs to the line and goes to `Prompt::key`.** That is also what keeps the borrow straight, since closing the prompt takes the whole board and editing takes only the prompt. Left, right, home, end, backspace and `ctrl-w` behave as they do in a shell, and `ctrl-w` eats the separators behind the cursor before the word behind those, so one press at the end of `mv 1b78a24 ` takes the id. There is deliberately no `tab`: suggesting the selected ticket is 00a14e7, and until then it is a key that must not reach the tabs
|
||||
- **The grammar is clap's, with nothing restated.** The line is tokenised by `split_line`, the binary's own name goes in front, and the arguments go to the same `Cli` definition the shell reaches, so a flag added to a command is typeable here the day it is added. Through `Cli::command().try_get_matches_from_mut` rather than `try_parse_from`, for what the matches give back: `command_name` walks the subcommands to name what resolved (`campaign show`, not `campaign`) instead of a `match` over every variant, which would be a second list of every verb the CLI has and one that goes stale silently
|
||||
- **`refused` is cleared by an edit and not by a movement.** The message is about the line, and moving the cursor does not change the line. `Prompt::key` clears it in the three arms that write to the line
|
||||
- **A line that ends inside a quote never reaches clap.** That is what `Unclosed` is for: a grammar complaint about a sentence nobody finished describes the wrong thing. Enter on an empty line, or one of nothing but separators, closes the prompt with nothing said, the way `esc` does — the bare form of the CLI opens a board and there is one on the screen
|
||||
- **Enter runs it, through `main.rs`'s `dispatch` and never through a handler this file names.** That match is the one mapping from a parsed command to the function that performs it: `main` calls it with its own stdout and the working directory, `Board::run` calls it with a buffer and the selected tab's root. A second copy inside `tui.rs` would drift the first time a command was added, and it would drift *silently*, since both halves go on compiling. The match is exhaustive so a new verb cannot fall into an `_` arm and do nothing, and `main_and_the_prompt_run_one_dispatch_table` reads both files as text to pin it. Only `tui` is matched outside the table, in `main`, because the board is that table's caller rather than an entry in it; reached from the prompt it is refused in those words
|
||||
- **`from_arg_matches` on the same matches gives `run` the typed values.** One parse, two readings: `command_name` walks the subcommands to name what resolved and `from_arg_matches` reconstructs the `Cli`. A `match` over every `Command` variant to get one or the other would be a second list of every verb the CLI has
|
||||
- **The handler's own words are what the board reports, word for word.** Those messages are written for a person already, and a second set kept here would go stale the first time one of them changed. The sink is a buffer, so the words come back as text and the board styles them; it is plain for the same reason `Detail` holds spans, since a ratatui paragraph prints an escape rather than obeying it. An error never goes through a sink at all — `color_text` asks the *process* about its stdout, which under the board answers yes about a terminal the message is not going to — so `error_lines` runs `without_escapes` over it and puts each cause on a line of its own
|
||||
- **A handler that errors leaves the prompt open with the line intact.** The usual cause is an ambiguous id, and the fix is two more characters rather than the whole line retyped from `:`. Ambiguity is an `Err` carrying the candidates, not a print and an `exit`, which is what makes it safe to reach from here at all
|
||||
- **The reload after a command is unconditional, and runs whether it failed or not.** `tick` reloads on the digest, which is right for a change made in another pane and needless latency for one the board just made: the reader would watch their own `mv` take up to a poll interval to appear. Either way, because a handler that failed part way through has still written
|
||||
- **The selection is restored by uuid across that reload, never by index.** `mv` puts the card in another column, `set --title` renames its file, and a filter can drop it out of view entirely, so the slot is not the ticket. `Board::reselect` has three answers: the card is in a drawn column and the selection goes to it; it is on the board but in a column the rotation is hiding, which is where `--status done` lands by default, so the notice says where it went and which key shows it; or the filter no longer holds it, which is said too, since a card vanishing from under the highlight reads as a bug in the board
|
||||
- **The merge tab is refused, for now.** It is the one tab that is not a board — its cards came from several `.worklane` directories and it is none of them — so `Board::current_project` answers `None` there and the command is refused rather than landing on whichever project came first. Routing by the card a command names is ebc5755. The project is resolved by index and not by the tab's name, which is a label two projects can share: e1d79c3 is exactly that, and a write routed by name would be that bug with a file changing at the end of it
|
||||
- **`Notice` holds as many lines as the command used, and `Board::notice_on_row` decides where they go.** One line with nothing else holding the row draws on the footer, where a copy's notice has always drawn. Anything else — several lines, or any answer at all while the prompt is still open on an error — draws as a box at the foot of the columns, cut to what the columns leave with the dropped count on its last row. A box rather than more rows of footer, and that is the whole reason it is an overlay: a footer that grew and shrank as notices came and went would reflow the columns on every keypress, moving every card the reader is looking at. `draw` and `draw_footer` both ask `notice_on_row`, so the two cannot come to disagree and draw the message twice or not at all
|
||||
- **What a refused line shows is clap's own message with the usage block cut off**, which is also what drops the `--help` line after it. `--help` is the exception: it parses as an error of the kind that means *print this* and what it would print is a page, so it is caught and answered in a row's worth of words, or clap's help lands on the alternate screen the way an unsunk `println!` would. `--version` goes through the ordinary path, because what it prints is one line by construction. `ColorChoice::Never` on the command, so nothing that reaches the row carries an escape
|
||||
- **The keys' width comes off the row before the line is windowed**, so a long command does not push them off the end; a message takes the row from the keys instead, since the reader has just been told something and `esc` and `enter` still do what they did. `prompt_window` anchors the window on the cursor's right edge, which costs the text *after* the cursor on a long line: keeping both ends needs a scroll offset in state, and the draw is where the width is known and the state is not writable
|
||||
- `: command` is named in every footer state, because the key works in every one of them, and the prompt's own key is drawn as `↵ run`
|
||||
|
||||
### The Prompt's Recall
|
||||
- **`up` and `down` walk the lines already typed, and the lines are on disk.** `.wlhistory` in the board's own folder, appended as each line is entered. It is the one file under `.worklane` the board writes rather than a command, and the only one that is not markdown, which is the cost of a recall worth having: a board is opened and closed all day, and one that emptied on quit would only help inside a single sitting
|
||||
- **`Recall` is per tab, parallel to `Board::tabs`**, so the tab in view decides which list `up` walks. A project's lines are the ones naming its ticket ids, and handing another board's `mv` back on this one would offer an id that resolves to nothing there. The tabs are fixed for the run, so the two vectors cannot drift, and the same index that picks the tab picks the recall
|
||||
- **The merge tab has no file.** It is the one tab that is not a board, `current_project` answers `None` there and a command typed there is refused for that reason, so there is nothing to attribute a line to. Those lines are still recalled for the run: every one of them was refused, and a refused line is the one most worth getting back. When ebc5755 routes a merge line to the board its card names, that board's file is the one to append to
|
||||
- **The position is on `Prompt` and the lines are on `Recall`**, so closing the prompt forgets the position and not the lines: the next `:` opens at the end of the list again, which is where a shell opens. `pending` holds the half typed line `up` walked away from, and walking `down` past the newest entry puts it back, so leaving a command to look for an older one never costs it
|
||||
- **The ends are stops, not wraps.** `up` on the oldest line leaves it up rather than cycling round to the newest, which is what a shell does with it; `down` with no walk under way does nothing, since there is nothing in front of a line still being typed and emptying the row would be a keypress that destroys work. **An empty recall does nothing at all**, and that includes leaving the line alone, or `up` on a board nobody has typed at would be a way to lose what is half written
|
||||
- **The line is kept before anything can refuse it.** A refused line never reached a handler and the fix is usually two characters, which is what the walk exists to save. Consecutive duplicates are kept once, against what is already held, so the rule spans runs as well as one sitting; a blank line is no command and is not kept. Nothing is trimmed
|
||||
- **A failed write is silent, and an unreadable file is an empty recall.** The line is in memory either way, so the walk works for the run on a board whose folder cannot be written, and a board with no history yet is the ordinary case rather than something to say. A notice about a history file would be about the one thing the reader did not ask for
|
||||
- **`.wlhistory` is not in `digest`.** Appending to it must not read as the tree moving, or every command typed would provoke a reload of every board on top of the one `run` already does
|
||||
|
||||
### Splitting a Typed Line
|
||||
- **`split_line` is the whole module, and it knows nothing about `Board`.** The command prompt reads one string and clap reads an argv, so `comment 1b78a24 the offset was never passed` has to be tokenised before anything can parse it: split on whitespace it is five arguments and `comment` takes two. A pure function over the line and the cursor is what makes every rule reachable from a unit test, and it is in a file of its own rather than in `tui.rs`, which is eleven thousand lines already
|
||||
- **The rules are the shell's, because that is what the prompt promises**: the line is spelled there exactly as it is spelled in the shell. Runs of whitespace separate arguments, single and double quotes group one, a backslash escapes the next character *except* inside single quotes where it is a backslash, and an explicitly empty `''` is an argument that exists and is empty — which is what `--title ""` being a usage error rather than a silent clear depends on. A leading hyphen is not special here: whether `--foo` is a flag or the text of a criterion is clap's question, and `PROSE` already answers it
|
||||
- **Written rather than pulled in, for the two answers a shell's own splitter does not owe anybody.** A line being typed is half finished, so an unterminated quote is a state to report and not an error to raise: `Unclosed` says which quote is open, or that the line ends on a backslash with nothing yet to escape, and the arguments up to that point are handed back anyway, because that is what a hint or a completion has to work from. And completion needs the cursor: which argument it is in counting from the verb, and whether nothing of that argument lies before it, which is the difference between completing an argument and starting one. Both fall out of the one scan and neither is reachable afterwards from the arguments alone
|
||||
- **`Some("")` is an argument that has been opened and is still empty**, which is the only thing that tells `''` from nothing typed at all. The cursor's answer is taken *before* the last argument is pushed, so a cursor at the end of the line is in the argument being typed rather than one past it
|
||||
- The cursor is a byte offset, because that is what the prompt's own cursor is: a `String` inserts and removes at byte indices. Past the end reads as the end and inside a multi-byte character reads as after it, so nothing panics and no caller has to clamp first
|
||||
- `Unclosed::Escape` wins over an open quote, being the inner of the two, and either answer refuses the line
|
||||
- The binary's own name is not among the arguments: prepending it before `Cli::try_parse_from` is the caller's, since only the caller knows what it is calling
|
||||
|
||||
### The Copy Key
|
||||
- **`y` copies the selected card's short id, over OSC 52 written by hand.** The board is where a ticket is found and the CLI is where it is acted on, and the only thing joining them was seven characters retyped off the screen. `y` reads as yank to the readers a keyboard board is for, and was the letter left: `q`, `esc`, `enter`, `space`, `hjkl`, the arrows, `pgup`, `pgdn`, `tab`, `backtab`, `d` and `/` were taken
|
||||
- **The mechanism was chosen against ssh**, which is where a board is often read. An escape sequence is the only one of the three ways that crosses the connection, since it is the terminal at the reader's end that owns the clipboard. A crate (`arboard` and its kind) wants X11 and Wayland libraries at build time, and on X11 the selection belongs to the process that set it: copy an id, quit, and the paste buffer is empty, which is precisely this flow. Shelling out to `wl-copy`, `xclip` or `pbcopy` is platform sniffing plus a process spawn, and does nothing on a machine where none of them is installed or on the far end of a connection. crossterm 0.28 is what ratatui 0.29 pins and it ships no clipboard command, and the backend types have to match whatever ratatui pins, so a newer crossterm cannot be picked up on its own
|
||||
@@ -406,7 +451,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **`Tab` owns the selection**, `column`, `card` and `offsets`, not `Board`. Sharing them across projects would point the selection at whatever unrelated ticket sat at the same place in the tab you switched to. `Board::current()` is the tab in view, and `visibility` stays on the board because it is a preference about the flow rather than about a project
|
||||
- The tabs are fixed for the run: a project cannot be added or dropped without restarting, so `Board::new` builds the tab list once and `reload` only refills each tab's columns. `reload` clamps **every** tab, and `select_tab` clamps again on arrival, because done may have been hidden while another tab was in view
|
||||
- The merge tab goes **first** and is where the view opens: it is the reason to monitor several boards at once. It is materialised in `reload`, from the cards already read, rather than computed per draw — the same reason the criteria count is filled in `collect_ticket_items`
|
||||
- The merge is **sorted**, through `by_priority_then_title` in `util.rs`, not concatenated. An overview whose order depended on the order of the arguments would bury one project's p1 under another's p5. It keeps priority then title where every other column takes `by_status_order`: the merge spans statuses, so no single entry stamp governs it
|
||||
- The merge is **sorted**, through `by_priority_then_title` in `util.rs`, not concatenated. An overview whose order depended on the order of the arguments would bury one project's p1 under another's p5. It keeps priority then title where every other column takes `by_status_order`: the merge spans statuses, so no single date governs it
|
||||
- `Card` wraps a `TicketItem` with the project it came from, `Some` only on the merge tab. Decided at reload rather than passed down to `card_lines` as a "which tab is this" flag. `TicketItem` is therefore `Clone`: the merge holds a second copy rather than re-reading every tree
|
||||
- **The project follows the id, on the card and on the overlay border.** Across boards the id is not an address: two projects can hold the same title, and seven characters do not say where they live. `project_label` takes what the row has left after the mark and the id and ends in an ellipsis, and it is measured before the due date, so on the merge the project wins the narrow column and the date is what `corner_line` drops
|
||||
- `tab` and `shift+tab` cycle rather than clamp, unlike the cards and columns: a row of tabs is a ring, and there is no end of a list to run off. Both were free of every other binding — the columns took `hjkl` and the arrows
|
||||
@@ -438,7 +483,7 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- **A mechanical entry renders as one line and a comment as it always did.** A field change is one fact, and a paragraph for it would bury the comments it sits between. The labels are padded to `Kind::LABEL_WIDTH`, `campaign` being the longest of the four, so the bodies line up under each other
|
||||
- **A campaign entry records `Campaign::name`, the codename or failing that the title, never the uuid the field holds.** Settled when the entry is written, not left to the renderer: a log is a record, and resolving at read time would let an entry change meaning when a campaign is renamed. A `before` uuid the board no longer has reads `_missing_`, the way the Campaign field itself renders a dangling one, and a ticket never assigned starts from `_Not set_` (f774a33)
|
||||
- **`--actor` is on every command that writes an entry**, spelled from one `ACTOR_HELP` in `command.rs`: a flag documented differently on each command reads as four flags. `--actor-from-git` rides beside it from its own one string, the same way. On `chown` it sits beside `user`, which is the ticket's new assignee — the two are different questions and that command answers both
|
||||
- **`set --actor` reaches only the entry `--tags` writes**, since tags are the one field of that command's that is logged. Documented on the flag rather than left for a reader to notice from the absence of entries
|
||||
- **`set --actor` reaches only the entry `--tags` writes**, since tags are the one field of that command's that is logged. Documented on the flag rather than left for a reader to notice from the absence of entries. `append --actor` is the same flag for the same reason: `append --tags` moves the same field, so it writes the same `Kind::Tags` entry, and a tag added without replacing the rest would otherwise be the one tag change the log missed
|
||||
|
||||
### Shipping the Agent Assets
|
||||
- The skill is embedded with `include_str!` from `assets/SKILL.md`, not copied by an install script. `cargo install` places binaries and nothing else, so an installed document that is not in the binary is a document that drifts from it
|
||||
@@ -460,11 +505,11 @@ and this file is for what someone changing worklane's own code needs.
|
||||
- `.opencode/agent/feature-planner-agent.md` is **deliberately not folded into `PLAN.md`**. It decomposes a feature request into new tickets, which is intake; `PLAN.md` orders the tickets that already exist. Merging them would give one document two jobs and a frontmatter description that fits neither, which is the same reason the review skill is its own document
|
||||
- **`install-tool` is a second command, not a flag on `install-skill`, because the two artifacts are not alike.** A skill is inert markdown that any agent can read and it reaches both from one path; the tool is executable TypeScript that reaches opencode alone. Claude Code has no directory it scans for a tool definition at all: `claude mcp add` with a `stdio`, `sse` or `http` transport is the only way a tool enters its tool list, and its plugin system adopts `agents`, `hooks`, `monitors`, `workflows`, `output-styles` and `themes` and nothing named tools. So an MCP server, a different artifact, would be what reached it. Verified against Claude Code 2.1.238
|
||||
- **`tools_root()` follows `XDG_CONFIG_HOME`, `skills_root()` does not.** `~/.claude` is not an XDG path and opencode's config root is: `opencode debug paths` reports `$XDG_CONFIG_HOME/opencode` with the variable set and `~/.config/opencode` without. An empty value counts as unset, the convention `colors_wanted` follows for `NO_COLOR`. `opencode_tool_dir` takes both variables as arguments for the reason `colors_wanted` does, since a threaded test binary cannot mutate the process environment to reach one branch at a time
|
||||
- **Singular `tool`, and it was measured, not guessed.** opencode 1.15.10 loads `~/.config/opencode/tool/` and `~/.config/opencode/tools/` both: each was served in turn from a directory outside any project and `/experimental/tool/ids` registered all eleven worklane tools. The singular is the spelling opencode's own documentation puts first, the way it writes `agent(s)` and `skill(s)`. `opencode serve` plus that endpoint is how to check this again; there is no `opencode debug tool` to ask
|
||||
- **`worklane.ts` is the file name the tool ids are built from.** opencode names each tool as the file then the export, so the file's eleven `export const` lines become `worklane_add` through `worklane_uncheck`. Renaming the file renames every tool and every permission rule that mentions one, which is why `TOOL.relative` is pinned by a test rather than left as a detail
|
||||
- **The tool needs nothing installed beside opencode**, which is worth stating because the file is executable and reads as though it wants a toolchain. It is loaded into opencode's own Bun runtime and the `@opencode-ai/plugin` import resolves there: a copy in a project with no `node_modules` anywhere above it registered all eleven tools, on a machine with no `bun` on `PATH`. c092ea7's criterion 6 named those two as runtime requirements and it was wrong about both
|
||||
- **Singular `tool`, and it was measured, not guessed.** opencode 1.15.10 loads `~/.config/opencode/tool/` and `~/.config/opencode/tools/` both: each was served in turn from a directory outside any project and `/experimental/tool/ids` registered every worklane tool the file carried, eleven at the time and twenty-one at the recheck after the wrapper caught up with the CLI. The singular is the spelling opencode's own documentation puts first, the way it writes `agent(s)` and `skill(s)`. `opencode serve` plus that endpoint is how to check this again; there is no `opencode debug tool` to ask
|
||||
- **`worklane.ts` is the file name the tool ids are built from.** opencode names each tool as the file then the export, so the file's twenty-one `export const` lines become `worklane_add` through `worklane_tags_set`. Renaming the file renames every tool and every permission rule that mentions one, which is why `TOOL.relative` is pinned by a test rather than left as a detail
|
||||
- **The tool needs nothing installed beside opencode**, which is worth stating because the file is executable and reads as though it wants a toolchain. It is loaded into opencode's own Bun runtime and the `@opencode-ai/plugin` import resolves there: a copy in a project with no `node_modules` anywhere above it registered all of its tools, on a machine with no `bun` on `PATH`. c092ea7's criterion 6 named those two as runtime requirements and it was wrong about both
|
||||
- **The closing line differs from the skills', and that is not a wording choice.** opencode reads its config once at startup and never reloads it, so a running one keeps the tools it began with; the skills' "on their next session" would be a claim that is not true here
|
||||
- **The wrapper is behind the CLI and nothing guards it.** It has no tool for `relate`, `campaign`, `assign` or `tags`, so an agent holding the tools cannot reach campaigns or relations at all. `every_tool_the_wrapper_exports_is_a_real_subcommand` catches the drift in the direction that breaks at call time, a tool for a command that no longer exists, and deliberately not the reverse: the gap is real, nobody has decided to close it, and a test asserting it would fail on that decision rather than on a mistake
|
||||
- **The wrapper walks clap in both directions now; until this ticket nothing did.** It was behind by four commands — `relate`, `campaign`, `assign` and `tags` had no tool, so an agent holding the tools could not reach campaigns or relations at all — and nothing compared the file to the CLI, which is how the gap opened and stayed open. `every_tool_the_wrapper_exports_is_a_real_subcommand` catches a tool for a command that has been renamed or dropped, which fails only when an agent finally calls it; `every_subcommand_outside_the_exceptions_has_a_tool` catches the other direction, a subcommand with no tool, through the same walk off clap the completion lists take. Its exception list carries a reason per entry rather than being bare, and one of those reasons was learned from the test's first run: a bare `worklane campaign` is refused by the CLI, its subcommand required, so there is no command for a `campaign` tool to wrap and the five `campaign_*` tools are the command
|
||||
- **Installing it globally reproduces fb3dec6 for the wrapper.** Global tools apply in every project including this one, so once `install-tool` has run, an agent working on worklane uses the installed copy of `assets/TOOL.ts` and not the tree it is editing. Same trap as the `worklane` on `PATH`, second instance
|
||||
- `every_agent_facing_subcommand_is_documented` stays on `SKILL` alone. It owns the CLI surface; a role document uses the handful of commands its job needs, and requiring the rest would fill a review document with `init` and campaigns to satisfy a test. The two checks that do run over every document are the frontmatter and that no document shows a command that does not exist
|
||||
- **The README command table has the same guard, `every_subcommand_has_a_row_in_the_readme_command_table` in `command.rs`.** The skill and the table are the two places a command is discovered, one by an agent and one by a person, and the skill was the only one under test: `campaign` and `assign` shipped in 0.12.0 and were still absent from the table at 0.20.0, e6e3a1b, along with the `--campaign` flag on the `ls` row. It walks clap's own subcommands, one level of nesting included, against the `|` lines of `README.md`, so a new command fails the suite until the table lists it. `help` is excluded, being clap's. The tag subcommands are named in a `PENDING` list rather than skipped, since f7dd1a1 rewrites that row and emptying the list is part of closing it
|
||||
|
||||
Generated
+1
-1
@@ -1503,7 +1503,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "worklane"
|
||||
version = "0.32.9"
|
||||
version = "0.32.21"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"assert_cmd",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "worklane"
|
||||
version = "0.32.9"
|
||||
version = "0.32.21"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
||||
@@ -5,15 +5,37 @@
|
||||
# release cannot end up half-done: no version bump left untagged, no tag without
|
||||
# a bump.
|
||||
|
||||
.PHONY: help patch minor major version release install
|
||||
.PHONY: help check patch minor major version release install
|
||||
|
||||
help:
|
||||
@echo "make check fmt, clippy and the suite, in that order"
|
||||
@echo "make patch bump $(CURRENT) -> next patch, amend into HEAD, tag"
|
||||
@echo "make minor bump $(CURRENT) -> next minor, amend into HEAD, tag"
|
||||
@echo "make major bump $(CURRENT) -> next major, amend into HEAD, tag"
|
||||
@echo "make version print the current version"
|
||||
@echo "make install cargo install --path . && worklane install-skill"
|
||||
|
||||
# The one command to run before committing. AGENTS.md pins fmt and clippy as clean and
|
||||
# 83d31cd is what happens when only memory enforces that: fmt drifted to about 160 places
|
||||
# across every file with the tool installed and configured the whole time. This is not CI,
|
||||
# which a single-author tool with no pipeline anywhere does not want, and not a hook, which
|
||||
# is a per-clone opt-in the way `blame.ignoreRevsFile` is. It is one name to type, so
|
||||
# "remember to run fmt, clippy and the tests" becomes "run make check".
|
||||
#
|
||||
# Cheapest first, so a formatting slip is reported in a second rather than after the suite.
|
||||
# `--all-targets` on clippy, matching the rule in AGENTS.md, so the tests are linted too.
|
||||
# `-D warnings` is what makes clippy's opinion an exit code: the rule says clean, and a
|
||||
# warning printed into a wall of cargo output is not clean, it is unread.
|
||||
#
|
||||
# Completions are in the suite rather than a step of their own. `cargo test` sources the
|
||||
# generated script into a real fish and asks it for candidates, so "check tests, check
|
||||
# completions" is one command already, and a second target would be a second thing to
|
||||
# remember. The fish tests skip when fish is not installed, printing that they did.
|
||||
check:
|
||||
cargo fmt --check
|
||||
cargo clippy --all-targets -- -D warnings
|
||||
cargo test
|
||||
|
||||
# Read from the [package] table of Cargo.toml, which is the version the binary
|
||||
# reports through `--version`, so it is the single source of truth. The name is
|
||||
# what finds this crate's own entry in Cargo.lock.
|
||||
|
||||
@@ -8,11 +8,11 @@ Worklane is a local Kanban flow for agentic software development.
|
||||
| `worklane` or `worklane tui [path...]` | Opens the board: one column per status, redrawn when the tree changes. Read only. Opens with done and discarded hidden, their counts in the footer; `d` rotates hide both, show done, show both, and back around. Arrows or `hjkl` to move, `enter` for detail, `pgup`/`pgdn` to scroll an open ticket or the campaign frame, whichever the selection is on, with a page indicator on its border 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, `c` to pick a campaign and filter the columns to its members, `q` to close whatever is open and then to quit. A card carries its campaign beside its tags, marked `~` and bold, and a comment count in its bottom right corner, the number then `❞` in cyan, before the criteria count and absent entirely when nobody has commented; while one is selected a frame above the columns names it, shows three rows of its description and says how far it has got, and `q` on its border gives the whole board back; up from the top card of a column moves the selection to that frame, where the scroll keys page through the description, `enter` gives it half the board and takes the rows back again, and down returns to the column it came from, leaving the frame at whatever height it was. 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, discarded 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 <tag>` and `--campaign <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 ls [status]` | Lists tickets, each column in its own order: the backlog by due date, soonest first, then priority then title, with an undated ticket below every dated one; committed and reviewing by when the ticket entered them, oldest first; done and discarded newest first. Optional positional status, and `--priority <1-5>`, `--tag <tag>` and `--campaign <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 <id>` | Shows ticket by UUID prefix (4+ chars), title substring, or filename substring. A campaign is addressed the same way, plus its exact codename, which wins over all three. Ends with the ticket's history: every comment on it and every change to its status, owner or tags, oldest first, each naming who made it |
|
||||
| `worklane mv <id> --status <target> [-f]` | Moves ticket between statuses. Default: forward only, one stage at a time. `-f` bypasses both restrictions. `--status discarded` is exempt and reachable from anywhere, for a ticket that will not be done; leaving `discarded` is a backward move and needs `-f`. Discarding is refused while open tickets are blocked by the ticket, `-f` overrides. Records a `status` entry in the ticket's history, after the move: a refused or no-op move records nothing. `--actor` names the writer of that entry |
|
||||
| `worklane set <ticket>` | Replaces fields with `--title`, `--description`, `--acceptance`, `--plan`, `--tags`, `--due`, `--priority`. At least one required. Changing the title renames the file, keeping the UUID. `--clear <field>` returns a field to unset instead, repeatable, taking `due`, `tags`, `priority`, `description`, `acceptance` or `plan`, and writing back exactly what `add` writes for a field it was never given. No `title`, which addresses the ticket, and no `owner`, which is `chown`'s. Replacing and clearing the same field in one call is refused. `--tags` records a `tags` entry in the ticket's history, with the tags before and after, and it is the only field of this command's that is logged; `--actor` names the writer of that entry |
|
||||
| `worklane append <ticket>` | Adds to a section with `--description`, `--acceptance`, `--plan`. At least one required. The description gains a paragraph; list items go on the end, steps numbered on from the last |
|
||||
| `worklane append <ticket>` | Adds to a section with `--description`, `--acceptance`, `--plan`, or to the tags with `--tags`. At least one required. The description gains a paragraph; list items go on the end, steps numbered on from the last. `--tags` keeps the tags the ticket already carries, ignores one it already has, and takes several as a repeated flag or separated by commas, the way the field itself is written; it is the counterpart to `set --tags`, which replaces the whole field. It records a `tags` entry in the ticket's history, and `--actor` names the writer of that entry, this command's only logged field as it is `set`'s. Emptying a field is `set --clear`, which has no counterpart here |
|
||||
| `worklane relate <ticket>` | Records an edge to another ticket with `--blocked-by`, `--regression-of` or `--relates-to`, each repeatable. At least one required. Only the ticket named is written; `show` derives the other end by scanning, and a derived row that reads exactly like a stored one is drawn once. `relates to` on a ticket whose target already stores it reports no change, since it is the same edge; `blocked by` and `regression of` read differently from the far end, so a mutual pair is two rows. `mv` refuses to move a ticket blocked by one that is not done, unless `-f`. `--clear <kind> <target>` takes an edge off instead, repeatable, the kind spelled either way, `blocked-by` or `blocked by`. The target resolves against the edges the ticket holds first, by id prefix, which is the only way to reach one whose ticket has been deleted, then as an ordinary ticket search. An edge the ticket does not hold reports no change; a target naming nothing at all is an error. Recording and clearing the same edge in one call is refused |
|
||||
| `worklane chown <user> <ticket>` | Sets the Owner field, the only command that writes it. Free text, checked against nothing. User first and ticket second, after Unix `chown`. `worklane chown --clear <ticket>` returns the field to unset, taking the ticket in the flag since there is no user to give, and not to the git user `add` falls back to. Records an `owner` entry in the ticket's history, with the owner before and after; `--actor` names who made the change, which is not the same as the user argument |
|
||||
| `worklane check <ticket> [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 |
|
||||
@@ -27,7 +27,7 @@ Worklane is a local Kanban flow for agentic software development.
|
||||
| `worklane tags` | Lists the tags the board carries as the tag, a tab and how many tickets carry it, one per line, unstyled and alphabetical. Case sensitive like `ls --tag`, so `bug` and `Bug` list separately and land next to each other. Every status, done included. The one command that answers what tags exist rather than what carries a tag already known |
|
||||
| `worklane completions <shell>` | 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>/SKILL.md`, which Claude Code and opencode both read. Four 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, and `worklane-admin` sets a board up and repairs one, its tag vocabulary and the faults a board can develop. Every document unless one is named. Leaves a modified copy alone unless `--force`; `--print` writes one to stdout instead and needs the name |
|
||||
| `worklane install-tool` | Writes the embedded opencode tool definitions to `$XDG_CONFIG_HOME/opencode/tool/worklane.ts`, or `~/.config/opencode/tool/` without it, where opencode loads them for every project. One file and so no name to pass. `--force` and `--print` behave as they do for a skill. opencode only: it registers the eleven `worklane_*` tools from the file name and its exports, and Claude Code has no directory it scans for a tool definition, so reaching it would mean an MCP server rather than this. Restart opencode after installing, since it reads its config at startup and never reloads it. Nothing else to install: the file runs inside opencode's own runtime, so neither Bun nor `@opencode-ai/plugin` has to be on the machine |
|
||||
| `worklane install-tool` | Writes the embedded opencode tool definitions to `$XDG_CONFIG_HOME/opencode/tool/worklane.ts`, or `~/.config/opencode/tool/` without it, where opencode loads them for every project. One file and so no name to pass. `--force` and `--print` behave as they do for a skill. opencode only: it registers the twenty-one `worklane_*` tools from the file name and its exports, and Claude Code has no directory it scans for a tool definition, so reaching it would mean an MCP server rather than this. Restart opencode after installing, since it reads its config at startup and never reloads it. Nothing else to install: the file runs inside opencode's own runtime, so neither Bun nor `@opencode-ai/plugin` has to be on the machine |
|
||||
|
||||
## Environment
|
||||
|
||||
@@ -88,6 +88,17 @@ the command. A pipe holds 64 KiB, so a listing that fits lands in the buffer who
|
||||
and the writer never learns the reader left, giving 0. Only output past that gets far
|
||||
enough to be cut off. Either way nothing is printed to stderr.
|
||||
|
||||
## Checking
|
||||
|
||||
```sh
|
||||
make check # cargo fmt --check, clippy -D warnings, cargo test
|
||||
```
|
||||
|
||||
One command, cheapest first, and the whole of what enforces the formatting and lint rules:
|
||||
there is no CI here and no hook. The completion tests inside it source the generated script
|
||||
into a real fish and ask it what it would offer, so they skip, saying so, on a machine
|
||||
without fish.
|
||||
|
||||
## Releasing
|
||||
|
||||
```sh
|
||||
|
||||
+15
-7
@@ -169,14 +169,21 @@ worklane set 1b78a24 --clear due # take a value away again
|
||||
worklane set 1b78a24 --clear tags --clear plan # as many fields as you like
|
||||
worklane append 1b78a24 --acceptance "One more criterion"
|
||||
worklane append 1b78a24 --description "What was learned since."
|
||||
worklane append 1b78a24 --tags tui # add a tag, keeping the ones there
|
||||
worklane chown alice 1b78a24 # hand the ticket to someone
|
||||
worklane chown --clear 1b78a24 # hand it back to nobody
|
||||
```
|
||||
|
||||
`set` replaces, `append` adds, `--clear` empties. Neither `set` nor `append` has
|
||||
`--owner` or `--status`: owner is `chown`'s and status is `mv`'s, so each field has
|
||||
exactly one writer. A field set to the value it already holds is reported unchanged and
|
||||
nothing is written, and so is a field cleared that was already unset.
|
||||
`set` replaces, `append` adds, `--clear` empties. `set --tags` overwrites the whole
|
||||
field, so **use `append --tags` to add a tag to a ticket that already carries some**: it
|
||||
keeps what is there, and a tag the ticket already has is reported as no change rather
|
||||
than added twice, so you do not have to read the ticket first. Several in one call by
|
||||
repeating the flag or by separating them with commas, `--tags "bug, tui"`, since that is
|
||||
how the field itself is written. Reach for `set --tags` when the whole list is being
|
||||
replaced, and `set --clear tags` to empty it: `append` has neither. Neither `set` nor
|
||||
`append` has `--owner` or `--status`: owner is `chown`'s and status is `mv`'s, so each
|
||||
field has exactly one writer. A field set to the value it already holds is reported
|
||||
unchanged and nothing is written, and so is a field cleared that was already unset.
|
||||
|
||||
**`--clear` takes the field as its value**, one of `due`, `tags`, `priority`,
|
||||
`description`, `acceptance` or `plan`, and repeats. It writes back exactly what `add`
|
||||
@@ -337,8 +344,8 @@ existing ticket will have been written from a different angle.
|
||||
|
||||
`show` ends with a HISTORY block: every comment on the ticket and every change to its
|
||||
status, owner, tags or campaign, oldest first, each naming who made it. You do not write
|
||||
these by hand. `mv`, `chown`, `set --tags` and `assign` record themselves, and a call
|
||||
that changes nothing records nothing. A campaign move is recorded by codename, or by
|
||||
these by hand. `mv`, `chown`, `set --tags`, `append --tags` and `assign` record
|
||||
themselves, and a call that changes nothing records nothing. A campaign move is recorded by codename, or by
|
||||
title for a campaign that has none, not by the uuid the field holds.
|
||||
|
||||
```
|
||||
@@ -378,7 +385,8 @@ you to move a ticket, or to put words on the board as their comment, so name the
|
||||
the flag — the move was theirs and the words are theirs, and an entry carrying your name
|
||||
reads later as though you decided both. Otherwise leave it off, unless your instructions
|
||||
say to use it. It is spelled the same on every command that writes an entry: `comment`,
|
||||
`mv`, `chown`, `set` and `assign`.
|
||||
`mv`, `chown`, `set`, `append` and `assign`. On the last two it reaches only the entry
|
||||
`--tags` writes, since that is the one field either of them logs.
|
||||
|
||||
Acting for the person without knowing how they spell themselves? `--actor-from-git`
|
||||
attributes the entry to the detected git user instead of `WORKLANE_ACTOR`, so their name
|
||||
|
||||
+389
-3
@@ -358,7 +358,7 @@ export const set = tool({
|
||||
|
||||
export const append = tool({
|
||||
description:
|
||||
"Add to a section of an existing worklane ticket without replacing what is there. The description gains a new paragraph; acceptance criteria and plan steps are added to the end of their lists, with steps numbered on from the last. Ticked criteria and handwritten content are left alone. To replace a section outright, use set.",
|
||||
"Add to an existing worklane ticket without replacing what is there. The description gains a new paragraph; acceptance criteria and plan steps are added to the end of their lists, with steps numbered on from the last; tags are added to the ones the ticket already carries. Ticked criteria and handwritten content are left alone. To replace a section or the whole tag list outright, use set.",
|
||||
args: {
|
||||
ticket: tool.schema
|
||||
.string()
|
||||
@@ -375,6 +375,14 @@ export const append = tool({
|
||||
.string()
|
||||
.describe("Implementation plan steps to add, one per line.")
|
||||
.optional(),
|
||||
tags: tool.schema
|
||||
.string()
|
||||
.describe("Tags to add, comma separated, keeping the ones the ticket already carries. A tag it already has is reported as no change rather than added twice, so the ticket does not have to be read first.")
|
||||
.optional(),
|
||||
actor: tool.schema
|
||||
.string()
|
||||
.describe("Who the entry is attributed to. Only reaches the entry tags writes, since that is the one field of this command's that is logged. If omitted, WORKLANE_ACTOR is used, then the git user.")
|
||||
.optional(),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.ticket) {
|
||||
@@ -395,9 +403,14 @@ export const append = tool({
|
||||
if (args.plan) {
|
||||
itemLines(args.plan).forEach((line: string) => cmd.push("--plan", line));
|
||||
}
|
||||
if (args.tags) cmd.push("--tags", args.tags);
|
||||
// Last, and not counted as a field: the length check below is what refuses a call
|
||||
// that names nothing to add, and an actor alone adds nothing. Same shape as set.
|
||||
const fields = cmd.length;
|
||||
if (args.actor) cmd.push("--actor", args.actor);
|
||||
|
||||
if (cmd.length === 2) {
|
||||
return "Error appending: give at least one section to add to";
|
||||
if (fields === 2) {
|
||||
return "Error appending: give at least one field to add to";
|
||||
}
|
||||
|
||||
try {
|
||||
@@ -497,3 +510,376 @@ function checkboxTool(verb: "check" | "uncheck") {
|
||||
|
||||
export const check = checkboxTool("check");
|
||||
export const uncheck = checkboxTool("uncheck");
|
||||
|
||||
/**
|
||||
* relate is the only writer of the Relations section, so the tool mirrors it rather
|
||||
* than folding relations into set.
|
||||
*
|
||||
* The clear half is one argument per kind rather than a free-text "kind target" line,
|
||||
* which is what the CLI's single --clear flag would force here. A kind inside a value
|
||||
* cannot be typed by the schema, a target is a search that may itself contain spaces,
|
||||
* and splitting the pair apart by hand re-parses what clap already refuses to guess at.
|
||||
* Per kind the target stays a plain line, the way every other list argument works.
|
||||
*/
|
||||
export const relate = tool({
|
||||
description:
|
||||
"Record a relation from one ticket to another, or take one off. Kinds: blocked-by means this one waits on that one and its moves are refused while the target is open; regression-of means this one broke that one's fix; relates-to is a neighbour with no dependency. The edge is stored on the ticket you name alone, and show derives the other end for the target, so never record both directions.",
|
||||
args: {
|
||||
ticket: tool.schema
|
||||
.string()
|
||||
.describe("Ticket UUID prefix (4+ chars) or title substring (required)"),
|
||||
blocked_by: tool.schema
|
||||
.string()
|
||||
.describe("Target tickets this one waits on, one per line.")
|
||||
.optional(),
|
||||
regression_of: tool.schema
|
||||
.string()
|
||||
.describe("Target tickets whose fix this one broke, one per line.")
|
||||
.optional(),
|
||||
relates_to: tool.schema
|
||||
.string()
|
||||
.describe("Target tickets this one merely relates to, one per line.")
|
||||
.optional(),
|
||||
clear_blocked_by: tool.schema
|
||||
.string()
|
||||
.describe("Targets whose blocked-by edge comes off this ticket, one per line.")
|
||||
.optional(),
|
||||
clear_regression_of: tool.schema
|
||||
.string()
|
||||
.describe("Targets whose regression-of edge comes off this ticket, one per line.")
|
||||
.optional(),
|
||||
clear_relates_to: tool.schema
|
||||
.string()
|
||||
.describe("Targets whose relates-to edge comes off this ticket, one per line.")
|
||||
.optional(),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.ticket) {
|
||||
return "Error relating tickets: ticket is required";
|
||||
}
|
||||
|
||||
const cmd: string[] = ["relate", args.ticket];
|
||||
if (args.blocked_by) itemLines(args.blocked_by).forEach((line) => cmd.push("--blocked-by", line));
|
||||
if (args.regression_of) {
|
||||
itemLines(args.regression_of).forEach((line) => cmd.push("--regression-of", line));
|
||||
}
|
||||
if (args.relates_to) itemLines(args.relates_to).forEach((line) => cmd.push("--relates-to", line));
|
||||
|
||||
// The kind is spelled the way the flag records it, not the way show prints it:
|
||||
// the CLI takes either, and the flag spelling is the one with no space in it.
|
||||
if (args.clear_blocked_by) {
|
||||
itemLines(args.clear_blocked_by).forEach((line) => cmd.push("--clear", "blocked-by", line));
|
||||
}
|
||||
if (args.clear_regression_of) {
|
||||
itemLines(args.clear_regression_of).forEach((line) => cmd.push("--clear", "regression-of", line));
|
||||
}
|
||||
if (args.clear_relates_to) {
|
||||
itemLines(args.clear_relates_to).forEach((line) => cmd.push("--clear", "relates-to", line));
|
||||
}
|
||||
|
||||
if (cmd.length === 2) {
|
||||
return "Error relating tickets: name a relation to record or one to clear";
|
||||
}
|
||||
|
||||
try {
|
||||
return await run(cmd, context);
|
||||
} catch (err: any) {
|
||||
return `Error relating tickets: ${err.message}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
/**
|
||||
* Five tools for the five campaign subcommands, one export each.
|
||||
*
|
||||
* One tool taking an action argument would mirror the CLI nesting, but the schema
|
||||
* could then no longer say which arguments belong to which action: campaign_set's
|
||||
* force only means something beside --codename, and campaign_append's description is
|
||||
* required where add's is not. Separate exports keep each schema true, and the ids
|
||||
* read as the CLI path anyway, since opencode builds them from this file name plus
|
||||
* the export: worklane_campaign_set.
|
||||
*/
|
||||
export const campaign_add = tool({
|
||||
description:
|
||||
"File a new campaign: several separate tickets that have to be finished together for one goal. Its state is derived from its members, so there is nothing to move or close. Give a codename when you can: one word the board draws on every card in the campaign and the shortest thing that addresses it.",
|
||||
args: {
|
||||
title: tool.schema
|
||||
.string()
|
||||
.describe("Campaign title (required)"),
|
||||
description: tool.schema
|
||||
.string()
|
||||
.describe("What the campaign is for. Use newlines between paragraphs.")
|
||||
.optional(),
|
||||
codename: tool.schema
|
||||
.string()
|
||||
.describe("One word to call the campaign by, e.g. 'v1' or 'beaver'.")
|
||||
.optional(),
|
||||
owner: tool.schema
|
||||
.string()
|
||||
.describe("Campaign owner name. If omitted, defaults to the git user.")
|
||||
.optional(),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.title) {
|
||||
return "Error adding campaign: title is required";
|
||||
}
|
||||
|
||||
const cmd: string[] = ["campaign", "add", "--title", args.title];
|
||||
if (args.description) {
|
||||
descriptionLines(args.description).forEach((line: string) =>
|
||||
cmd.push("--description", line),
|
||||
);
|
||||
}
|
||||
if (args.codename) cmd.push("--codename", String(args.codename));
|
||||
if (args.owner) cmd.push("--owner", args.owner);
|
||||
|
||||
try {
|
||||
return await run(cmd, context);
|
||||
} catch (err: any) {
|
||||
return `Error adding campaign: ${err.message}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
export const campaign_set = tool({
|
||||
description:
|
||||
"Replace fields on an existing campaign: its title, its description or its codename. Replacing a codename the campaign already has needs force, since everything refers to the campaign by that word once it exists; setting the codename it already carries is a no-op either way. Membership is not set here, use assign.",
|
||||
args: {
|
||||
campaign: tool.schema
|
||||
.string()
|
||||
.describe("Campaign UUID prefix, codename or title substring (required)"),
|
||||
title: tool.schema
|
||||
.string()
|
||||
.describe("New title. The file is renamed to match, keeping the UUID.")
|
||||
.optional(),
|
||||
description: tool.schema
|
||||
.string()
|
||||
.describe("New description, replacing the whole section. Use newlines between paragraphs.")
|
||||
.optional(),
|
||||
codename: tool.schema
|
||||
.string()
|
||||
.describe("New codename, one word. Replacing an existing one needs force.")
|
||||
.optional(),
|
||||
force: tool.schema
|
||||
.boolean()
|
||||
.describe("Allow replacing a codename the campaign already has.")
|
||||
.optional(),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.campaign) {
|
||||
return "Error setting campaign fields: campaign is required";
|
||||
}
|
||||
|
||||
const cmd: string[] = ["campaign", "set", args.campaign];
|
||||
if (args.title) cmd.push("--title", args.title);
|
||||
if (args.description) {
|
||||
descriptionLines(args.description).forEach((line: string) =>
|
||||
cmd.push("--description", line),
|
||||
);
|
||||
}
|
||||
if (args.codename) cmd.push("--codename", String(args.codename));
|
||||
if (args.force) cmd.push("--force");
|
||||
|
||||
if (cmd.length === 3) {
|
||||
return "Error setting campaign fields: give at least one field to change";
|
||||
}
|
||||
|
||||
try {
|
||||
return await run(cmd, context);
|
||||
} catch (err: any) {
|
||||
return `Error setting campaign fields: ${err.message}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
export const campaign_append = tool({
|
||||
description:
|
||||
"Add a paragraph to a campaign's description without replacing what is already written. To replace the whole description, use campaign_set.",
|
||||
args: {
|
||||
campaign: tool.schema
|
||||
.string()
|
||||
.describe("Campaign UUID prefix, codename or title substring (required)"),
|
||||
description: tool.schema
|
||||
.string()
|
||||
.describe("Text to add as a new paragraph at the end of the description (required)."),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.campaign) {
|
||||
return "Error appending to campaign: campaign is required";
|
||||
}
|
||||
if (!args.description) {
|
||||
return "Error appending to campaign: description is required";
|
||||
}
|
||||
|
||||
const cmd: string[] = ["campaign", "append", args.campaign];
|
||||
descriptionLines(args.description).forEach((line: string) =>
|
||||
cmd.push("--description", line),
|
||||
);
|
||||
|
||||
try {
|
||||
return await run(cmd, context);
|
||||
} catch (err: any) {
|
||||
return `Error appending to campaign: ${err.message}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
export const campaign_ls = tool({
|
||||
description:
|
||||
"List campaigns with how far each has got: id, codename or title, owner, and done members against total. Open until every member is done or discarded.",
|
||||
args: {
|
||||
ids: tool.schema
|
||||
.boolean()
|
||||
.describe("Print only id and title, tab separated, one per line, for parsing.")
|
||||
.optional(),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
const cmd = ["campaign", "ls"];
|
||||
if (args.ids) cmd.push("--ids");
|
||||
try {
|
||||
return await run(cmd, context);
|
||||
} catch (err: any) {
|
||||
return `Error listing campaigns: ${err.message}, Dir: ${resolveWorklaneDir(context)}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
export const campaign_show = tool({
|
||||
description:
|
||||
"Show a campaign's body and its members grouped by status, done included, so what is finished against what is left is one answer.",
|
||||
args: {
|
||||
campaign: tool.schema
|
||||
.string()
|
||||
.describe("Campaign UUID prefix, codename or title substring (required)"),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.campaign) {
|
||||
return "Error showing campaign: campaign is required";
|
||||
}
|
||||
try {
|
||||
return await run(["campaign", "show", args.campaign], context);
|
||||
} catch (err: any) {
|
||||
return `Error showing campaign: ${err.message}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
export const assign = tool({
|
||||
description:
|
||||
"Put a ticket in a campaign, moving it out of whichever campaign it was in: a ticket is in at most one. Note the order, campaign first and ticket second, after chown.",
|
||||
args: {
|
||||
campaign: tool.schema
|
||||
.string()
|
||||
.describe("Campaign UUID prefix, codename or title substring (required)"),
|
||||
ticket: tool.schema
|
||||
.string()
|
||||
.describe("Ticket UUID prefix (4+ chars) or title substring (required)"),
|
||||
actor: tool.schema
|
||||
.string()
|
||||
.describe("Who the entry is attributed to. If omitted, WORKLANE_ACTOR is used, then the git user, then \"unknown\". Set WORKLANE_ACTOR in the environment opencode is started with rather than passing this on every call.")
|
||||
.optional(),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.campaign) {
|
||||
return "Error assigning ticket: campaign is required";
|
||||
}
|
||||
if (!args.ticket) {
|
||||
return "Error assigning ticket: ticket is required";
|
||||
}
|
||||
|
||||
const cmd: string[] = ["assign", args.campaign, args.ticket];
|
||||
if (args.actor) cmd.push("--actor", args.actor);
|
||||
|
||||
try {
|
||||
return await run(cmd, context);
|
||||
} catch (err: any) {
|
||||
return `Error assigning ticket: ${err.message}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
/**
|
||||
* Three tools for tags, and none for `tags ls`: it prints exactly what the bare
|
||||
* `worklane tags` listing prints, which the tags tool runs.
|
||||
*
|
||||
* The annotation lines go through descriptionLines, not itemLines: an empty value is
|
||||
* a paragraph break in an annotation, exactly as it is in a description, because the
|
||||
* value_parser on the CLI side accepts one and the vocabulary file stores prose under
|
||||
* the tag heading.
|
||||
*/
|
||||
export const tags = tool({
|
||||
description:
|
||||
"List the tags the board carries: the tag, how many tickets carry it, and the opening line of its declared meaning. Read this before inventing a tag. Case sensitive, so bug and Bug list separately and land next to each other, which is where a near-duplicate is spotted.",
|
||||
args: {},
|
||||
async execute(_args: Record<string, any>, context: ToolContext) {
|
||||
try {
|
||||
return await run(["tags"], context);
|
||||
} catch (err: any) {
|
||||
return `Error listing tags: ${err.message}, Dir: ${resolveWorklaneDir(context)}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
export const tags_add = tool({
|
||||
description:
|
||||
"Declare a tag and what it means: when the next ticket belongs in it. The tag is spelled exactly the way ls --tag matches it, one word with no comma in it.",
|
||||
args: {
|
||||
tag: tool.schema
|
||||
.string()
|
||||
.describe("The tag to declare (required), e.g. 'bug' or 'frontend'."),
|
||||
annotation: tool.schema
|
||||
.string()
|
||||
.describe("What the tag means and when it is appropriate. Use newlines between paragraphs.")
|
||||
.optional(),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.tag) {
|
||||
return "Error declaring tag: tag is required";
|
||||
}
|
||||
|
||||
const cmd: string[] = ["tags", "add", args.tag];
|
||||
if (args.annotation) {
|
||||
descriptionLines(args.annotation).forEach((line: string) =>
|
||||
cmd.push("--annotation", line),
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
return await run(cmd, context);
|
||||
} catch (err: any) {
|
||||
return `Error declaring tag: ${err.message}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
export const tags_set = tool({
|
||||
description:
|
||||
"Replace what a declared tag means, keeping the tickets carrying it. There is no rename: changing the word itself means rewriting the Tags field of every ticket that carries it, which is a migration and not this call.",
|
||||
args: {
|
||||
tag: tool.schema
|
||||
.string()
|
||||
.describe("The tag to change, spelled the way it was declared (required)."),
|
||||
annotation: tool.schema
|
||||
.string()
|
||||
.describe("What the tag means, replacing whatever it said before. Use newlines between paragraphs (required)."),
|
||||
},
|
||||
async execute(args: Record<string, any>, context: ToolContext) {
|
||||
if (!args.tag) {
|
||||
return "Error setting tag meaning: tag is required";
|
||||
}
|
||||
if (!args.annotation) {
|
||||
return "Error setting tag meaning: annotation is required";
|
||||
}
|
||||
|
||||
const cmd: string[] = ["tags", "set", args.tag];
|
||||
descriptionLines(args.annotation).forEach((line: string) =>
|
||||
cmd.push("--annotation", line),
|
||||
);
|
||||
|
||||
try {
|
||||
return await run(cmd, context);
|
||||
} catch (err: any) {
|
||||
return `Error setting tag meaning: ${err.message}`;
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
+26
-4
@@ -858,14 +858,15 @@ impl ChownArgs {
|
||||
}
|
||||
}
|
||||
|
||||
/// `append` only offers the sections that hold multiple lines, since appending to a
|
||||
/// scalar has no meaning.
|
||||
/// `append` offers the fields something can be added to without disturbing what is
|
||||
/// already in them: the three sections that hold multiple lines, and Tags, which is a
|
||||
/// list. Appending to a scalar has no meaning, so there is no `--priority` or `--due`.
|
||||
#[derive(clap::Args)]
|
||||
#[command(group(
|
||||
clap::ArgGroup::new("append_fields")
|
||||
.required(true)
|
||||
.multiple(true)
|
||||
.args(["description", "acceptance", "plan"])
|
||||
.args(["description", "acceptance", "plan", "tags"])
|
||||
))]
|
||||
pub struct AppendArgs {
|
||||
/// Ticket UUID or title
|
||||
@@ -882,6 +883,24 @@ pub struct AppendArgs {
|
||||
/// Add implementation plan steps, numbered on from the last. Repeat the flag
|
||||
#[arg(short, long, allow_hyphen_values = PROSE)]
|
||||
pub plan: Vec<String>,
|
||||
|
||||
/// Add tags, keeping the ones the ticket already carries. Repeat the flag, or
|
||||
/// separate them with commas
|
||||
///
|
||||
/// `non_empty` rather than the `clearable` that `set --tags` takes. That message
|
||||
/// names `--clear`, and this command has none: emptying the field is
|
||||
/// `set --clear tags`, so pointing at a flag that is not here would send the caller
|
||||
/// looking for it on `append`.
|
||||
#[arg(short = 'g', long, value_parser = non_empty)]
|
||||
pub tags: Vec<String>,
|
||||
|
||||
/// Only reaches the entry `--tags` writes, since that is the one field of this
|
||||
/// command's that is logged, exactly as on `set`
|
||||
#[arg(long, help = ACTOR_HELP)]
|
||||
pub actor: Option<String>,
|
||||
|
||||
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
|
||||
pub actor_from_git: bool,
|
||||
}
|
||||
|
||||
/// `relate` is the only writer of the Relations section, the way `chown` is the only
|
||||
@@ -1080,6 +1099,9 @@ mod tests {
|
||||
|
||||
// A guard on the walker itself: if it stopped finding commands, every assertion
|
||||
// above would pass by never running.
|
||||
assert_eq!(seen, 5, "expected comment, mv, chown, set and assign to carry --actor");
|
||||
assert_eq!(
|
||||
seen, 6,
|
||||
"expected comment, mv, chown, set, append and assign to carry --actor"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
+81
-13
@@ -64,12 +64,22 @@ pub const CAMPAIGN_NESTED_COMMANDS: [(&str, &str); 3] = [
|
||||
/// Options whose value is a campaign.
|
||||
pub const CAMPAIGN_FLAGS: [&str; 1] = ["campaign"];
|
||||
|
||||
/// Options whose value is a tag.
|
||||
/// Options whose value is a tag, as the command that takes it and the flag's long name.
|
||||
///
|
||||
/// Its own list rather than a line in the block below, because the values come from a
|
||||
/// different command: a tag is not an object with an id, so `worklane tags` answers this
|
||||
/// one where `ls --ids` answers the tickets.
|
||||
pub const TAG_FLAGS: [&str; 1] = ["tag"];
|
||||
///
|
||||
/// Pairs rather than the flat list the other flag lists are, because the two spellings
|
||||
/// differ: `ls --tag` filters on one and `append --tags` adds them, so a single rule
|
||||
/// naming both options would tell fish that each command takes the other's flag. One
|
||||
/// rule per pair instead.
|
||||
///
|
||||
/// `add --tags` and `set --tags` are deliberately absent. Both take the *whole* list, so
|
||||
/// the token being completed is `bug,tui` and fish replaces a token entire: offering one
|
||||
/// tag there would throw away the ones already typed. `append --tags` is the one where
|
||||
/// naming a single tag is the ordinary call.
|
||||
pub const TAG_FLAGS: [(&str, &str); 2] = [("ls", "tag"), ("append", "tags")];
|
||||
|
||||
/// Nested commands whose first argument is a tag the board already has.
|
||||
///
|
||||
@@ -110,7 +120,16 @@ fn fish_dynamic() -> String {
|
||||
.collect::<Vec<_>>()
|
||||
.join("; or ");
|
||||
let campaign_flags = flag_list(&CAMPAIGN_FLAGS);
|
||||
let tag_flags = flag_list(&TAG_FLAGS);
|
||||
let tag_flags = TAG_FLAGS
|
||||
.iter()
|
||||
.map(|(command, flag)| {
|
||||
format!(
|
||||
"complete -c worklane -n '__worklane_command_is {command}' -l {flag} \\\n \
|
||||
-x -a '(worklane tags | cut -f1,3)'"
|
||||
)
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
let tag_nested = TAG_NESTED_COMMANDS
|
||||
.iter()
|
||||
.map(|(parent, child)| format!("__worklane_nested_arg_of {parent} {child}"))
|
||||
@@ -218,8 +237,10 @@ complete -c worklane -n '__worklane_command_is ls' {campaign_flags} \
|
||||
# What is left is the annotation, and a tag the board carries but has never declared has
|
||||
# none: it is offered with no description at all, which is the near-duplicate the file was
|
||||
# added to catch. The count used to be the description and said the same thing more weakly.
|
||||
complete -c worklane -n '__worklane_command_is ls' {tag_flags} \
|
||||
-x -a '(worklane tags | cut -f1,3)'
|
||||
#
|
||||
# One rule per command, from `TAG_FLAGS`: `ls --tag` and `append --tags` are spelled
|
||||
# differently, so a single rule naming both options would offer each under the other.
|
||||
{tag_flags}
|
||||
|
||||
# And `tags set` names one that is already declared, so it reads the same listing. `tags
|
||||
# add` has no rule on purpose: it takes a tag the board does not have, so the candidates
|
||||
@@ -410,14 +431,28 @@ mod tests {
|
||||
/// about what the fish block is missing, which is a test's question.
|
||||
const TAG_NEW_COMMANDS: [(&str, &str); 1] = [("tags", "add")];
|
||||
|
||||
/// Options taking a whole comma-separated list of tags rather than one.
|
||||
///
|
||||
/// `add --tags` and `set --tags` write the field entire, so what is being typed at the
|
||||
/// cursor is `bug,tui` and fish replaces a token whole: a rule offering one tag there
|
||||
/// would throw away the ones already in the token. `append --tags` adds to what is
|
||||
/// there, so a single tag is the ordinary value and it earns a rule. Recorded rather
|
||||
/// than skipped, for the reason `TAG_NEW_COMMANDS` is: the next `--tags` has to say
|
||||
/// which of the two it is.
|
||||
const TAG_LIST_FLAGS: [(&str, &str); 2] = [("add", "tags"), ("set", "tags")];
|
||||
|
||||
/// Tags have their own list because their values come from `worklane tags` rather than
|
||||
/// from a listing of objects, so a second tag-taking option would need that rule and
|
||||
/// not the campaign one.
|
||||
///
|
||||
/// Both spellings are walked, `tag` and `tags`: they are the same object under two
|
||||
/// argument names, and looking at only the singular is how `set --tags` went years
|
||||
/// without anybody deciding whether it wanted a rule.
|
||||
#[test]
|
||||
fn no_tag_taking_option_is_missing() {
|
||||
let mut seen = 0;
|
||||
for (path, arg) in every_argument() {
|
||||
if arg.get_id().as_str() != "tag" {
|
||||
if !matches!(arg.get_id().as_str(), "tag" | "tags") {
|
||||
continue;
|
||||
}
|
||||
seen += 1;
|
||||
@@ -440,13 +475,18 @@ mod tests {
|
||||
continue;
|
||||
};
|
||||
|
||||
let pair = (name.as_str(), long);
|
||||
assert!(
|
||||
TAG_FLAGS.contains(&long),
|
||||
"`worklane {name} --{long}` takes a tag but is not in TAG_FLAGS"
|
||||
TAG_FLAGS.contains(&pair) || TAG_LIST_FLAGS.contains(&pair),
|
||||
"`worklane {name} --{long}` takes a tag, so it belongs in TAG_FLAGS if one \
|
||||
tag is the ordinary value and TAG_LIST_FLAGS if the value is the whole list"
|
||||
);
|
||||
}
|
||||
|
||||
assert_eq!(seen, 3, "expected ls --tag, tags add and tags set");
|
||||
assert_eq!(
|
||||
seen, 6,
|
||||
"expected ls --tag, tags add, tags set, add --tags, set --tags and append --tags"
|
||||
);
|
||||
}
|
||||
|
||||
/// **Every rule naming an option has to say which command it belongs to.** A bare
|
||||
@@ -472,8 +512,30 @@ mod tests {
|
||||
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}");
|
||||
|
||||
// Every list that names a top-level command, not only the ticket ones. The others
|
||||
// were reachable only through the rule counts below, which fail with `expected 3,
|
||||
// got 4` and name nothing: a stale entry is a `complete` line whose condition never
|
||||
// matches, so fish offers nothing and says nothing about why.
|
||||
let top = TICKET_COMMANDS
|
||||
.iter()
|
||||
.chain(TICKET_SECOND_COMMANDS.iter())
|
||||
.chain(CAMPAIGN_COMMANDS.iter())
|
||||
.copied()
|
||||
.chain(TAG_FLAGS.iter().map(|(command, _)| *command));
|
||||
|
||||
for name in top {
|
||||
assert!(known.contains(&name), "no such subcommand: {name}");
|
||||
}
|
||||
|
||||
for (parent, child) in CAMPAIGN_NESTED_COMMANDS.iter().chain(TAG_NESTED_COMMANDS.iter()) {
|
||||
let sub = cli
|
||||
.find_subcommand(parent)
|
||||
.unwrap_or_else(|| panic!("no such subcommand: {parent}"));
|
||||
assert!(
|
||||
sub.find_subcommand(child).is_some(),
|
||||
"`worklane {parent}` has no `{child}` subcommand"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -587,10 +649,16 @@ mod tests {
|
||||
.filter(|line| line.contains("(worklane tags"))
|
||||
.collect();
|
||||
|
||||
// **Hardcoded on purpose, and not derivable from the lists above.** This number is
|
||||
// what catches an entry naming a command or a flag that does not exist: the walkers
|
||||
// go clap → list and never see an extra, so a bogus `("bogus", "nope")` in
|
||||
// `TAG_FLAGS` produces a fourth rule and only this count notices. Writing it as
|
||||
// `TAG_FLAGS.len() + TAG_NESTED_COMMANDS.len()` would grow with the bogus entry and
|
||||
// pass, which is the improvement to not make.
|
||||
assert_eq!(
|
||||
reading.len(),
|
||||
2,
|
||||
"expected the ls --tag rule and the tags set one: {reading:?}"
|
||||
3,
|
||||
"expected the ls --tag rule, the append --tags one and the tags set one: {reading:?}"
|
||||
);
|
||||
for line in reading {
|
||||
assert!(line.contains("(worklane tags | cut -f1,3)"), "{line}");
|
||||
|
||||
+358
-129
@@ -2,7 +2,7 @@ use anyhow::{Result, anyhow};
|
||||
use chrono::Local;
|
||||
use std::collections::BTreeMap;
|
||||
use std::fs;
|
||||
use std::io::{BufRead, IsTerminal, Write};
|
||||
use std::io::{BufRead, IsTerminal};
|
||||
use std::path::Path;
|
||||
|
||||
use crate::campaign::*;
|
||||
@@ -15,12 +15,12 @@ use crate::install;
|
||||
use crate::tag::{TAGS_FILE, TagIndex, tags_path};
|
||||
use crate::util::*;
|
||||
|
||||
pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
pub fn cmd_init(start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let dir = start.canonicalize().unwrap_or_else(|_| start.to_path_buf());
|
||||
let worklane_dir = dir.join(".worklane");
|
||||
|
||||
if worklane_dir.exists() {
|
||||
println!("worklane already initialized in: {}", worklane_dir.display());
|
||||
sink.writeln(&format!("worklane already initialized in: {}", worklane_dir.display()))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -42,11 +42,11 @@ pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
// directory was made three lines ago, so there is nothing here to truncate.
|
||||
fs::write(tags_path(&worklane_dir), TagIndex::default().render())?;
|
||||
|
||||
println!("Initialized worklane in: {}", worklane_dir.display());
|
||||
sink.writeln(&format!("Initialized worklane in: {}", worklane_dir.display()))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path, sink: &mut Sink) -> 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. Ahead of the
|
||||
// `--ids` branch too: a completion that quietly listed the whole board because the
|
||||
@@ -58,17 +58,18 @@ pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
let uuid = campaign.as_ref().map(|campaign| campaign.uuid.as_str());
|
||||
let tag = args.tag.as_deref();
|
||||
let priority_filter = args.priority;
|
||||
let colored = sink.use_color;
|
||||
|
||||
if args.ids {
|
||||
return list_ids(args.status, priority_filter, uuid, tag, worklane_dir);
|
||||
return list_ids(sink, args.status, priority_filter, uuid, tag, worklane_dir);
|
||||
}
|
||||
|
||||
if let Some(campaign) = &campaign {
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Members of campaign ({}) {}\n",
|
||||
color_text(short_id(&campaign.uuid), Color::Red),
|
||||
color_text(&campaign.title, Color::Green),
|
||||
);
|
||||
paint(short_id(&campaign.uuid), Color::Red, colored),
|
||||
paint(&campaign.title, Color::Green, colored),
|
||||
))?;
|
||||
}
|
||||
|
||||
if let Some(status) = args.status {
|
||||
@@ -92,16 +93,16 @@ pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
items.sort_by(|a, b| by_status_order(status, a, b));
|
||||
|
||||
if items.is_empty() {
|
||||
println!("No tickets in '{}' status.", name);
|
||||
sink.writeln(&format!("No tickets in '{}' status.", name))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
println!("Tickets in '{}' status:\n", name);
|
||||
display_ticket_items(&items);
|
||||
sink.writeln(&format!("Tickets in '{}' status:\n", name))?;
|
||||
display_ticket_items(sink, &items)?;
|
||||
} else {
|
||||
// List all statuses with their ticket counts
|
||||
let statuses = status_dirs();
|
||||
println!("Tickets by status:\n");
|
||||
sink.writeln("Tickets by status:\n")?;
|
||||
for status in &statuses {
|
||||
let status_path = worklane_dir.join(status);
|
||||
if !status_path.exists() {
|
||||
@@ -110,7 +111,7 @@ pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
let items = filtered(collect_ticket_items(&status_path)?, priority_filter, uuid, tag);
|
||||
let count = items.len();
|
||||
let label = if count == 1 { "ticket" } else { "tickets" };
|
||||
println!(" [{}] {} {}", status.to_uppercase(), count, label);
|
||||
sink.writeln(&format!(" [{}] {} {}", status.to_uppercase(), count, label))?;
|
||||
}
|
||||
|
||||
// Show all tickets except the two terminal statuses, grouped by status. Over
|
||||
@@ -134,9 +135,9 @@ pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
continue;
|
||||
}
|
||||
let status_header =
|
||||
color_text(&format!("[{}]", status.as_str().to_uppercase()), Color::Orange);
|
||||
println!("\n{}", status_header);
|
||||
display_ticket_items(&items);
|
||||
paint(&format!("[{}]", status.as_str().to_uppercase()), Color::Orange, colored);
|
||||
sink.writeln(&format!("\n{}", status_header))?;
|
||||
display_ticket_items(sink, &items)?;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -160,6 +161,7 @@ pub fn cmd_ls(args: &LsArgs, worklane_dir: &Path) -> Result<()> {
|
||||
/// 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(
|
||||
sink: &mut Sink,
|
||||
status: Option<Status>,
|
||||
level: Option<u8>,
|
||||
campaign: Option<&str>,
|
||||
@@ -181,7 +183,7 @@ fn list_ids(
|
||||
let mut items = filtered(collect_ticket_items(&status_path)?, level, campaign, tag);
|
||||
items.sort_by(|a, b| by_status_order(status, a, b));
|
||||
for item in items {
|
||||
println!("{}\t{}", item.id, item.title);
|
||||
sink.writeln(&format!("{}\t{}", item.id, item.title))?;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -243,7 +245,7 @@ fn filter_by_priority(items: Vec<TicketItem>, level: Option<u8>) -> Vec<TicketIt
|
||||
}
|
||||
}
|
||||
|
||||
pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_add(args: &AddArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let AddArgs {
|
||||
title,
|
||||
description,
|
||||
@@ -344,33 +346,33 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
|
||||
// format allows: duplicate titles are supported and `add_allows_duplicate_titles`
|
||||
// pins it. `cmd_campaign_add` deliberately does not carry it either. What is left is
|
||||
// the write's own failure, named with the ticket and the path the way the other
|
||||
// writes in the tree name them.
|
||||
fs::write(&filepath, body).map_err(|e| {
|
||||
anyhow!("Could not write ticket '{}' at {}: {}", title, filepath.display(), e)
|
||||
})?;
|
||||
// writes in the tree name them. Staged like them too: there is no existing content
|
||||
// to corrupt, but a partial file in backlog is a ticket the listing would read, so
|
||||
// the same writer as every edit is the one that makes the new file appear whole.
|
||||
write_then_replace(&worklane_dir, &filepath, &filename, &body, TICKET, title)?;
|
||||
|
||||
println!("Created ticket: {}", filename);
|
||||
sink.writeln(&format!("Created ticket: {}", filename))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
pub fn cmd_show(search: &str, worklane_dir: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let colored = sink.use_color;
|
||||
let (_status, title, content) = resolve_ticket(search, worklane_dir)?;
|
||||
let ticket_uuid = parse_ticket_field(&content, "ID");
|
||||
// Read before anything is printed, so a board that cannot be read fails instead of
|
||||
// half printing a ticket.
|
||||
// Read before anything is printed, so a board that cannot be read fails instead of recover.
|
||||
let resolved = resolved_for(&content, worklane_dir)?;
|
||||
|
||||
// The only title in the output: content_trim_colored used to print it a second
|
||||
// The only title in the output: content_trim used to print it a second
|
||||
// time from the file content. Green per the colour guideline, and the rule is
|
||||
// measured in characters so a non-ASCII title is not over-drawn.
|
||||
println!("{}", color_text(&title, Color::Green));
|
||||
println!("{}", "─".repeat(title.chars().count()));
|
||||
println!("\n{}", content_trim_colored(&content, &resolved));
|
||||
sink.writeln(&paint(&title, Color::Green, colored))?;
|
||||
sink.writeln(&"─".repeat(title.chars().count()))?;
|
||||
sink.writeln(&format!("\n{}", content_trim(&content, colored, &resolved)))?;
|
||||
|
||||
if ticket_uuid != "_Not set_" {
|
||||
let entries = read_history(worklane_dir, &ticket_uuid)?;
|
||||
let formatted = format_history(&entries);
|
||||
println!("{}", formatted);
|
||||
sink.writeln(&formatted)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -598,7 +600,7 @@ fn check_dependents(worklane_dir: &Path, uuid: &str, title: &str) -> Result<()>
|
||||
/// 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(args: &MvArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_mv(args: &MvArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let MvArgs {
|
||||
ticket: ticket_id,
|
||||
status: target,
|
||||
@@ -657,10 +659,10 @@ pub fn cmd_mv(args: &MvArgs, start: &Path) -> Result<()> {
|
||||
let recorded = parse_ticket_field(&resolved, "Status");
|
||||
|
||||
if recorded == target_status {
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Ticket is already in '{}' status.",
|
||||
color_text(target_status, Color::Orange)
|
||||
);
|
||||
paint(target_status, Color::Orange, sink.use_color)
|
||||
))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -679,12 +681,12 @@ pub fn cmd_mv(args: &MvArgs, start: &Path) -> Result<()> {
|
||||
&corrected,
|
||||
)?;
|
||||
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Corrected Status field on '{}': said {}, but the file sits in {}.",
|
||||
color_text(&title, Color::Green),
|
||||
color_text(&recorded, Color::Orange),
|
||||
color_text(target_status, Color::Orange)
|
||||
);
|
||||
paint(&title, Color::Green, sink.use_color),
|
||||
paint(&recorded, Color::Orange, sink.use_color),
|
||||
paint(target_status, Color::Orange, sink.use_color)
|
||||
))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -747,12 +749,12 @@ pub fn cmd_mv(args: &MvArgs, start: &Path) -> Result<()> {
|
||||
&reason,
|
||||
)?;
|
||||
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Moved ticket '{}' from {} to {}",
|
||||
color_text(&title, Color::Green),
|
||||
color_text(¤t_status, Color::Orange),
|
||||
color_text(target_status, Color::Orange),
|
||||
);
|
||||
paint(&title, Color::Green, sink.use_color),
|
||||
paint(¤t_status, Color::Orange, sink.use_color),
|
||||
paint(target_status, Color::Orange, sink.use_color),
|
||||
))?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -763,6 +765,7 @@ pub fn cmd_comment(
|
||||
actor: &Option<String>,
|
||||
actor_from_git: bool,
|
||||
start: &Path,
|
||||
sink: &mut Sink,
|
||||
) -> Result<()> {
|
||||
if body.is_empty() {
|
||||
return Err(anyhow!("Comment body is required."));
|
||||
@@ -785,7 +788,7 @@ pub fn cmd_comment(
|
||||
"",
|
||||
)?;
|
||||
|
||||
println!("Comment added to '{}' ({})", title, filename);
|
||||
sink.writeln(&format!("Comment added to '{}' ({})", title, filename))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -928,8 +931,8 @@ fn apply(content: &mut String, changed: &mut Vec<&'static str>, field: &'static
|
||||
}
|
||||
}
|
||||
|
||||
fn report(fields: &[&str], title: &str, verb: &str) {
|
||||
report_in(fields, title, Color::Green, verb)
|
||||
fn report(sink: &mut Sink, fields: &[&str], title: &str, verb: &str) -> Result<()> {
|
||||
report_in(sink, fields, title, Color::Green, verb)
|
||||
}
|
||||
|
||||
/// The same, for a subject that is not a title.
|
||||
@@ -939,16 +942,28 @@ fn report(fields: &[&str], title: &str, verb: &str) {
|
||||
/// not one of them. The colour is passed in rather than decided here, which is the trade
|
||||
/// `paint` makes with `color_text`, and it keeps the wording in one place so a tag reports
|
||||
/// a no-op in the same words a ticket does.
|
||||
fn report_in(fields: &[&str], title: &str, color: Color, verb: &str) {
|
||||
fn report_in(
|
||||
sink: &mut Sink,
|
||||
fields: &[&str],
|
||||
title: &str,
|
||||
color: Color,
|
||||
verb: &str,
|
||||
) -> Result<()> {
|
||||
if fields.is_empty() {
|
||||
println!("No changes to '{}'", color_text(title, color));
|
||||
return;
|
||||
sink.writeln(&format!("No changes to '{}'", sink.color(title, color)))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
println!("{} {} on '{}'", verb, fields.join(", "), color_text(title, color));
|
||||
sink.writeln(&format!(
|
||||
"{} {} on '{}'",
|
||||
verb,
|
||||
fields.join(", "),
|
||||
sink.color(title, color)
|
||||
))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_set(args: &SetArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
if let Some(field) = args.contested() {
|
||||
let name = field.name();
|
||||
return Err(anyhow!(
|
||||
@@ -1010,7 +1025,7 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
}
|
||||
|
||||
if changed.is_empty() && cleared.is_empty() {
|
||||
report(&[], &title, "Updated");
|
||||
report(sink, &[], &title, "Updated")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -1037,10 +1052,10 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
|
||||
let shown = args.title.clone().unwrap_or(title);
|
||||
if !changed.is_empty() {
|
||||
report(&changed, &shown, "Updated");
|
||||
report(sink, &changed, &shown, "Updated")?;
|
||||
}
|
||||
if !cleared.is_empty() {
|
||||
report(&cleared, &shown, "Cleared");
|
||||
report(sink, &cleared, &shown, "Cleared")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -1061,7 +1076,7 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
|
||||
/// for a ticket it is filing, which is a default for something new; an owner taken away
|
||||
/// says nobody owns this, and putting the person running the command there instead would
|
||||
/// hand them a ticket they were giving up.
|
||||
pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_chown(args: &ChownArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let (ticket_id, user) = args.target().ok_or_else(|| {
|
||||
anyhow!("chown takes a user and a ticket, or --clear with the ticket alone")
|
||||
})?;
|
||||
@@ -1073,7 +1088,7 @@ pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
|
||||
let content = set_metadata_field(&original, "Owner", user.unwrap_or(NOT_SET), &title)?;
|
||||
|
||||
if content == original {
|
||||
report(&[], &title, "Updated");
|
||||
report(sink, &[], &title, "Updated")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -1097,11 +1112,11 @@ pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
|
||||
Some(_) => "Updated",
|
||||
None => "Cleared",
|
||||
};
|
||||
report(&["owner"], &title, verb);
|
||||
report(sink, &["owner"], &title, verb)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cmd_append(args: &AppendArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_append(args: &AppendArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
@@ -1120,12 +1135,83 @@ pub fn cmd_append(args: &AppendArgs, start: &Path) -> Result<()> {
|
||||
changed.push(section.label);
|
||||
}
|
||||
|
||||
// Through `apply`, unlike the sections above: appending a section always adds
|
||||
// something, and appending a tag the ticket already carries is the no-op this flag
|
||||
// exists to make free.
|
||||
if !args.tags.is_empty() {
|
||||
let next =
|
||||
set_metadata_field(&content, "Tags", &appended_tags(&content, &args.tags)?, &title)?;
|
||||
apply(&mut content, &mut changed, "tags", next);
|
||||
}
|
||||
|
||||
// The only way to reach here with nothing to write is a `--tags` the ticket already
|
||||
// satisfied, since every other field on this command adds or refuses. Reported in the
|
||||
// words `set` uses for the same answer.
|
||||
if changed.is_empty() {
|
||||
report(sink, &[], &title, "Appended to")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
||||
|
||||
report(&changed, &title, "Appended to");
|
||||
// Tags are logged wherever they change, so the one command that adds to them without
|
||||
// replacing them logs too. Same shape as `set`'s, down to the before and after being
|
||||
// read off the field rather than off the flag: what the entry records is where the
|
||||
// field went, not what this call asked for.
|
||||
if changed.contains(&"tags") {
|
||||
write_entry(
|
||||
&worklane_dir,
|
||||
&uuid,
|
||||
Kind::Tags,
|
||||
&change(
|
||||
&parse_ticket_field(&original, "Tags"),
|
||||
&parse_ticket_field(&content, "Tags"),
|
||||
),
|
||||
&resolve_actor(args.actor.as_deref(), args.actor_from_git),
|
||||
"",
|
||||
)?;
|
||||
}
|
||||
|
||||
report(sink, &changed, &title, "Appended to")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The ticket's tags with the call's merged onto the end, or the refusal for a call that
|
||||
/// named none.
|
||||
///
|
||||
/// A tag the ticket already carries is not added a second time, which is the whole
|
||||
/// difference from `set --tags`: appending means the caller does not have to know what is
|
||||
/// there already, so naming one that is reports no change rather than doubling it. New
|
||||
/// ones go on the end in the order they were given rather than sorted, so the field goes
|
||||
/// on reading as what was added when.
|
||||
///
|
||||
/// The values are split on commas the way the stored field is, so `--tags "bug, tui"`
|
||||
/// names two tags and matches the two a ticket carrying them already holds. Without that
|
||||
/// the pair would land as a single tag nothing can filter by, which is what `tag_value`
|
||||
/// refuses outright for the vocabulary; here it is split instead, because `set --tags`
|
||||
/// takes the comma form on this same field and refusing it on its counterpart would be a
|
||||
/// trap.
|
||||
///
|
||||
/// A call whose every value comes out blank is refused rather than written, the way
|
||||
/// [`appended_items`] refuses one: `--tags ","` names nothing, and writing the field back
|
||||
/// unchanged would report an append that never happened. Emptying the field is
|
||||
/// `set --clear tags`.
|
||||
fn appended_tags(content: &str, values: &[String]) -> Result<String> {
|
||||
let added: Vec<String> = values.iter().flat_map(|value| split_tags(value)).collect();
|
||||
if added.is_empty() {
|
||||
return Err(anyhow!("Nothing to append to the tags: every value given was blank"));
|
||||
}
|
||||
|
||||
let mut tags = parse_tags(content);
|
||||
for tag in added {
|
||||
if !tags.contains(&tag) {
|
||||
tags.push(tag);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(tags.join(", "))
|
||||
}
|
||||
|
||||
/// Record a relation from one ticket to another.
|
||||
///
|
||||
/// One side is written and the inverse is derived wherever it is shown. `blocked by`
|
||||
@@ -1210,7 +1296,7 @@ fn find_relation(
|
||||
}
|
||||
}
|
||||
|
||||
pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_relate(args: &RelateArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, original) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
let uuid = parse_ticket_field(&original, "ID");
|
||||
@@ -1303,7 +1389,7 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
}
|
||||
|
||||
if items.is_empty() && dropped.is_empty() {
|
||||
report(&[], &title, "Recorded");
|
||||
report(sink, &[], &title, "Recorded")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -1336,10 +1422,10 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
|
||||
|
||||
if !changed.is_empty() {
|
||||
report(&changed, &title, "Recorded");
|
||||
report(sink, &changed, &title, "Recorded")?;
|
||||
}
|
||||
if !cleared.is_empty() {
|
||||
report(&cleared, &title, "Cleared");
|
||||
report(sink, &cleared, &title, "Cleared")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -1351,7 +1437,7 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
|
||||
/// Written through `write_then_replace` rather than `fs::write`, so a failure leaves no
|
||||
/// half-written campaign behind. `cmd_add` predates that primitive and still uses the
|
||||
/// plain write; the difference is noted on the ticket rather than fixed here.
|
||||
pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let CampaignAddArgs {
|
||||
title,
|
||||
description,
|
||||
@@ -1382,7 +1468,7 @@ pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
|
||||
|
||||
write_then_replace(&worklane_dir, &path, &filename, &body, CAMPAIGN, title)?;
|
||||
|
||||
println!("Created campaign: {}", filename);
|
||||
sink.writeln(&format!("Created campaign: {}", filename))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1392,26 +1478,26 @@ pub fn cmd_campaign_add(args: &CampaignAddArgs, start: &Path) -> Result<()> {
|
||||
/// scan per row rather than one scan reused, and it is deliberate: the alternative is a
|
||||
/// map from campaign uuid to counts built in a single walk, which is worth writing when
|
||||
/// a board has enough campaigns to notice and is premature now.
|
||||
pub fn cmd_campaign_ls(worklane_dir: &Path, ids: bool) -> Result<()> {
|
||||
pub fn cmd_campaign_ls(worklane_dir: &Path, ids: bool, sink: &mut Sink) -> Result<()> {
|
||||
let index = CampaignIndex::load(worklane_dir)?;
|
||||
let colored = sink.use_color;
|
||||
|
||||
// Ahead of the empty check, which prints prose: a completion must offer nothing
|
||||
// rather than offer a sentence, the same bargain `list_ids` takes with a missing
|
||||
// status directory.
|
||||
if ids {
|
||||
for campaign in index.iter() {
|
||||
println!("{}\t{}", short_id(&campaign.uuid), campaign.title);
|
||||
sink.writeln(&format!("{}\t{}", short_id(&campaign.uuid), campaign.title))?;
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if index.is_empty() {
|
||||
println!("No campaigns yet. `worklane campaign add --title` files one.");
|
||||
sink.writeln("No campaigns yet. `worklane campaign add --title` files one.")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let colored = should_use_colors();
|
||||
println!("Campaigns:\n");
|
||||
sink.writeln("Campaigns:\n")?;
|
||||
|
||||
for campaign in index.iter() {
|
||||
let standing = Standing::of(&members(worklane_dir, &campaign.uuid)?);
|
||||
@@ -1432,14 +1518,14 @@ pub fn cmd_campaign_ls(worklane_dir: &Path, ids: bool) -> Result<()> {
|
||||
false => String::new(),
|
||||
};
|
||||
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
" ({}) {}{} | {}{}",
|
||||
paint(short_id(&campaign.uuid), Color::Red, colored),
|
||||
codename,
|
||||
campaign.title,
|
||||
standing.label(),
|
||||
state,
|
||||
);
|
||||
))?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -1479,7 +1565,7 @@ pub fn cmd_campaign_ls(worklane_dir: &Path, ids: bool) -> Result<()> {
|
||||
///
|
||||
/// Every status, done included, for the reason `ls --ids` includes it: a tag retired months
|
||||
/// ago is still part of the answer to what the vocabulary has been.
|
||||
pub fn cmd_tags(worklane_dir: &Path) -> Result<()> {
|
||||
pub fn cmd_tags(worklane_dir: &Path, sink: &mut Sink) -> Result<()> {
|
||||
// Through the same `load` `tags add` uses, so a file that is there and cannot be read
|
||||
// is an error here too. The listing is the one tag command that could go on without the
|
||||
// file, and reporting a vocabulary while silently treating a broken file as no file is
|
||||
@@ -1507,8 +1593,8 @@ pub fn cmd_tags(worklane_dir: &Path) -> Result<()> {
|
||||
|
||||
for (tag, count) in counts {
|
||||
match index.summary(&tag) {
|
||||
Some(summary) => println!("{tag}\t{count}\t{summary}"),
|
||||
None => println!("{tag}\t{count}"),
|
||||
Some(summary) => sink.writeln(&format!("{tag}\t{count}\t{summary}"))?,
|
||||
None => sink.writeln(&format!("{tag}\t{count}"))?,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1531,7 +1617,7 @@ pub fn cmd_tags(worklane_dir: &Path) -> Result<()> {
|
||||
/// The whole file is re-rendered from the parsed vocabulary, so declaring a tag also
|
||||
/// re-sorts the file and rewrites its preamble. That is why an unreadable file is an error
|
||||
/// in `TagIndex::load` rather than an empty vocabulary: here, empty would mean erased.
|
||||
pub fn cmd_tag_add(args: &TagAddArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_tag_add(args: &TagAddArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let mut index = TagIndex::load(&worklane_dir)?;
|
||||
|
||||
@@ -1559,7 +1645,10 @@ pub fn cmd_tag_add(args: &TagAddArgs, start: &Path) -> Result<()> {
|
||||
|
||||
// The tag in its own colour, which is the colour it is drawn in on every card and in
|
||||
// every listing: `tag_color` is a pure function of the word.
|
||||
println!("Declared tag: {}", color_text(&args.tag, tag_color(&args.tag)));
|
||||
sink.writeln(&format!(
|
||||
"Declared tag: {}",
|
||||
paint(&args.tag, tag_color(&args.tag), sink.use_color)
|
||||
))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1577,7 +1666,7 @@ pub fn cmd_tag_add(args: &TagAddArgs, start: &Path) -> Result<()> {
|
||||
/// The no-op compares the rendered file rather than the annotation, which is what `apply`
|
||||
/// does for a ticket: the file is the thing that would be written, so it is the thing worth
|
||||
/// asking whether the write would change.
|
||||
pub fn cmd_tag_set(args: &TagSetArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_tag_set(args: &TagSetArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let mut index = TagIndex::load(&worklane_dir)?;
|
||||
|
||||
@@ -1606,7 +1695,7 @@ pub fn cmd_tag_set(args: &TagSetArgs, start: &Path) -> Result<()> {
|
||||
)?;
|
||||
}
|
||||
|
||||
report_in(&changed, &args.tag, tag_color(&args.tag), "Updated");
|
||||
report_in(sink, &changed, &args.tag, tag_color(&args.tag), "Updated")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1649,7 +1738,7 @@ pub fn cmd_tag_set(args: &TagSetArgs, start: &Path) -> Result<()> {
|
||||
/// the heading, so an insertion path here would be reachable only from a hand-edited file:
|
||||
/// that is the opposite of the Relations case, where `add` writes nothing and the insertion
|
||||
/// is the only path there is.
|
||||
pub fn cmd_campaign_set(args: &CampaignSetArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_campaign_set(args: &CampaignSetArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let campaign = resolve_campaign(&args.campaign, &worklane_dir)?;
|
||||
let title = campaign.title.clone();
|
||||
@@ -1693,14 +1782,14 @@ pub fn cmd_campaign_set(args: &CampaignSetArgs, start: &Path) -> Result<()> {
|
||||
}
|
||||
|
||||
if changed.is_empty() {
|
||||
report(&[], &title, "Updated");
|
||||
report(sink, &[], &title, "Updated")?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let renamed = changed.contains(&"title").then_some(()).and(args.title.as_ref());
|
||||
save_campaign(&worklane_dir, &campaign.uuid, &title, renamed, &content)?;
|
||||
|
||||
report(&changed, args.title.as_ref().unwrap_or(&title), "Updated");
|
||||
report(sink, &changed, args.title.as_ref().unwrap_or(&title), "Updated")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1717,7 +1806,7 @@ pub fn cmd_campaign_set(args: &CampaignSetArgs, start: &Path) -> Result<()> {
|
||||
///
|
||||
/// One section, so there is no loop and no list to report: what changed is the description
|
||||
/// or the call failed.
|
||||
pub fn cmd_campaign_append(args: &CampaignAppendArgs, start: &Path) -> Result<()> {
|
||||
pub fn cmd_campaign_append(args: &CampaignAppendArgs, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let campaign = resolve_campaign(&args.campaign, &worklane_dir)?;
|
||||
|
||||
@@ -1726,7 +1815,7 @@ pub fn cmd_campaign_append(args: &CampaignAppendArgs, start: &Path) -> Result<()
|
||||
|
||||
save_campaign(&worklane_dir, &campaign.uuid, &campaign.title, None, &content)?;
|
||||
|
||||
report(&[DESCRIPTION.label], &campaign.title, "Appended to");
|
||||
report(sink, &[DESCRIPTION.label], &campaign.title, "Appended to")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1735,28 +1824,35 @@ pub fn cmd_campaign_append(args: &CampaignAppendArgs, start: &Path) -> Result<()
|
||||
/// Every status is shown, done included, unlike `ls`, which leaves done out of its
|
||||
/// listing. A campaign's whole point is what is finished against what is left, so
|
||||
/// hiding the finished half would hide the answer.
|
||||
pub fn cmd_campaign_show(search: &str, worklane_dir: &Path) -> Result<()> {
|
||||
pub fn cmd_campaign_show(search: &str, worklane_dir: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let colored = sink.use_color;
|
||||
let campaign = resolve_campaign(search, worklane_dir)?;
|
||||
|
||||
println!("{}", color_text(&campaign.title, Color::Green));
|
||||
println!("{}", "─".repeat(campaign.title.chars().count()));
|
||||
sink.writeln(&paint(&campaign.title, Color::Green, colored))?;
|
||||
sink.writeln(&"─".repeat(campaign.title.chars().count()))?;
|
||||
// No relations and no campaign of its own: a campaign is not a ticket, and neither
|
||||
// belongs to one.
|
||||
println!("\n{}", content_trim_colored(&campaign.content, &Resolved::default()));
|
||||
sink.writeln(&format!(
|
||||
"\n{}",
|
||||
content_trim(&campaign.content, colored, &Resolved::default())
|
||||
))?;
|
||||
|
||||
let grouped = members(worklane_dir, &campaign.uuid)?;
|
||||
let standing = Standing::of(&grouped);
|
||||
|
||||
println!("{}", color_text("Members", Color::Orange));
|
||||
println!("{}", "─".repeat("Members".chars().count()));
|
||||
println!("\n{}", standing.label());
|
||||
sink.writeln(&paint("Members", Color::Orange, colored))?;
|
||||
sink.writeln(&"─".repeat("Members".chars().count()))?;
|
||||
sink.writeln(&format!("\n{}", standing.label()))?;
|
||||
|
||||
for (status, items) in &grouped {
|
||||
if items.is_empty() {
|
||||
continue;
|
||||
}
|
||||
println!("\n{}", color_text(&format!("[{}]", status.to_uppercase()), Color::Orange));
|
||||
display_ticket_items(items);
|
||||
sink.writeln(&format!(
|
||||
"\n{}",
|
||||
paint(&format!("[{}]", status.to_uppercase()), Color::Orange, colored)
|
||||
))?;
|
||||
display_ticket_items(sink, items)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -1776,6 +1872,7 @@ pub fn cmd_assign(
|
||||
actor: &Option<String>,
|
||||
actor_from_git: bool,
|
||||
start: &Path,
|
||||
sink: &mut Sink,
|
||||
) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let campaign = resolve_campaign(campaign_search, &worklane_dir)?;
|
||||
@@ -1786,11 +1883,11 @@ pub fn cmd_assign(
|
||||
set_or_insert_metadata_field(&original, CAMPAIGN_FIELD, &campaign.uuid, TICKET, &title)?;
|
||||
|
||||
if content == original {
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Ticket '{}' is already in campaign '{}'",
|
||||
color_text(&title, Color::Green),
|
||||
paint(&title, Color::Green, sink.use_color),
|
||||
campaign.title,
|
||||
);
|
||||
))?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -1817,11 +1914,11 @@ pub fn cmd_assign(
|
||||
"",
|
||||
)?;
|
||||
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
"Assigned '{}' to campaign '{}'",
|
||||
color_text(&title, Color::Green),
|
||||
paint(&title, Color::Green, sink.use_color),
|
||||
campaign.title,
|
||||
);
|
||||
))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1832,7 +1929,7 @@ pub fn cmd_assign(
|
||||
/// reason: the opencode wrapper throws on the exit code and keeps stderr, so a list
|
||||
/// printed to stdout would be discarded and an agent would learn nothing. Prompting
|
||||
/// regardless would leave it blocked on a stdin that never closes.
|
||||
fn ask_which_criterion(criteria: &[Criterion], title: &str) -> Result<usize> {
|
||||
fn ask_which_criterion(sink: &mut Sink, criteria: &[Criterion], title: &str) -> Result<usize> {
|
||||
let listing = criteria_list(criteria);
|
||||
|
||||
if !std::io::stdin().is_terminal() {
|
||||
@@ -1843,11 +1940,14 @@ fn ask_which_criterion(criteria: &[Criterion], title: &str) -> Result<usize> {
|
||||
));
|
||||
}
|
||||
|
||||
println!("Acceptance criteria of '{}':", color_text(title, Color::Green));
|
||||
println!("{}", listing);
|
||||
sink.writeln(&format!(
|
||||
"Acceptance criteria of '{}':",
|
||||
paint(title, Color::Green, sink.use_color)
|
||||
))?;
|
||||
sink.writeln(&listing)?;
|
||||
// Either form, since find_criteria takes both.
|
||||
print!("Number or text: ");
|
||||
std::io::stdout().flush()?;
|
||||
sink.write("Number or text: ")?;
|
||||
sink.flush()?;
|
||||
|
||||
let mut answer = String::new();
|
||||
std::io::stdin().lock().read_line(&mut answer)?;
|
||||
@@ -1933,7 +2033,7 @@ fn resolve_criteria(criteria: &[Criterion], terms: &[String], title: &str) -> Re
|
||||
Ok(chosen)
|
||||
}
|
||||
|
||||
pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path, sink: &mut Sink) -> Result<()> {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
let (status, title, content) = resolve_ticket(&args.ticket, &worklane_dir)?;
|
||||
|
||||
@@ -1943,7 +2043,7 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
}
|
||||
|
||||
let chosen = match args.criteria.as_slice() {
|
||||
[] => vec![ask_which_criterion(&criteria, &title)?],
|
||||
[] => vec![ask_which_criterion(sink, &criteria, &title)?],
|
||||
terms => resolve_criteria(&criteria, terms, &title)?,
|
||||
};
|
||||
|
||||
@@ -1975,7 +2075,12 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
past.to_string()
|
||||
};
|
||||
|
||||
println!("{} {}: {}", state, offset + 1, color_text(&criterion.text, Color::Green));
|
||||
sink.writeln(&format!(
|
||||
"{} {}: {}",
|
||||
state,
|
||||
offset + 1,
|
||||
paint(&criterion.text, Color::Green, sink.use_color)
|
||||
))?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -1990,7 +2095,12 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
/// With no name, every shipped document is installed. Narrowing to one is the
|
||||
/// exception rather than the rule, so that a document added in a later version reaches
|
||||
/// anyone who already knows the command.
|
||||
pub fn cmd_install_skill(skill: Option<&str>, force: bool, print: bool) -> Result<()> {
|
||||
pub fn cmd_install_skill(
|
||||
skill: Option<&str>,
|
||||
force: bool,
|
||||
print: bool,
|
||||
sink: &mut Sink,
|
||||
) -> Result<()> {
|
||||
if print {
|
||||
// Printing every document would run them together into something that is not
|
||||
// any of them, and the point of `--print` is to diff one against its copy.
|
||||
@@ -2000,7 +2110,7 @@ pub fn cmd_install_skill(skill: Option<&str>, force: bool, print: bool) -> Resul
|
||||
install::skill_names()
|
||||
)
|
||||
})?;
|
||||
print!("{}", install::skill_named(name)?.content);
|
||||
sink.write(install::skill_named(name)?.content)?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -2010,14 +2120,14 @@ pub fn cmd_install_skill(skill: Option<&str>, force: bool, print: bool) -> Resul
|
||||
};
|
||||
|
||||
let root = install::skills_root()?;
|
||||
let written = install_each(&chosen, &root, force, |asset| {
|
||||
let written = install_each(sink, &chosen, &root, force, |asset| {
|
||||
format!("worklane install-skill {} --print", asset.name)
|
||||
})?;
|
||||
|
||||
// Once, and only when something arrived: repeating it per document would make the
|
||||
// instruction look like part of each outcome rather than the one thing to do next.
|
||||
if written {
|
||||
println!("Claude Code and opencode pick it up on their next session");
|
||||
sink.writeln("Claude Code and opencode pick it up on their next session")?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -2033,6 +2143,7 @@ pub fn cmd_install_skill(skill: Option<&str>, force: bool, print: bool) -> Resul
|
||||
/// each command has its own thing to say about what picks the asset up, and neither
|
||||
/// should say it once per asset.
|
||||
fn install_each(
|
||||
sink: &mut Sink,
|
||||
chosen: &[&install::Asset],
|
||||
root: &Path,
|
||||
force: bool,
|
||||
@@ -2043,15 +2154,26 @@ fn install_each(
|
||||
for asset in chosen {
|
||||
match asset.install(root, force)? {
|
||||
install::Outcome::Written(path) => {
|
||||
println!("Installed the {} {} to: {}", asset.name, asset.what, path.display());
|
||||
sink.writeln(&format!(
|
||||
"Installed the {} {} to: {}",
|
||||
asset.name,
|
||||
asset.what,
|
||||
path.display()
|
||||
))?;
|
||||
written = true;
|
||||
}
|
||||
install::Outcome::Unchanged(path) => {
|
||||
println!("Already up to date: {}", path.display());
|
||||
sink.writeln(&format!("Already up to date: {}", path.display()))?;
|
||||
}
|
||||
install::Outcome::Refused(path) => {
|
||||
println!("Differs from the version in this binary: {}", path.display());
|
||||
println!("Compare with `{}`, or overwrite with --force", compare(asset));
|
||||
sink.writeln(&format!(
|
||||
"Differs from the version in this binary: {}",
|
||||
path.display()
|
||||
))?;
|
||||
sink.writeln(&format!(
|
||||
"Compare with `{}`, or overwrite with --force",
|
||||
compare(asset)
|
||||
))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2064,29 +2186,136 @@ fn install_each(
|
||||
/// No name argument, where `install-skill` has an optional one: there is a single tool
|
||||
/// file, so a name could only be right or wrong, and `--print` needs no help deciding
|
||||
/// what to print.
|
||||
pub fn cmd_install_tool(force: bool, print: bool) -> Result<()> {
|
||||
pub fn cmd_install_tool(force: bool, print: bool, sink: &mut Sink) -> Result<()> {
|
||||
if print {
|
||||
print!("{}", install::TOOL.content);
|
||||
sink.write(install::TOOL.content)?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let chosen: Vec<&install::Asset> = install::TOOLS.iter().collect();
|
||||
let root = install::tools_root()?;
|
||||
let written =
|
||||
install_each(&chosen, &root, force, |_| "worklane install-tool --print".to_string())?;
|
||||
let written = install_each(sink, &chosen, &root, force, |_| {
|
||||
"worklane install-tool --print".to_string()
|
||||
})?;
|
||||
|
||||
// Not "on its next session", which is what the skills say: opencode reads its config
|
||||
// once at startup and does not reload it, so a running one keeps the tools it began
|
||||
// with. The second line is there because the file is executable and looks like it
|
||||
// needs a toolchain: it does not, it runs inside opencode.
|
||||
if written {
|
||||
println!(
|
||||
"opencode loads it in every project. Restart it: the config is read at startup and never reloaded"
|
||||
);
|
||||
println!(
|
||||
"Nothing else to install. It runs in opencode's own runtime, so neither Bun nor @opencode-ai/plugin is needed on this machine"
|
||||
);
|
||||
sink.writeln(
|
||||
"opencode loads it in every project. Restart it: the config is read at startup and never reloaded",
|
||||
)?;
|
||||
sink.writeln(
|
||||
"Nothing else to install. It runs in opencode's own runtime, so neither Bun nor @opencode-ai/plugin is needed on this machine",
|
||||
)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod sink_tests {
|
||||
use super::*;
|
||||
use crate::util::Sink;
|
||||
use std::fs;
|
||||
|
||||
/// A throwaway board, so a test can point a handler at a sink without touching the
|
||||
/// real one. Cleaned up at the end; a leftover here is an aborted test, not a
|
||||
/// fixture the suite has to keep alive.
|
||||
fn temp_worklane() -> std::path::PathBuf {
|
||||
let dir = std::env::temp_dir().join(format!("wl-sink-{}", uuid::Uuid::new_v4()));
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
for status in ["backlog", "committed", "reviewing", "done", "discarded"] {
|
||||
fs::create_dir_all(dir.join(status)).unwrap();
|
||||
}
|
||||
fs::create_dir_all(dir.join("campaigns")).unwrap();
|
||||
fs::write(dir.join("tags.md"), crate::tag::TagIndex::default().render()).unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
fn ticket(dir: &Path, status: &str, uuid: &str) {
|
||||
fs::write(
|
||||
dir.join(status).join(format!("{}_ticket.md", uuid)),
|
||||
format!(
|
||||
"# {u} title\n\
|
||||
\n\
|
||||
## Description\n\
|
||||
body\n\
|
||||
\n\
|
||||
## Metadata\n\
|
||||
\n\
|
||||
- **ID**: {u}\n\
|
||||
- **Priority**: 3\n\
|
||||
- **Tags**: _None_\n\
|
||||
- **Owner**: alice\n\
|
||||
- **Created At**: 2026-08-21 02:10:17\n\
|
||||
- **Status**: {status}\n",
|
||||
u = uuid,
|
||||
status = status,
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
/// A handler writes through the sink it is handed, and a caller can read the bytes
|
||||
/// back without a terminal or a real stdout.
|
||||
#[test]
|
||||
fn handler_writes_to_a_buffer() {
|
||||
let dir = temp_worklane();
|
||||
ticket(&dir, "backlog", "abc1234-def5678");
|
||||
|
||||
let args = LsArgs {
|
||||
status: None,
|
||||
priority: None,
|
||||
tag: None,
|
||||
campaign: None,
|
||||
ids: false,
|
||||
};
|
||||
|
||||
let mut buf = Vec::new();
|
||||
{
|
||||
let mut sink = Sink::buffer(&mut buf);
|
||||
cmd_ls(&args, &dir, &mut sink).unwrap();
|
||||
}
|
||||
|
||||
let out = String::from_utf8(buf).unwrap();
|
||||
// The short id, not swallowed by a terminal, and no colour escapes without a
|
||||
// colour sink.
|
||||
assert!(out.contains("abc1234"), "ticket id missing from:\n{out}");
|
||||
assert!(!out.contains('\u{1b}'), "unexpected colour in:\n{out}");
|
||||
|
||||
fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
|
||||
/// The same handler behind a coloured sink paints the id red, so the colour decision
|
||||
/// is the sink's and not the process's.
|
||||
#[test]
|
||||
fn handler_colours_when_the_sink_says_so() {
|
||||
let dir = temp_worklane();
|
||||
ticket(&dir, "backlog", "abc1234-def5678");
|
||||
|
||||
let args = LsArgs {
|
||||
status: None,
|
||||
priority: None,
|
||||
tag: None,
|
||||
campaign: None,
|
||||
ids: false,
|
||||
};
|
||||
|
||||
let mut buf = Vec::new();
|
||||
{
|
||||
let mut sink = Sink::new(Box::new(&mut buf), true);
|
||||
// The sink is the source of the colour decision: the same word it wraps
|
||||
// here is what the handler paints through `paint(.., sink.use_color)`.
|
||||
assert!(sink.color("abc1234", Color::Red).contains('\u{1b}'));
|
||||
cmd_ls(&args, &dir, &mut sink).unwrap();
|
||||
}
|
||||
|
||||
let out = String::from_utf8(buf).unwrap();
|
||||
assert!(out.contains("abc1234"), "ticket id missing from:\n{out}");
|
||||
assert!(out.contains('\u{1b}'), "expected colour in:\n{out}");
|
||||
|
||||
fs::remove_dir_all(&dir).ok();
|
||||
}
|
||||
}
|
||||
|
||||
+124
-21
@@ -162,7 +162,8 @@ pub fn skills_root() -> Result<PathBuf> {
|
||||
/// `NO_COLOR`. Checked against opencode 1.15.10.
|
||||
///
|
||||
/// Singular `tool`, though 1.15.10 loads `tools` as well: each was served in turn from a
|
||||
/// directory outside any project and registered all eleven worklane tools. The singular
|
||||
/// directory outside any project and registered every worklane tool the file carried,
|
||||
/// eleven at the time and twenty-one at the recheck. The singular
|
||||
/// is the spelling opencode's own documentation puts first, the way it writes `agent(s)`
|
||||
/// and `skill(s)`.
|
||||
///
|
||||
@@ -569,7 +570,7 @@ mod tests {
|
||||
}
|
||||
|
||||
/// The file name is the tool id prefix, not decoration: opencode names each tool as
|
||||
/// the file then the export, so a renamed file renames all eleven tools and every
|
||||
/// the file then the export, so a renamed file renames all twenty-one tools and every
|
||||
/// permission rule that mentions one.
|
||||
#[test]
|
||||
fn the_tool_lands_flat_in_the_root_under_the_name_that_prefixes_its_ids() {
|
||||
@@ -579,31 +580,18 @@ mod tests {
|
||||
assert_eq!(TOOL.relative, "worklane.ts");
|
||||
}
|
||||
|
||||
/// Every tool the file exports names a real subcommand.
|
||||
/// Every tool the file exports names a real subcommand path.
|
||||
///
|
||||
/// The guard the fish completion lists already have, pointed the other way: this
|
||||
/// catches a tool wrapping a command that has been renamed or dropped, which would
|
||||
/// fail only when an agent finally called it. It cannot catch the reverse, a
|
||||
/// subcommand the wrapper never grew a tool for, and the wrapper is behind by
|
||||
/// several: `relate`, `campaign`, `assign` and `tags` have no tool. That is its own
|
||||
/// ticket, and asserting it here would fail on a gap nobody has decided to close.
|
||||
/// fail only when an agent finally called it. The converse, a subcommand the wrapper
|
||||
/// never grew a tool for, is [`every_subcommand_outside_the_exceptions_has_a_tool`].
|
||||
#[test]
|
||||
fn every_tool_the_wrapper_exports_is_a_real_subcommand() {
|
||||
use clap::CommandFactory;
|
||||
let commands: Vec<String> = subcommand_paths();
|
||||
let exported = exported_tools();
|
||||
|
||||
let commands: Vec<String> = crate::Cli::command()
|
||||
.get_subcommands()
|
||||
.map(|command| command.get_name().to_string())
|
||||
.collect();
|
||||
|
||||
let exported: Vec<&str> = TOOL
|
||||
.content
|
||||
.lines()
|
||||
.filter_map(|line| line.strip_prefix("export const "))
|
||||
.filter_map(|rest| rest.split_whitespace().next())
|
||||
.collect();
|
||||
|
||||
assert_eq!(exported.len(), 11, "{exported:?}");
|
||||
assert_eq!(exported.len(), 21, "{exported:?}");
|
||||
for name in exported {
|
||||
assert!(
|
||||
commands.iter().any(|command| command == name),
|
||||
@@ -611,4 +599,119 @@ mod tests {
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The export names in the tool file: one per `export const`, which is what makes
|
||||
/// them tool ids once opencode prefixes its file name.
|
||||
fn exported_tools() -> Vec<&'static str> {
|
||||
TOOL.content
|
||||
.lines()
|
||||
.filter_map(|line| line.strip_prefix("export const "))
|
||||
.filter_map(|rest| rest.split_whitespace().next())
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Every subcommand as the wrapper spells it: the CLI path joined with `_`, since
|
||||
/// that is how an export name has to be spelled to be an identifier. So
|
||||
/// `campaign set` is `campaign_set`, and the hyphen in `install-skill` becomes one.
|
||||
///
|
||||
/// Walked off clap rather than written out, the way every other guard here is:
|
||||
/// a hand-maintained list is the very drift this exists to catch.
|
||||
fn subcommand_paths() -> Vec<String> {
|
||||
use clap::CommandFactory;
|
||||
|
||||
fn walk(command: &clap::Command, prefix: Option<&str>, paths: &mut Vec<String>) {
|
||||
for sub in command.get_subcommands() {
|
||||
let name = sub.get_name();
|
||||
if name == "help" {
|
||||
continue;
|
||||
}
|
||||
|
||||
let path = match prefix {
|
||||
Some(prefix) => format!("{prefix}_{name}"),
|
||||
None => name.to_string(),
|
||||
};
|
||||
let path = path.replace('-', "_");
|
||||
walk(sub, Some(&path), paths);
|
||||
paths.push(path);
|
||||
}
|
||||
}
|
||||
|
||||
let mut paths = Vec::new();
|
||||
walk(&crate::Cli::command(), None, &mut paths);
|
||||
paths
|
||||
}
|
||||
|
||||
/// Subcommands the wrapper deliberately does not carry, each with why it is left out.
|
||||
///
|
||||
/// Spelled the way [`subcommand_paths`] spells a path, so a renamed command leaves a
|
||||
/// stale entry behind rather than silently exempting nothing.
|
||||
const NO_TOOL: [(&str, &str); 6] = [
|
||||
(
|
||||
"campaign",
|
||||
"a bare `worklane campaign` is refused by the CLI, its subcommand is required: the five campaign_* tools are the command",
|
||||
),
|
||||
(
|
||||
"tui",
|
||||
"the board view is for a person: it takes over the terminal and returns only when quit",
|
||||
),
|
||||
(
|
||||
"completions",
|
||||
"writes a person's shell configuration, which is not an agent's call to make",
|
||||
),
|
||||
(
|
||||
"install_skill",
|
||||
"installs the skill documents themselves, so an agent running it would rewrite its own instructions mid-session",
|
||||
),
|
||||
(
|
||||
"install_tool",
|
||||
"installs this very wrapper, which opencode reads once at startup, so reinstalling from inside changes nothing until restart",
|
||||
),
|
||||
(
|
||||
"tags_ls",
|
||||
"prints exactly what the bare `worklane tags` listing prints, and the tags tool runs that",
|
||||
),
|
||||
];
|
||||
|
||||
/// The direction that went unguarded until now: every subcommand outside the
|
||||
/// exception list has a tool.
|
||||
///
|
||||
/// This is the gap e6e3a1b taught the README about and the completion lists have
|
||||
/// never had: a new subcommand reached clap, the completions and the skill, and
|
||||
/// stopped there, so an agent holding the tools could not call it at all and its
|
||||
/// only way to the command was to shell out, which is the thing the wrapper exists
|
||||
/// to avoid. Nothing else walks the wrapper against clap, so without this test the
|
||||
/// next command lands in the same silence.
|
||||
#[test]
|
||||
fn every_subcommand_outside_the_exceptions_has_a_tool() {
|
||||
let paths = subcommand_paths();
|
||||
let exported = exported_tools();
|
||||
|
||||
// Guard on the walker itself: if it stopped finding subcommands, both filters
|
||||
// below would pass on nothing.
|
||||
assert_eq!(paths.len(), 27, "{paths:?}");
|
||||
assert_eq!(exported.len(), 21, "{exported:?}");
|
||||
|
||||
let missing: Vec<&String> = paths
|
||||
.iter()
|
||||
.filter(|path| !NO_TOOL.iter().any(|(name, _)| name == path))
|
||||
.filter(|path| !exported.iter().any(|tool| tool == path))
|
||||
.collect();
|
||||
|
||||
assert!(
|
||||
missing.is_empty(),
|
||||
"no tool for {missing:?}. A new subcommand reaches the CLI, the completions \
|
||||
and the skill, and stops there: give it a tool in assets/TOOL.ts, or name \
|
||||
it in NO_TOOL with why it should not have one."
|
||||
);
|
||||
|
||||
// An exception naming a subcommand that has gone, or carrying no reason, is
|
||||
// drift of exactly the kind this test is for.
|
||||
for (name, reason) in NO_TOOL {
|
||||
assert!(
|
||||
paths.iter().any(|path| path == name),
|
||||
"the exception {name:?} names no subcommand clap has"
|
||||
);
|
||||
assert!(!reason.trim().is_empty(), "the exception for {name} carries no reason");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+94
-38
@@ -1,3 +1,5 @@
|
||||
use std::path::Path;
|
||||
|
||||
use anyhow::Result;
|
||||
use clap::Parser;
|
||||
|
||||
@@ -8,6 +10,11 @@ mod completions;
|
||||
mod handlers;
|
||||
mod history;
|
||||
mod install;
|
||||
/// The command prompt reads `split_line` and `unclosed`; `cursor_arg` and `at_new_arg` are
|
||||
/// what completing an argument needs and nothing reads them yet, so the allow stays until
|
||||
/// 00a14e7 and 952a9f8 land. The tests are what drive them in the meantime.
|
||||
#[cfg_attr(not(test), allow(dead_code))]
|
||||
mod split;
|
||||
mod tag;
|
||||
mod tui;
|
||||
mod util;
|
||||
@@ -42,77 +49,111 @@ fn main() -> Result<()> {
|
||||
|
||||
let start = std::env::current_dir()?;
|
||||
|
||||
match cli.command {
|
||||
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),
|
||||
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) => dispatch(&command, &start, &mut sink),
|
||||
};
|
||||
|
||||
// The board (and every handler) own their own writing, so flush what the last one
|
||||
// handed the sink before returning; an error path printed nothing to flush.
|
||||
sink.flush()?;
|
||||
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)
|
||||
}
|
||||
Some(Command::Show { id }) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_show(&id, &worklane_dir)
|
||||
Command::Show { id } => {
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
cmd_show(id, &worklane_dir, sink)
|
||||
}
|
||||
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 {
|
||||
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),
|
||||
Some(Command::Campaign { command }) => match command {
|
||||
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
|
||||
} => 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)
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
cmd_campaign_ls(&worklane_dir, *ids, sink)
|
||||
}
|
||||
CampaignCommand::Set(args) => cmd_campaign_set(&args, &start),
|
||||
CampaignCommand::Append(args) => cmd_campaign_append(&args, &start),
|
||||
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)
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
cmd_campaign_show(campaign, &worklane_dir, sink)
|
||||
}
|
||||
},
|
||||
Some(Command::Assign {
|
||||
Command::Assign {
|
||||
campaign,
|
||||
ticket,
|
||||
actor,
|
||||
actor_from_git,
|
||||
}) => cmd_assign(&campaign, &ticket, &actor, actor_from_git, &start),
|
||||
} => 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.
|
||||
Some(Command::Tags { command }) => match command {
|
||||
Command::Tags { command } => match command {
|
||||
None | Some(TagCommand::Ls) => {
|
||||
let worklane_dir = find_worklane_dir(&start)?;
|
||||
cmd_tags(&worklane_dir)
|
||||
let worklane_dir = find_worklane_dir(start)?;
|
||||
cmd_tags(&worklane_dir, sink)
|
||||
}
|
||||
Some(TagCommand::Add(args)) => cmd_tag_add(&args, &start),
|
||||
Some(TagCommand::Set(args)) => cmd_tag_set(&args, &start),
|
||||
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.
|
||||
Some(Command::Completions { shell }) => {
|
||||
completions::generate(shell, &mut std::io::stdout()).map_err(Into::into)
|
||||
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)
|
||||
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.
|
||||
Some(Command::InstallTool { force, print }) => cmd_install_tool(force, print),
|
||||
Command::InstallTool { force, print } => cmd_install_tool(*force, *print, sink),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -208,6 +249,15 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
|
||||
continue;
|
||||
}
|
||||
|
||||
// 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. 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;
|
||||
}
|
||||
|
||||
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
|
||||
@@ -251,6 +301,12 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
|
||||
// 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(),
|
||||
// The way in to the command prompt, and the same single-shot arm `/` is:
|
||||
// from the next keypress on, `prompt_key` above has the keyboard. A `:`
|
||||
// typed into either open prompt is a character there and one pressed at an
|
||||
// open picker is swallowed by it, so this arm is only ever the way in from
|
||||
// the board itself. Free of every existing binding.
|
||||
KeyCode::Char(':') => board.open_prompt(),
|
||||
// `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.
|
||||
|
||||
+453
@@ -0,0 +1,453 @@
|
||||
//! Splitting a typed line into the arguments a parser wants.
|
||||
//!
|
||||
//! The prompt on the board takes one string and clap takes an argv, so something has to
|
||||
//! turn `comment 1b78a24 the offset was never passed` into a verb, a ticket and one body
|
||||
//! with spaces in it. Splitting on whitespace hands clap five arguments where `comment`
|
||||
//! takes two, which is not a grammar error to report but a tokenising step nobody ran.
|
||||
//!
|
||||
//! The rules are the shell's, because that is what the prompt promises: a line is spelled
|
||||
//! there exactly as it is spelled in the shell. Runs of whitespace separate arguments,
|
||||
//! single and double quotes group one, a backslash escapes the next character except
|
||||
//! inside single quotes where it is a backslash, and an explicitly empty `''` is an
|
||||
//! argument that exists and is empty — which is what `--title ""` being a usage error
|
||||
//! rather than a silent clear depends on. A leading hyphen is not special here: whether
|
||||
//! `--foo` is a flag or the text of a criterion is clap's question, and the prose
|
||||
//! arguments already accept one.
|
||||
//!
|
||||
//! Two things a shell's own splitter does not have to answer, and both are why this is
|
||||
//! written rather than pulled in:
|
||||
//!
|
||||
//! - **A line being typed is half finished.** An unterminated quote is a state to report,
|
||||
//! not an error to raise, because the prompt has to keep taking characters and refuse
|
||||
//! only enter. See [`Unclosed`].
|
||||
//! - **Completion needs to know where the cursor is.** Which argument it sits in, counting
|
||||
//! from the verb, and whether nothing of that argument lies before it. Both fall out of
|
||||
//! the scan for free and neither is reachable afterwards from the arguments alone.
|
||||
//!
|
||||
//! One pure function over the line and the cursor, and nothing here knows about `Board`.
|
||||
|
||||
/// What a line is still inside when it ends.
|
||||
///
|
||||
/// A half-typed line is not a line that failed: `comment 1b78a24 "the offset` is a
|
||||
/// sentence somebody is in the middle of, and the arguments before the quote are already
|
||||
/// right. So this is a state the caller reports, and the reason enter is refused while it
|
||||
/// is anything but [`Unclosed::Closed`] — the arguments up to that point are still handed
|
||||
/// back, because that is what a completion or a hint has to work from.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Unclosed {
|
||||
/// Nothing. The arguments are whole and the line can go to a parser.
|
||||
Closed,
|
||||
/// A `'` with no `'` after it.
|
||||
Single,
|
||||
/// A `"` with no `"` after it.
|
||||
Double,
|
||||
/// A trailing `\`, which has nothing yet to escape.
|
||||
///
|
||||
/// Not a quote, and reported the same way for the same reason: the character it will
|
||||
/// escape is the next one typed. It wins over an open quote, being the inner of the
|
||||
/// two, and either answer refuses the line.
|
||||
Escape,
|
||||
}
|
||||
|
||||
/// Which quote the scan is inside.
|
||||
///
|
||||
/// Private, because what a caller needs is [`Unclosed`], which also carries the state no
|
||||
/// quote can. Two public spellings of one fact is how they come to disagree.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
enum Quote {
|
||||
Single,
|
||||
Double,
|
||||
}
|
||||
|
||||
/// One scan of a line: its arguments, where the cursor sits among them, and what the line
|
||||
/// is still inside.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct Split {
|
||||
/// The arguments, in order, with the quotes and escapes taken off. The binary's own
|
||||
/// name is not among them: prepending it is the caller's, since only the caller knows
|
||||
/// what it is calling.
|
||||
pub args: Vec<String>,
|
||||
/// Which argument the cursor is in, counting from the verb at 0. Equal to
|
||||
/// `args.len()` when the cursor is past the last one, which is the index an argument
|
||||
/// typed next would take.
|
||||
pub cursor_arg: usize,
|
||||
/// Whether nothing of `cursor_arg` lies before the cursor, because the line up to it
|
||||
/// ends in a separator or has nothing in it at all. That is the difference between
|
||||
/// completing an argument and starting one.
|
||||
pub at_new_arg: bool,
|
||||
/// What the line is still inside, and therefore whether it can be run at all.
|
||||
pub unclosed: Unclosed,
|
||||
}
|
||||
|
||||
/// Split `line` into arguments, reading the cursor at `cursor` as a byte offset into it.
|
||||
///
|
||||
/// Bytes because that is what the prompt's own cursor is: a `String` inserts and removes
|
||||
/// at byte indices. A cursor past the end of the line reads as the end, and one inside a
|
||||
/// multi-byte character reads as being after that character, so neither can panic and
|
||||
/// neither needs the caller to have clamped it first.
|
||||
pub fn split_line(line: &str, cursor: usize) -> Split {
|
||||
let mut args: Vec<String> = Vec::new();
|
||||
// `Some("")` is an argument that has been opened and is still empty, which is what
|
||||
// tells `''` from nothing at all: a bare `take()` cannot make that distinction.
|
||||
let mut arg: Option<String> = None;
|
||||
let mut quote: Option<Quote> = None;
|
||||
let mut escape = false;
|
||||
// The cursor's answer, taken at the character it falls on and never revised.
|
||||
let mut at: Option<(usize, bool)> = None;
|
||||
|
||||
for (offset, c) in line.char_indices() {
|
||||
if at.is_none() && offset >= cursor {
|
||||
at = Some((args.len(), arg.is_none()));
|
||||
}
|
||||
|
||||
if escape {
|
||||
arg.get_or_insert_default().push(c);
|
||||
escape = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
match (quote, c) {
|
||||
// The shell's exception, and the reason a criterion reading `a\b` survives
|
||||
// being typed as `'a\b'`: single quotes are literal, backslash included.
|
||||
(Some(Quote::Single), '\\') => arg.get_or_insert_default().push(c),
|
||||
(_, '\\') => escape = true,
|
||||
(None, '\'') => {
|
||||
quote = Some(Quote::Single);
|
||||
arg.get_or_insert_default();
|
||||
}
|
||||
(None, '"') => {
|
||||
quote = Some(Quote::Double);
|
||||
arg.get_or_insert_default();
|
||||
}
|
||||
(Some(Quote::Single), '\'') | (Some(Quote::Double), '"') => quote = None,
|
||||
// A run of separators closes the open argument once and then finds none.
|
||||
(None, ws) if ws.is_whitespace() => {
|
||||
if let Some(done) = arg.take() {
|
||||
args.push(done);
|
||||
}
|
||||
}
|
||||
_ => arg.get_or_insert_default().push(c),
|
||||
}
|
||||
}
|
||||
|
||||
// Before the last argument is pushed, so a cursor at the end of the line is still in
|
||||
// the argument it is typing rather than one past it.
|
||||
let (cursor_arg, at_new_arg) = at.unwrap_or((args.len(), arg.is_none()));
|
||||
if let Some(last) = arg {
|
||||
args.push(last);
|
||||
}
|
||||
|
||||
Split {
|
||||
args,
|
||||
cursor_arg,
|
||||
at_new_arg,
|
||||
unclosed: match (escape, quote) {
|
||||
(true, _) => Unclosed::Escape,
|
||||
(false, Some(Quote::Single)) => Unclosed::Single,
|
||||
(false, Some(Quote::Double)) => Unclosed::Double,
|
||||
(false, None) => Unclosed::Closed,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// One line and everything the scan is supposed to say about it.
|
||||
///
|
||||
/// The defaults are the empty line's own answers, so a row states the rule it is about
|
||||
/// and stays quiet about the rest.
|
||||
struct Case {
|
||||
line: &'static str,
|
||||
/// Where the cursor is, or the end of the line, which is where it sits while a
|
||||
/// line is being typed. Only the cursor rows move it.
|
||||
cursor: Option<usize>,
|
||||
args: &'static [&'static str],
|
||||
cursor_arg: usize,
|
||||
at_new_arg: bool,
|
||||
unclosed: Unclosed,
|
||||
}
|
||||
|
||||
impl Default for Case {
|
||||
fn default() -> Self {
|
||||
Case {
|
||||
line: "",
|
||||
cursor: None,
|
||||
args: &[],
|
||||
cursor_arg: 0,
|
||||
at_new_arg: true,
|
||||
unclosed: Unclosed::Closed,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Every field of every row, each named in its own failure: a table that reports only
|
||||
/// the first mismatch makes the next run tell a different story than this one.
|
||||
fn check(cases: &[Case]) {
|
||||
for case in cases {
|
||||
let cursor = case.cursor.unwrap_or(case.line.len());
|
||||
let split = split_line(case.line, cursor);
|
||||
let args: Vec<&str> = split.args.iter().map(String::as_str).collect();
|
||||
let at = format!("{:?} with the cursor at {cursor}", case.line);
|
||||
|
||||
assert_eq!(args, case.args, "arguments of {at}");
|
||||
assert_eq!(split.cursor_arg, case.cursor_arg, "cursor argument of {at}");
|
||||
assert_eq!(split.at_new_arg, case.at_new_arg, "new argument of {at}");
|
||||
assert_eq!(split.unclosed, case.unclosed, "unclosed state of {at}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_line_splits_into_arguments_the_way_a_shell_splits_one() {
|
||||
check(&[
|
||||
// Nothing typed yet, which is the state the prompt opens in.
|
||||
Case::default(),
|
||||
Case {
|
||||
line: "tags",
|
||||
args: &["tags"],
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
Case {
|
||||
line: "mv 1b78a24 --status committed",
|
||||
args: &["mv", "1b78a24", "--status", "committed"],
|
||||
cursor_arg: 3,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// Runs of separators collapse, at either end and in the middle, and a tab is
|
||||
// one of them.
|
||||
Case {
|
||||
line: " mv 1b78a24 ",
|
||||
args: &["mv", "1b78a24"],
|
||||
cursor_arg: 2,
|
||||
..Case::default()
|
||||
},
|
||||
Case {
|
||||
line: "mv\t1b78a24",
|
||||
args: &["mv", "1b78a24"],
|
||||
cursor_arg: 1,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// What the ticket for this was written about: one body, spaces and all.
|
||||
Case {
|
||||
line: "comment 1b78a24 \"the offset was never passed\"",
|
||||
args: &["comment", "1b78a24", "the offset was never passed"],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// Single quotes group the same, and a run of spaces inside one is not a
|
||||
// separator to collapse.
|
||||
Case {
|
||||
line: "comment 1b78a24 'two spaces'",
|
||||
args: &["comment", "1b78a24", "two spaces"],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// A quote in the middle of an argument groups part of it, which is how a
|
||||
// `--flag=value` carrying a space is typed.
|
||||
Case {
|
||||
line: "set 1b78a24 --title=\"a b\"",
|
||||
args: &["set", "1b78a24", "--title=a b"],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// A backslash escapes the next character: a separator, a quote, itself.
|
||||
Case {
|
||||
line: "comment 1b78a24 a\\ b",
|
||||
args: &["comment", "1b78a24", "a b"],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
Case {
|
||||
line: "comment 1b78a24 \"she said \\\"no\\\"\"",
|
||||
args: &["comment", "1b78a24", "she said \"no\""],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
Case {
|
||||
line: "comment 1b78a24 a\\\\b",
|
||||
args: &["comment", "1b78a24", "a\\b"],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// Except inside single quotes, where it is a character like any other.
|
||||
Case {
|
||||
line: "comment 1b78a24 'a\\b'",
|
||||
args: &["comment", "1b78a24", "a\\b"],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// A leading hyphen is clap's business, not the splitter's.
|
||||
Case {
|
||||
line: "add --title --print is supported",
|
||||
args: &["add", "--title", "--print", "is", "supported"],
|
||||
cursor_arg: 4,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// An empty quoted value is an argument that exists and is empty. Losing it
|
||||
// here would turn a usage error into a silent clear.
|
||||
Case {
|
||||
line: "set 1b78a24 --title \"\"",
|
||||
args: &["set", "1b78a24", "--title", ""],
|
||||
cursor_arg: 3,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
Case {
|
||||
line: "''",
|
||||
args: &[""],
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_half_typed_line_says_what_it_is_still_inside_and_hands_back_the_rest() {
|
||||
check(&[
|
||||
// The arguments before the open quote are already right, and the open one is
|
||||
// as far as it has been typed.
|
||||
Case {
|
||||
line: "comment 1b78a24 \"the offset",
|
||||
args: &["comment", "1b78a24", "the offset"],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
unclosed: Unclosed::Double,
|
||||
..Case::default()
|
||||
},
|
||||
Case {
|
||||
line: "comment 1b78a24 'the offset",
|
||||
args: &["comment", "1b78a24", "the offset"],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
unclosed: Unclosed::Single,
|
||||
..Case::default()
|
||||
},
|
||||
// A quote just opened is an argument that exists and is empty, the same shape
|
||||
// a closed `''` leaves.
|
||||
Case {
|
||||
line: "comment 1b78a24 \"",
|
||||
args: &["comment", "1b78a24", ""],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
unclosed: Unclosed::Double,
|
||||
..Case::default()
|
||||
},
|
||||
// A trailing backslash has nothing yet to escape. It opened no argument, so
|
||||
// the cursor is starting one.
|
||||
Case {
|
||||
line: "mv 1b78a24 \\",
|
||||
args: &["mv", "1b78a24"],
|
||||
cursor_arg: 2,
|
||||
unclosed: Unclosed::Escape,
|
||||
..Case::default()
|
||||
},
|
||||
// Inside a quote the escape is the inner of the two, and it is what the line
|
||||
// is waiting on.
|
||||
Case {
|
||||
line: "comment 1b78a24 \"a\\",
|
||||
args: &["comment", "1b78a24", "a"],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
unclosed: Unclosed::Escape,
|
||||
..Case::default()
|
||||
},
|
||||
// A closed quote reopened is open again: the state is where the scan ended,
|
||||
// not how many quotes were typed.
|
||||
Case {
|
||||
line: "comment 1b78a24 'a' 'b",
|
||||
args: &["comment", "1b78a24", "a", "b"],
|
||||
cursor_arg: 3,
|
||||
at_new_arg: false,
|
||||
unclosed: Unclosed::Single,
|
||||
..Case::default()
|
||||
},
|
||||
]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_split_says_which_argument_the_cursor_is_in_and_whether_it_begins_one() {
|
||||
check(&[
|
||||
// The line is split whole whatever the cursor is doing: only the two cursor
|
||||
// answers move.
|
||||
Case {
|
||||
line: "mv 1b78a24",
|
||||
cursor: Some(0),
|
||||
args: &["mv", "1b78a24"],
|
||||
..Case::default()
|
||||
},
|
||||
Case {
|
||||
line: "mv 1b78a24",
|
||||
cursor: Some(1),
|
||||
args: &["mv", "1b78a24"],
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// At the end of the verb, still in the verb: the cursor is completing it.
|
||||
Case {
|
||||
line: "mv 1b78a24",
|
||||
cursor: Some(2),
|
||||
args: &["mv", "1b78a24"],
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// Past the separator, so the argument at 1 has nothing before the cursor even
|
||||
// though the line goes on to hold one.
|
||||
Case {
|
||||
line: "mv 1b78a24",
|
||||
cursor: Some(3),
|
||||
args: &["mv", "1b78a24"],
|
||||
cursor_arg: 1,
|
||||
..Case::default()
|
||||
},
|
||||
// A cursor past the end of the line reads as the end of it.
|
||||
Case {
|
||||
line: "mv",
|
||||
cursor: Some(99),
|
||||
args: &["mv"],
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// Inside a quoted argument the cursor is in that argument, not in a fourth
|
||||
// one the quotes might look like they opened.
|
||||
Case {
|
||||
line: "comment 1b78a24 \"the offset\"",
|
||||
cursor: Some(20),
|
||||
args: &["comment", "1b78a24", "the offset"],
|
||||
cursor_arg: 2,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
// Byte offsets, so a multi-byte character before the cursor counts for its
|
||||
// width and not for one: 8 is where `é` starts and 9 is inside it.
|
||||
Case {
|
||||
line: "comment é",
|
||||
cursor: Some(8),
|
||||
args: &["comment", "é"],
|
||||
cursor_arg: 1,
|
||||
..Case::default()
|
||||
},
|
||||
// A cursor inside a character reads as being after it, which is the answer
|
||||
// that cannot claim an argument has not started when it has.
|
||||
Case {
|
||||
line: "comment é",
|
||||
cursor: Some(9),
|
||||
args: &["comment", "é"],
|
||||
cursor_arg: 1,
|
||||
at_new_arg: false,
|
||||
..Case::default()
|
||||
},
|
||||
]);
|
||||
}
|
||||
}
|
||||
+2180
-19
File diff suppressed because it is too large
Load Diff
+283
-40
@@ -1,7 +1,7 @@
|
||||
use anyhow::{Result, anyhow};
|
||||
use chrono::NaiveDateTime;
|
||||
use std::fs;
|
||||
use std::io::IsTerminal;
|
||||
use std::io::{IsTerminal, Write};
|
||||
use std::path::Path;
|
||||
use std::sync::OnceLock;
|
||||
|
||||
@@ -303,6 +303,119 @@ pub fn color_text(text: &str, color: Color) -> String {
|
||||
paint(text, color, should_use_colors())
|
||||
}
|
||||
|
||||
/// `text` with every ANSI escape sequence taken out of it.
|
||||
///
|
||||
/// The inverse of what [`paint`] writes, and the guard at the seam where a handler's
|
||||
/// words become something the board draws: ratatui prints an escape as literal bytes
|
||||
/// rather than obeying it, so a painted status reaches the screen as `\x1b[33m` and
|
||||
/// the word after it.
|
||||
///
|
||||
/// A [`Sink`] the board owns is plain, so this is not about a handler's ordinary
|
||||
/// output. It is about the strings that never go through one: an error message is
|
||||
/// built with `color_text`, which asks the *process* about its stdout, and under the
|
||||
/// board that answers yes about a terminal the message is not going to.
|
||||
pub fn without_escapes(text: &str) -> String {
|
||||
let mut out = String::with_capacity(text.len());
|
||||
let mut chars = text.chars();
|
||||
|
||||
while let Some(c) = chars.next() {
|
||||
if c != '\x1b' {
|
||||
out.push(c);
|
||||
continue;
|
||||
}
|
||||
|
||||
// A CSI sequence is `\x1b[`, then parameter bytes, closed by a final byte in
|
||||
// `@` to `~`. That is every sequence `Color` writes. Anything else is a short
|
||||
// escape whose one following character goes with it, which `next` has taken.
|
||||
if chars.next() == Some('[') {
|
||||
for c in chars.by_ref() {
|
||||
if ('\x40'..='\x7e').contains(&c) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
out
|
||||
}
|
||||
|
||||
/// A destination for a command's output, chosen by the caller.
|
||||
///
|
||||
/// `main` hands a handler its own stdout and nothing about the CLI changes; the
|
||||
/// board (or a test) hands it an in-memory buffer and reads back what the command
|
||||
/// said. Threading the writer and the colour decision together means every print
|
||||
/// site reaches both, and a handler never asks the process about its own stdout.
|
||||
///
|
||||
/// `use_color` is the sink's answer, not a read of [`should_use_colors`]: a process
|
||||
/// whose stdout is a pipe still wants colour when the sink is a buffer a renderer
|
||||
/// will colour itself, and the board wants plain text however the terminal answers.
|
||||
pub struct Sink<'a> {
|
||||
writer: Box<dyn Write + 'a>,
|
||||
/// Whether the bytes this sink writes carry colour escapes.
|
||||
pub use_color: bool,
|
||||
}
|
||||
|
||||
impl<'a> Sink<'a> {
|
||||
/// The process's stdout, coloured by what the terminal wants.
|
||||
///
|
||||
/// What `main` passes, so the CLI's output is byte identical to before: every
|
||||
/// command wrote to stdout through `println!`, and this sink writes to the same
|
||||
/// stdout through the same [`paint`].
|
||||
pub fn std() -> Sink<'static> {
|
||||
// Through `new` so the process's stdout is just another writer the sink wraps.
|
||||
Sink::new(Box::new(std::io::stdout()), should_use_colors())
|
||||
}
|
||||
|
||||
/// An in-memory buffer, plain, for a test or a caller that colours the text
|
||||
/// itself.
|
||||
///
|
||||
/// What the board's command prompt passes: the handler's words come back as text
|
||||
/// and the board styles them with ratatui, which is also why it must not be handed
|
||||
/// a coloured one — a paragraph prints an escape rather than obeying it.
|
||||
pub fn buffer(target: &'a mut Vec<u8>) -> Sink<'a> {
|
||||
Sink {
|
||||
writer: Box::new(target),
|
||||
use_color: false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Any writer, with the colour decision given.
|
||||
pub fn new(writer: Box<dyn Write + 'a>, use_color: bool) -> Sink<'a> {
|
||||
Sink { writer, use_color }
|
||||
}
|
||||
|
||||
/// The writer, for a caller that already knows how to fill it (the completions
|
||||
/// generator).
|
||||
pub fn as_write(&mut self) -> &mut dyn Write {
|
||||
&mut *self.writer
|
||||
}
|
||||
|
||||
/// Write `text` followed by a newline, the way `println!` did.
|
||||
pub fn writeln(&mut self, text: &str) -> Result<()> {
|
||||
self.writer.write_all(text.as_bytes())?;
|
||||
self.writer.write_all(b"\n")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Write `text` with no terminator, the way `print!` did. The caller flushes
|
||||
/// when it then waits on input.
|
||||
pub fn write(&mut self, text: &str) -> Result<()> {
|
||||
self.writer.write_all(text.as_bytes())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Flush the writer, so a prompt reaches the terminal before a read.
|
||||
pub fn flush(&mut self) -> Result<()> {
|
||||
self.writer.flush()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// `text` wrapped in `color`'s escape when this sink is coloured.
|
||||
pub fn color(&self, text: &str, color: Color) -> String {
|
||||
paint(text, color, self.use_color)
|
||||
}
|
||||
}
|
||||
|
||||
/// What sits at a candidate `.worklane` path.
|
||||
///
|
||||
/// The distinction the walk turns on is between nothing there and something
|
||||
@@ -738,10 +851,6 @@ pub struct Resolved {
|
||||
pub campaign: Vec<Cell>,
|
||||
}
|
||||
|
||||
pub fn content_trim_colored(content: &str, resolved: &Resolved) -> String {
|
||||
content_trim(content, should_use_colors(), resolved)
|
||||
}
|
||||
|
||||
/// A section heading, its rule, and the blank line the body opens under.
|
||||
///
|
||||
/// The rule is measured on the name as displayed, in characters. It used to span the
|
||||
@@ -1499,6 +1608,16 @@ pub fn parse_tags(content: &str) -> Vec<String> {
|
||||
return Vec::new();
|
||||
}
|
||||
|
||||
split_tags(&value)
|
||||
}
|
||||
|
||||
/// The tags in one comma-separated value, trimmed and without the empty ones.
|
||||
///
|
||||
/// Split out of [`parse_tags`] because a value typed on the command line is separated the
|
||||
/// same way the stored field is: `append --tags "bug, tui"` names two tags, and merging
|
||||
/// that into what a ticket already carries has to see two or it stores the pair as one
|
||||
/// tag and adds it again on the next call.
|
||||
pub fn split_tags(value: &str) -> Vec<String> {
|
||||
value
|
||||
.split(',')
|
||||
.map(str::trim)
|
||||
@@ -3204,7 +3323,8 @@ impl TicketItem {
|
||||
/// A slot per status rather than a lookup by field name, so a fifth status carrying
|
||||
/// a stamp is a compile error here the way it is in [`Status::stamp_field`].
|
||||
/// Backlog has none: nothing stamps it, and `Created At` is not an entry time, so
|
||||
/// every ticket in that column answers `None` and the whole order is the fallback.
|
||||
/// every ticket in that column answers `None` and [`TicketItem::due_key`] is what
|
||||
/// orders it instead.
|
||||
fn entry_stamp(&self, status: Status) -> Option<&str> {
|
||||
match status {
|
||||
Status::Backlog => None,
|
||||
@@ -3214,6 +3334,22 @@ impl TicketItem {
|
||||
Status::Discarded => self.discarded_on.as_deref(),
|
||||
}
|
||||
}
|
||||
|
||||
/// The date the ticket is due, or `None` for one carrying nothing orderable.
|
||||
///
|
||||
/// What the backlog is sorted on, standing in for the entry stamp the column does
|
||||
/// not have. `YYYY-MM-DD` only, so lexicographic order is chronological order and
|
||||
/// the comparison stays a string comparison like the stamps'. `--due` has refused
|
||||
/// anything else since daa0e79, and [`due_date`] cuts a datetime written before
|
||||
/// that, or by hand, back to its date.
|
||||
///
|
||||
/// Free text answers `None` rather than sorting on its spelling. A due nobody can
|
||||
/// place on a calendar is unknown, the same reading a missing stamp gets, and
|
||||
/// unknown must not claim a place in a queue ordered by time.
|
||||
fn due_key(&self) -> Option<&str> {
|
||||
let date = due_date(&self.due);
|
||||
is_ymd(date).then_some(date)
|
||||
}
|
||||
}
|
||||
|
||||
/// The stamp a ticket carries for a status, or `None` for one it has not reached.
|
||||
@@ -3314,8 +3450,8 @@ fn show_priority(priority: Priority, colored: bool) -> String {
|
||||
paint(glyph, colour, colored)
|
||||
}
|
||||
|
||||
pub fn display_ticket_items(items: &[TicketItem]) {
|
||||
let colored = should_use_colors();
|
||||
pub fn display_ticket_items(sink: &mut Sink, items: &[TicketItem]) -> Result<()> {
|
||||
let colored = sink.use_color;
|
||||
|
||||
for item in items {
|
||||
let id = paint(&item.id, Color::Red, colored);
|
||||
@@ -3324,15 +3460,19 @@ pub fn display_ticket_items(items: &[TicketItem]) {
|
||||
let priority = show_priority(item.priority, colored);
|
||||
|
||||
if item.created.is_empty() {
|
||||
println!(" {} ({}) {} | Owner: {} | Due: {}", priority, id, item.title, owner, due);
|
||||
sink.writeln(&format!(
|
||||
" {} ({}) {} | Owner: {} | Due: {}",
|
||||
priority, id, item.title, owner, due
|
||||
))?;
|
||||
} else {
|
||||
let created = paint(&item.created, Color::Cyan, colored);
|
||||
println!(
|
||||
sink.writeln(&format!(
|
||||
" {} {} ({}) {} | Owner: {} | Due: {}",
|
||||
priority, created, id, item.title, owner, due
|
||||
);
|
||||
))?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn collect_ticket_items(status_path: impl AsRef<Path>) -> Result<Vec<TicketItem>> {
|
||||
@@ -3415,8 +3555,7 @@ pub fn collect_ticket_items(status_path: impl AsRef<Path>) -> Result<Vec<TicketI
|
||||
Ok(items)
|
||||
}
|
||||
|
||||
/// The order the backlog is read in, and the tiebreak every other column falls back to:
|
||||
/// priority first, title second.
|
||||
/// The tiebreak every column falls back to: priority first, title second.
|
||||
///
|
||||
/// Named and exported because the board's All tab merges several boards' columns into
|
||||
/// one and has to land in one order. A merge sorted a second way would put a p1 below a
|
||||
@@ -3431,36 +3570,46 @@ pub fn by_priority_then_title(a: &TicketItem, b: &TicketItem) -> std::cmp::Order
|
||||
|
||||
/// The order one status column is read in, keyed on the status.
|
||||
///
|
||||
/// Priority is the clock in the backlog, and that column keeps exactly the order it has
|
||||
/// always printed. Past the backlog the question changes: committed asks what has waited
|
||||
/// longest, reviewing what was handed over first, done what just landed. The head of
|
||||
/// every column is therefore what the reader acts on next, which is ascending by entry
|
||||
/// stamp in committed and reviewing and descending in done and discarded, the way a
|
||||
/// changelog reads.
|
||||
/// Every column asks the same question, what the reader acts on next, and answers it
|
||||
/// with the one date it has. Committed asks what has waited longest, reviewing what was
|
||||
/// handed over first, done what just landed: ascending by entry stamp in committed and
|
||||
/// reviewing, descending in done and discarded, the way a changelog reads. The backlog
|
||||
/// carries no entry stamp, so what heads it is the date the work is wanted by, soonest
|
||||
/// first. Priority ran that column alone until then, which sat a p1 nobody had promised
|
||||
/// above a p3 due tomorrow.
|
||||
///
|
||||
/// A ticket with no stamp sinks below every stamped one in its column. A missing time is
|
||||
/// unknown, not ancient, and unknown must not claim the head of a queue ahead of a wait
|
||||
/// somebody can point at. Reading absence as the epoch would come free from the string
|
||||
/// comparison and put every legacy ticket first on data nothing verified.
|
||||
/// A ticket with no date sinks below every dated one in its column, whether that date is
|
||||
/// a stamp or a due. A missing time is unknown, not ancient, and unknown must not claim
|
||||
/// the head of a queue ahead of a deadline somebody can point at. Reading absence as the
|
||||
/// epoch would come free from the string comparison and put every legacy ticket first on
|
||||
/// data nothing verified.
|
||||
///
|
||||
/// The comparison is a string comparison. The stamp format is `%Y-%m-%d %H:%M:%S`, where
|
||||
/// lexicographic order is chronological order, the same property `Due` already relies
|
||||
/// on, so there is no date parsing at sort time. Equal stamps happen, `mv` writes whole
|
||||
/// seconds, and they fall through to priority and title like everything else.
|
||||
/// The comparison is a string comparison. The stamp format is `%Y-%m-%d %H:%M:%S` and a
|
||||
/// due is `%Y-%m-%d`, both of which order lexicographically the way they order
|
||||
/// chronologically, so there is no date parsing at sort time. Equal dates happen, `mv`
|
||||
/// writes whole seconds and a due has no time at all, and they fall through to priority
|
||||
/// and title like everything else.
|
||||
pub fn by_status_order(status: Status, a: &TicketItem, b: &TicketItem) -> std::cmp::Ordering {
|
||||
let by_stamp = match (a.entry_stamp(status), b.entry_stamp(status)) {
|
||||
// One pair, so the rules below are written once. Which date a column is keyed on is
|
||||
// the only thing that changes with the status.
|
||||
let (left, right) = match status {
|
||||
Status::Backlog => (a.due_key(), b.due_key()),
|
||||
_ => (a.entry_stamp(status), b.entry_stamp(status)),
|
||||
};
|
||||
|
||||
let by_date = match (left, right) {
|
||||
(Some(left), Some(right)) => match status {
|
||||
Status::Done | Status::Discarded => right.cmp(left),
|
||||
_ => left.cmp(right),
|
||||
},
|
||||
(Some(_), None) => std::cmp::Ordering::Less,
|
||||
(None, Some(_)) => std::cmp::Ordering::Greater,
|
||||
// Both unstamped, which is every ticket in the backlog: the fallback is the
|
||||
// whole order there rather than a tiebreak.
|
||||
// Neither carries one, which is every undated ticket in the backlog: the
|
||||
// fallback is the whole order between them rather than a tiebreak.
|
||||
(None, None) => std::cmp::Ordering::Equal,
|
||||
};
|
||||
|
||||
by_stamp.then_with(|| by_priority_then_title(a, b))
|
||||
by_date.then_with(|| by_priority_then_title(a, b))
|
||||
}
|
||||
|
||||
/// The environment variable that keeps a test's fixture directory on disk.
|
||||
@@ -4526,6 +4675,16 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
/// A listed ticket carrying a due value, which is what the backlog column is ordered
|
||||
/// by. Built off [`listed`] rather than beside it, so a field added to `TicketItem`
|
||||
/// is still filled in one place.
|
||||
fn due_on(title: &str, level: u8, status: Status, due: &str) -> TicketItem {
|
||||
TicketItem {
|
||||
due: due.to_string(),
|
||||
..listed(title, level, status, None)
|
||||
}
|
||||
}
|
||||
|
||||
/// Sorted the way the column is read, titles out, so a case reads as the order it
|
||||
/// asserts rather than as a pair of comparisons.
|
||||
fn ordered(status: Status, mut items: Vec<TicketItem>) -> Vec<String> {
|
||||
@@ -4533,11 +4692,11 @@ mod tests {
|
||||
items.into_iter().map(|item| item.title).collect()
|
||||
}
|
||||
|
||||
/// The backlog is the one column priority still governs, and it prints exactly what
|
||||
/// it always has: the stamps a ticket carries from an earlier trip through the flow
|
||||
/// do not reach it, because backlog has no stamp of its own to sort on.
|
||||
/// Undated backlog tickets keep exactly the order the column always printed: the
|
||||
/// stamps a ticket carries from an earlier trip through the flow do not reach it,
|
||||
/// because backlog has no stamp of its own to sort on.
|
||||
#[test]
|
||||
fn the_backlog_keeps_priority_then_title() {
|
||||
fn undated_backlog_tickets_keep_priority_then_title() {
|
||||
let items = vec![
|
||||
listed("zebra", 5, Status::Backlog, None),
|
||||
listed("alpha", 1, Status::Backlog, None),
|
||||
@@ -4547,6 +4706,90 @@ mod tests {
|
||||
assert_eq!(ordered(Status::Backlog, items), ["alpha", "beta", "zebra"]);
|
||||
}
|
||||
|
||||
/// The due date is the backlog's clock, so the soonest deadline heads the column the
|
||||
/// way the oldest wait heads committed. Priority is deliberately inverted against the
|
||||
/// dates here: a p1 due last is still listed last.
|
||||
#[test]
|
||||
fn the_backlog_lists_the_soonest_due_date_first() {
|
||||
let items = vec![
|
||||
listed("undated", 1, Status::Backlog, None),
|
||||
due_on("last", 1, Status::Backlog, "2026-09-03"),
|
||||
due_on("first", 5, Status::Backlog, "2026-09-01"),
|
||||
due_on("middle", 3, Status::Backlog, "2026-09-02"),
|
||||
];
|
||||
|
||||
assert_eq!(ordered(Status::Backlog, items), ["first", "middle", "last", "undated"]);
|
||||
}
|
||||
|
||||
/// A due nobody promised must not outrank one somebody did, whatever the priorities
|
||||
/// say. This is the case the column got wrong before: the p1 sat on top.
|
||||
#[test]
|
||||
fn a_dated_backlog_ticket_sorts_above_an_undated_one_of_any_priority() {
|
||||
let items = vec![
|
||||
listed("undated", 1, Status::Backlog, None),
|
||||
due_on("dated", 5, Status::Backlog, "2026-09-01"),
|
||||
];
|
||||
|
||||
assert_eq!(ordered(Status::Backlog, items), ["dated", "undated"]);
|
||||
}
|
||||
|
||||
/// A due carries no time, so two tickets wanted on the same day is the common case
|
||||
/// rather than the rare one, and it falls through to priority and title.
|
||||
#[test]
|
||||
fn backlog_tickets_sharing_a_due_date_fall_back_to_priority_then_title() {
|
||||
let same = "2026-09-01";
|
||||
let items = vec![
|
||||
due_on("zebra", 1, Status::Backlog, same),
|
||||
due_on("beta", 3, Status::Backlog, same),
|
||||
due_on("alpha", 3, Status::Backlog, same),
|
||||
];
|
||||
|
||||
assert_eq!(ordered(Status::Backlog, items), ["zebra", "alpha", "beta"]);
|
||||
}
|
||||
|
||||
/// `--due` has taken `YYYY-MM-DD` and nothing else since daa0e79, but a file written
|
||||
/// before that or by hand can hold a datetime or free text. The datetime sorts on the
|
||||
/// date inside it; the free text is unknown rather than a date, and sinks with the
|
||||
/// unset ones instead of sorting on its spelling.
|
||||
#[test]
|
||||
fn a_backlog_due_that_is_not_a_plain_date_sorts_on_what_can_be_read_from_it() {
|
||||
let items = vec![
|
||||
due_on("prose", 1, Status::Backlog, "next friday"),
|
||||
due_on("unset", 1, Status::Backlog, NOT_SET),
|
||||
due_on("datetime", 5, Status::Backlog, "2026-09-01 09:30:00"),
|
||||
];
|
||||
|
||||
assert_eq!(ordered(Status::Backlog, items), ["datetime", "prose", "unset"]);
|
||||
}
|
||||
|
||||
/// The due is the backlog's clock and only the backlog's. Past it the entry stamp is
|
||||
/// the question, and a deadline set on a committed ticket does not reorder the queue
|
||||
/// of what has waited longest.
|
||||
#[test]
|
||||
fn a_due_date_does_not_reorder_a_column_past_the_backlog() {
|
||||
for status in [
|
||||
Status::Committed,
|
||||
Status::Reviewing,
|
||||
Status::Done,
|
||||
Status::Discarded,
|
||||
] {
|
||||
let soon = TicketItem {
|
||||
due: "2026-09-01".to_string(),
|
||||
..listed("soon", 1, status, Some("2026-08-02 09:00:00"))
|
||||
};
|
||||
let items = vec![
|
||||
soon,
|
||||
listed("later", 1, status, Some("2026-08-01 09:00:00")),
|
||||
];
|
||||
|
||||
let expected = match status {
|
||||
Status::Done | Status::Discarded => ["soon", "later"],
|
||||
_ => ["later", "soon"],
|
||||
};
|
||||
assert_eq!(ordered(status, items), expected, "{status:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Committed and reviewing are queues: the head is what has waited longest, which is
|
||||
/// where the reader picks next from.
|
||||
#[test]
|
||||
@@ -4714,7 +4957,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn a_section_rule_matches_the_width_of_its_name() {
|
||||
let rendered = content_trim_colored("# T\n\n## Description\nbody\n", &Resolved::default());
|
||||
let rendered = content_trim("# T\n\n## Description\nbody\n", false, &Resolved::default());
|
||||
|
||||
// Eleven characters, not fourteen: the rule used to span "## Description"
|
||||
assert!(rendered.starts_with("Description\n───────────\n"), "{rendered:?}");
|
||||
@@ -4722,7 +4965,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn a_non_ascii_section_name_is_not_over_drawn() {
|
||||
let rendered = content_trim_colored("# T\n\n## Résumé\nbody\n", &Resolved::default());
|
||||
let rendered = content_trim("# T\n\n## Résumé\nbody\n", false, &Resolved::default());
|
||||
|
||||
assert!(rendered.starts_with("Résumé\n──────\n"), "{rendered:?}");
|
||||
}
|
||||
@@ -4730,7 +4973,7 @@ mod tests {
|
||||
#[test]
|
||||
fn the_body_leaves_the_title_to_cmd_show() {
|
||||
let rendered =
|
||||
content_trim_colored("# Only Once\n\n## Description\nbody\n", &Resolved::default());
|
||||
content_trim("# Only Once\n\n## Description\nbody\n", false, &Resolved::default());
|
||||
|
||||
assert!(!rendered.contains("Only Once"), "{rendered:?}");
|
||||
// And no gap where it was
|
||||
@@ -4740,7 +4983,7 @@ mod tests {
|
||||
#[test]
|
||||
fn the_metadata_section_renders_as_a_table_inside_the_body() {
|
||||
let content = "# T\n\n## Metadata\n\n- **ID**: abc\n- **Owner**: alice\n";
|
||||
let rendered = content_trim_colored(content, &Resolved::default());
|
||||
let rendered = content_trim(content, false, &Resolved::default());
|
||||
|
||||
assert_eq!(rendered, "Metadata\n────────\n\nID abc\nOwner alice\n");
|
||||
}
|
||||
@@ -4853,7 +5096,7 @@ Plain line with **bold** and a [link](http://x.test/a).
|
||||
#[test]
|
||||
fn a_section_after_metadata_still_renders() {
|
||||
let content = "# T\n\n## Metadata\n\n- **ID**: abc\n\n## Notes\n\nafter\n";
|
||||
let rendered = content_trim_colored(content, &Resolved::default());
|
||||
let rendered = content_trim(content, false, &Resolved::default());
|
||||
|
||||
assert!(rendered.contains("ID abc"), "{rendered:?}");
|
||||
assert!(rendered.contains("Notes\n─────\n"), "{rendered:?}");
|
||||
|
||||
@@ -574,6 +574,12 @@ fn chmod(path: &Path, mode: u32) {
|
||||
/// itself, and it is named with the ticket and the path rather than raised as a bare io
|
||||
/// error. The branch this replaces could not fire at all: the filename carries a fresh
|
||||
/// uuid, and its message claimed the title was taken.
|
||||
///
|
||||
/// The add stages through `write_then_replace` like every other write, so the temp
|
||||
/// lives under `.worklane/`, outside the directory the chmod keeps closed, and the
|
||||
/// rename is the step that fails here. Both halves have to be gone afterwards: no half
|
||||
/// ticket in backlog, and no `.wl-*.tmp` beside it, which is what `stray_files` checks
|
||||
/// for a move.
|
||||
#[test]
|
||||
fn add_names_the_ticket_and_the_path_when_the_write_fails() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
@@ -596,6 +602,14 @@ fn add_names_the_ticket_and_the_path_when_the_write_fails() {
|
||||
|
||||
chmod(&backlog, 0o755);
|
||||
assert_eq!(fs::read_dir(&backlog).unwrap().count(), 0);
|
||||
|
||||
let strays: Vec<String> = fs::read_dir(&worklane)
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.filter(|name| name.starts_with(".wl-"))
|
||||
.collect();
|
||||
assert_eq!(strays, Vec::<String>::new(), "the staging file was left behind");
|
||||
}
|
||||
|
||||
/// The board above the project is real and empty, and stays empty: a dangling
|
||||
|
||||
@@ -68,6 +68,232 @@ fn fish_is_offered_every_status() {
|
||||
assert!(out.contains("-a 'backlog committed reviewing done discarded' -d status"));
|
||||
}
|
||||
|
||||
/// A board holding one ticket and one tag, for the rules whose values come off a board.
|
||||
///
|
||||
/// Returned with the ticket's id and the tag, since the assertions are that those exact
|
||||
/// strings are what fish offers.
|
||||
fn board() -> (assert_fs::TempDir, String, String) {
|
||||
let temp = assert_fs::TempDir::new().unwrap();
|
||||
let mut init = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
init.current_dir(temp.path()).arg("init").assert().success();
|
||||
|
||||
let mut add = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
add.current_dir(temp.path())
|
||||
.args(["add", "--title", "A ticket to complete", "--tags", "atag"])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let mut ls = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let listed = ls
|
||||
.current_dir(temp.path())
|
||||
.args(["ls", "--ids"])
|
||||
.assert()
|
||||
.success();
|
||||
let listed = String::from_utf8(listed.get_output().stdout.clone()).unwrap();
|
||||
let id = listed.split('\t').next().unwrap().trim().to_string();
|
||||
|
||||
(temp, id, "atag".to_string())
|
||||
}
|
||||
|
||||
/// What fish would actually offer for a half-typed line, or `None` when fish is absent.
|
||||
///
|
||||
/// `complete -C` is fish's own answer to "what are the candidates here", so this asks the
|
||||
/// question a person at a prompt asks rather than searching the script for the rule that
|
||||
/// ought to produce the answer. Each candidate is a name and, after a tab, its description.
|
||||
///
|
||||
/// **The shell is pointed at the binary under test and stood in a real board**, which is
|
||||
/// what makes the dynamic half testable at all: its rules are command substitutions calling
|
||||
/// `worklane ls --ids` and `worklane tags`, so with no board and no binary they return
|
||||
/// nothing and every assertion about them would pass on an empty answer. The directory of
|
||||
/// `CARGO_BIN_EXE_worklane` goes on the front of PATH so the substitution runs this build
|
||||
/// rather than whatever is installed.
|
||||
///
|
||||
/// **`fish_complete_path` is emptied first, and without that line this test cannot fail.**
|
||||
/// `complete -C` autoloads completions for the command it is asked about, so a developer
|
||||
/// who has ever run `worklane completions fish > ~/.config/fish/completions/worklane.fish`
|
||||
/// gets that file merged into the answer. It was written by some earlier version of this
|
||||
/// binary and answers for whatever the rules used to be: the first draft of this test
|
||||
/// passed against a deliberately broken scope because the installed copy still had the
|
||||
/// working one. Emptying the path is what makes the sourced script the only source.
|
||||
fn candidates(board: &assert_fs::TempDir, line: &str) -> Option<Vec<String>> {
|
||||
// Beside the board rather than in it: a rule that fires nothing falls back to listing
|
||||
// the directory, and a script sitting in there would appear among the candidates and
|
||||
// read like an answer.
|
||||
let holder = assert_fs::TempDir::new().unwrap();
|
||||
let path = holder.path().join("worklane.fish");
|
||||
std::fs::write(&path, script("fish")).unwrap();
|
||||
|
||||
let bin_dir = std::path::Path::new(BIN_NAME).parent().unwrap();
|
||||
let inherited = std::env::var("PATH").unwrap_or_default();
|
||||
|
||||
let asked = std::process::Command::new("fish")
|
||||
.current_dir(board.path())
|
||||
.env("PATH", format!("{}:{inherited}", bin_dir.display()))
|
||||
.arg("-c")
|
||||
.arg(format!(
|
||||
"set fish_complete_path; source {}; complete -C '{line}'",
|
||||
path.display()
|
||||
))
|
||||
.output();
|
||||
|
||||
match asked {
|
||||
Ok(out) => Some(
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
.lines()
|
||||
.map(str::to_string)
|
||||
.collect(),
|
||||
),
|
||||
Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
|
||||
Err(err) => panic!("could not run fish: {err}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// The name half of a candidate, dropping the description fish takes after the tab.
|
||||
fn names(candidates: &[String]) -> Vec<&str> {
|
||||
candidates
|
||||
.iter()
|
||||
.map(|line| line.split('\t').next().unwrap_or(line))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// **Ask fish what it offers, instead of asserting that the rule that should make it
|
||||
/// offer that is in the file.**
|
||||
///
|
||||
/// Every other test here reads the script as text, which cannot tell a rule that fires
|
||||
/// from one whose condition stopped matching. That is how a completion actually breaks:
|
||||
/// the clap definition moves, a list or a `__worklane_command_is` scope no longer names
|
||||
/// anything, and the rule sits in the file offering nothing. Loading it into a real fish
|
||||
/// and asking for the candidates is the only check that can see the difference.
|
||||
///
|
||||
/// **Asserting the values, not only the names, is the point.** clap emits every option's
|
||||
/// name on its own, so `--tags` and `--blocked-by` are offered whether or not the dynamic
|
||||
/// half loaded: an assertion that they appear passes with every hand-written rule deleted.
|
||||
/// What those rules add is the candidates *after* the flag, and that is what is pinned
|
||||
/// here, against the board `board()` puts under the shell.
|
||||
///
|
||||
/// Descriptions are read off deliberately and not asserted: every option carrying a
|
||||
/// hand-written rule currently loses the help text clap gave it, which is its own ticket
|
||||
/// rather than something to pin as correct here.
|
||||
///
|
||||
/// **Skipped when fish is not on PATH, and it says so.** There is no CI here and fish is
|
||||
/// the shell this tool is written for, so failing a machine that never had it would be a
|
||||
/// guard nobody could satisfy. A missing fish means the check did not run, not that it
|
||||
/// passed.
|
||||
#[test]
|
||||
fn fish_offers_the_commands_the_statuses_and_the_values() {
|
||||
let (temp, id, tag) = board();
|
||||
|
||||
let Some(commands) = candidates(&temp, "worklane ") else {
|
||||
eprintln!("skipped: fish is not on PATH, so nothing asked it for candidates");
|
||||
return;
|
||||
};
|
||||
for command in [
|
||||
"add", "ls", "show", "mv", "set", "append", "relate", "campaign",
|
||||
] {
|
||||
assert!(
|
||||
names(&commands).contains(&command),
|
||||
"`worklane <TAB>` never offers {command}"
|
||||
);
|
||||
}
|
||||
|
||||
// The `ls` status positional, which clap emits nothing for, so this answer comes from
|
||||
// the dynamic half alone and an empty one means that half stopped loading.
|
||||
let statuses = candidates(&temp, "worklane ls ").unwrap();
|
||||
for status in ["backlog", "committed", "reviewing", "done", "discarded"] {
|
||||
assert!(
|
||||
names(&statuses).contains(&status),
|
||||
"`worklane ls <TAB>` never offers {status}"
|
||||
);
|
||||
}
|
||||
|
||||
let shells = candidates(&temp, "worklane completions ").unwrap();
|
||||
for shell in ["fish", "bash", "zsh"] {
|
||||
assert!(
|
||||
names(&shells).contains(&shell),
|
||||
"`worklane completions <TAB>` never offers {shell}"
|
||||
);
|
||||
}
|
||||
|
||||
// Every rule whose values come off the board, one per list it is generated from.
|
||||
let ticket_value = [
|
||||
("worklane show ", "TICKET_COMMANDS"),
|
||||
("worklane chown alice ", "TICKET_SECOND_COMMANDS"),
|
||||
("worklane relate --blocked-by ", "TICKET_FLAGS"),
|
||||
("worklane chown --clear ", "the chown --clear rule"),
|
||||
];
|
||||
for (line, list) in ticket_value {
|
||||
let offered = candidates(&temp, line).unwrap();
|
||||
assert!(
|
||||
names(&offered).contains(&id.as_str()),
|
||||
"`{line}<TAB>` never offers the one ticket on the board, so {list} is not reaching it: {offered:?}"
|
||||
);
|
||||
}
|
||||
|
||||
let tag_value = [
|
||||
("worklane ls --tag ", "TAG_FLAGS"),
|
||||
("worklane append --tags ", "TAG_FLAGS"),
|
||||
("worklane tags set ", "TAG_NESTED_COMMANDS"),
|
||||
];
|
||||
for (line, list) in tag_value {
|
||||
let offered = candidates(&temp, line).unwrap();
|
||||
assert!(
|
||||
names(&offered).contains(&tag.as_str()),
|
||||
"`{line}<TAB>` never offers the one tag on the board, so {list} is not reaching it: {offered:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// **The script is handed to fish, which parses it without running it.**
|
||||
///
|
||||
/// The fish half is a hand-written `format!` string carrying single quotes, command
|
||||
/// substitutions and backslash line continuations, and every text assertion in this file
|
||||
/// is a `contains`, which a broken script satisfies exactly as well as a correct one.
|
||||
/// `--no-execute` is the parse without the run.
|
||||
///
|
||||
/// **What it catches is a script that does not parse**: quotes still open at the end of
|
||||
/// the file, an unclosed block. That is narrower than it sounds and the limit is worth
|
||||
/// writing down, because it was measured rather than assumed. An apostrophe interpolated
|
||||
/// into a `-d` description partway down the file re-balances against the next quote and
|
||||
/// parses, corrupting every rule in between while this test passes; the same apostrophe in
|
||||
/// the *last* rule reaches the end unbalanced and is caught. So this is a floor, not an
|
||||
/// oracle, and `fish_offers_the_commands_the_statuses_and_the_flags` is the one that reads
|
||||
/// what the rules actually do.
|
||||
///
|
||||
/// Only fish, because only fish gets a hand-written half. What the other four shells are
|
||||
/// given is clap's output whole, which `no_other_shell_gets_the_fish_half` pins, so a
|
||||
/// syntax error there would be clap's bug and not this repo's to catch.
|
||||
///
|
||||
/// **Skipped when fish is not on PATH, and it says so.** The trade is deliberate: there is
|
||||
/// no CI here and fish is the shell this tool is written for, so failing a machine that
|
||||
/// never had it would be a guard nobody could satisfy. A missing fish means the check did
|
||||
/// not run, not that it passed.
|
||||
#[test]
|
||||
fn fish_parses_the_script_it_is_given() {
|
||||
let temp = assert_fs::TempDir::new().unwrap();
|
||||
let path = temp.path().join("worklane.fish");
|
||||
std::fs::write(&path, script("fish")).unwrap();
|
||||
|
||||
let parsed = std::process::Command::new("fish")
|
||||
.arg("--no-execute")
|
||||
.arg(&path)
|
||||
.output();
|
||||
|
||||
let out = match parsed {
|
||||
Ok(out) => out,
|
||||
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
|
||||
eprintln!("skipped: fish is not on PATH, so the generated script went unparsed");
|
||||
return;
|
||||
}
|
||||
Err(err) => panic!("could not run fish: {err}"),
|
||||
};
|
||||
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"fish refuses the script `worklane completions fish` writes:\n{}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unknown_shell_is_a_usage_error() {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
|
||||
+81
-2
@@ -114,14 +114,16 @@ fn ls_with_invalid_status_fails() {
|
||||
.failure();
|
||||
}
|
||||
|
||||
/// Title is the last tiebreak, so the three share a due date and a priority: anything
|
||||
/// else here would be testing the due order instead, which has its own case.
|
||||
#[test]
|
||||
fn ls_listed_tickets_sorted_alphabetically() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
create_ticket(&worklane, "backlog", "Zebra", "alice", "2026-06-01");
|
||||
create_ticket(&worklane, "backlog", "Apple", "bob", "2026-07-01");
|
||||
create_ticket(&worklane, "backlog", "Mango", "charlie", "2026-08-01");
|
||||
create_ticket(&worklane, "backlog", "Apple", "bob", "2026-06-01");
|
||||
create_ticket(&worklane, "backlog", "Mango", "charlie", "2026-06-01");
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
@@ -744,6 +746,32 @@ fn create_stamped_ticket(
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
/// A backlog ticket with the due date that column is ordered by.
|
||||
///
|
||||
/// Backlog only, the way [`create_stamped_ticket`] is one status at a time: the due is
|
||||
/// what stands in for an entry stamp in the one column that has none, and `_Not set_`
|
||||
/// passed here is the undated case rather than a separate helper.
|
||||
fn create_due_ticket(
|
||||
worklane_dir: &std::path::Path,
|
||||
title: &str,
|
||||
uuid: &str,
|
||||
priority: &str,
|
||||
due: &str,
|
||||
) {
|
||||
let body = format!(
|
||||
"# {title}\n\n## Metadata\n\n- **ID**: {uuid}\n- **Priority**: {priority}\n\
|
||||
- **Tags**: test\n- **Due**: {due}\n- **Owner**: alice\n\
|
||||
- **Status**: backlog\n"
|
||||
);
|
||||
fs::write(
|
||||
worklane_dir
|
||||
.join("backlog")
|
||||
.join(format!("{uuid}_{}.md", slug(title))),
|
||||
body,
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
fn positions(stdout: &str, titles: [&str; 3]) -> Vec<usize> {
|
||||
titles
|
||||
.iter()
|
||||
@@ -828,6 +856,57 @@ fn ls_orders_done_by_the_newest_entry_stamp() {
|
||||
assert!(seen[0] < seen[1] && seen[1] < seen[2], "{stdout}");
|
||||
}
|
||||
|
||||
/// The backlog has no entry stamp, so the due date is its clock and the soonest deadline
|
||||
/// heads the column. The p1 here is due last and is listed last, which is exactly what
|
||||
/// priority alone got wrong.
|
||||
#[test]
|
||||
fn ls_orders_the_backlog_by_the_soonest_due_date() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let at = |n: u8| format!("dddd000{n}-0000-0000-0000-000000000001");
|
||||
create_due_ticket(&worklane, "Soonest", &at(1), "5", "2026-09-01");
|
||||
create_due_ticket(&worklane, "Latest", &at(2), "1", "2026-09-03");
|
||||
create_due_ticket(&worklane, "Between", &at(3), "3", "2026-09-02");
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "backlog"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
|
||||
let seen = positions(&stdout, ["Soonest", "Between", "Latest"]);
|
||||
assert!(seen[0] < seen[1] && seen[1] < seen[2], "{stdout}");
|
||||
|
||||
// The overview lists the same column, so it has to agree with the narrowed listing
|
||||
// rather than falling back to priority for the same tickets.
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).arg("ls");
|
||||
let overview = get_stdout(&mut cmd);
|
||||
|
||||
let seen = positions(&overview, ["Soonest", "Between", "Latest"]);
|
||||
assert!(seen[0] < seen[1] && seen[1] < seen[2], "{overview}");
|
||||
}
|
||||
|
||||
/// A due nobody promised must not outrank one somebody did. The undated ticket here is
|
||||
/// the most urgent of the three and still trails both, and among the dated ones the
|
||||
/// equal due falls through to priority.
|
||||
#[test]
|
||||
fn ls_sinks_an_undated_backlog_ticket_below_the_dated_ones() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let at = |n: u8| format!("eeee000{n}-0000-0000-0000-000000000001");
|
||||
create_due_ticket(&worklane, "Undated", &at(1), "1", "_Not set_");
|
||||
create_due_ticket(&worklane, "Urgent", &at(2), "3", "2026-09-01");
|
||||
create_due_ticket(&worklane, "Relaxed", &at(3), "5", "2026-09-01");
|
||||
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path()).args(["ls", "backlog"]);
|
||||
let stdout = get_stdout(&mut cmd);
|
||||
|
||||
let seen = positions(&stdout, ["Urgent", "Relaxed", "Undated"]);
|
||||
assert!(seen[0] < seen[1] && seen[1] < seen[2], "{stdout}");
|
||||
}
|
||||
|
||||
/// A missing stamp is unknown, not ancient, so it sinks below every stamped ticket
|
||||
/// rather than claiming the head of the queue. Every ticket on a board older than the
|
||||
/// stamps is one of these.
|
||||
|
||||
@@ -676,6 +676,140 @@ fn append_requires_at_least_one_section() {
|
||||
assert_eq!(run(&temp, &["append", UUID]).status.code(), Some(2));
|
||||
}
|
||||
|
||||
/// The reason the flag exists: `set --tags` writes the whole field, so adding one tag to
|
||||
/// a ticket that already carries some meant knowing and retyping every one of them.
|
||||
#[test]
|
||||
fn append_adds_a_tag_and_keeps_the_ones_already_there() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["append", UUID, "--tags", "beta"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- **Tags**: alpha, beta"), "{content}");
|
||||
// The sections and the other fields are as untouched as they are by any other append
|
||||
assert!(content.contains("- [x] Crit one\n- [ ] Crit two\n"), "{content}");
|
||||
assert!(content.contains("- **Priority**: 3"), "{content}");
|
||||
}
|
||||
|
||||
/// Idempotent on purpose: the caller of an append does not have to know what is there
|
||||
/// already, so naming a tag the ticket carries is reported as no change and writes
|
||||
/// nothing, the way an unchanged field is everywhere else.
|
||||
#[test]
|
||||
fn append_ignores_a_tag_the_ticket_already_carries() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &["append", UUID, "--tags", "alpha"]);
|
||||
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stdout).contains("No changes to"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&out.stdout)
|
||||
);
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
|
||||
// And the one already there is not added a second time beside a new one
|
||||
run(&temp, &["append", UUID, "--tags", "alpha", "--tags", "beta"]);
|
||||
assert!(
|
||||
ticket(&worklane).contains("- **Tags**: alpha, beta"),
|
||||
"{}",
|
||||
ticket(&worklane)
|
||||
);
|
||||
}
|
||||
|
||||
/// Two spellings for the same call, because the stored field is comma separated too and
|
||||
/// `set --tags` takes that form on this very field: refusing it on the counterpart would
|
||||
/// be a trap. New tags land in the order they were given, after the ones already there.
|
||||
#[test]
|
||||
fn append_takes_several_tags_by_repeated_flag_or_by_comma() {
|
||||
for args in [
|
||||
vec!["append", UUID, "--tags", "bug", "--tags", "tui"],
|
||||
vec!["append", UUID, "--tags", "bug, tui"],
|
||||
vec!["append", UUID, "-g", "bug,tui"],
|
||||
] {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
|
||||
let out = run(&temp, &args);
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{args:?}: {:?}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(ticket(&worklane).contains("- **Tags**: alpha, bug, tui"), "{args:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// A value that names no tag is refused rather than written, the way an all-blank section
|
||||
/// value is: `--tags ","` adds nothing, and writing the field back unchanged would report
|
||||
/// an append that never happened. Emptying the field is `set --clear tags`.
|
||||
#[test]
|
||||
fn append_refuses_a_tags_value_that_names_nothing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane);
|
||||
let before = ticket(&worklane);
|
||||
|
||||
// Empty at the parser, before the ticket is even resolved
|
||||
let empty = run(&temp, &["append", UUID, "--tags", ""]);
|
||||
assert_eq!(empty.status.code(), Some(2));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&empty.stderr).contains("value cannot be empty"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&empty.stderr)
|
||||
);
|
||||
// The message must not name a `--clear` this command does not have
|
||||
assert!(
|
||||
!String::from_utf8_lossy(&empty.stderr).contains("use --clear"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&empty.stderr)
|
||||
);
|
||||
|
||||
// Separators only, which the parser cannot see is empty
|
||||
let blank = run(&temp, &["append", UUID, "--tags", ", ,"]);
|
||||
assert_eq!(blank.status.code(), Some(1));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&blank.stderr).contains("Nothing to append to the tags"),
|
||||
"{:?}",
|
||||
String::from_utf8_lossy(&blank.stderr)
|
||||
);
|
||||
|
||||
assert_eq!(ticket(&worklane), before);
|
||||
}
|
||||
|
||||
/// A ticket with no tags starts the list rather than appending to the sentinel.
|
||||
#[test]
|
||||
fn append_writes_the_first_tag_over_the_unset_sentinel() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
|
||||
let mut add = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
add.current_dir(temp.path())
|
||||
.args(["add", "--title", "Untagged"])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let uuid = fs::read_dir(worklane.join("backlog"))
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().into_string().unwrap())
|
||||
.next()
|
||||
.map(|name| name.split('_').next().unwrap().to_string())
|
||||
.unwrap();
|
||||
|
||||
run(&temp, &["append", &uuid, "--tags", "bug"]);
|
||||
|
||||
let content = ticket(&worklane);
|
||||
assert!(content.contains("- **Tags**: bug"), "{content}");
|
||||
assert!(!content.contains("_None_"), "{content}");
|
||||
}
|
||||
|
||||
/// Owner belongs to chown and status to mv, so neither command offers them.
|
||||
#[test]
|
||||
fn neither_command_can_write_owner_or_status() {
|
||||
|
||||
+45
-3
@@ -275,6 +275,36 @@ fn clearing_the_tags_writes_a_tags_entry() {
|
||||
assert!(entry.starts_with("**Tags**\nalpha → _None_\n"), "{entry:?}");
|
||||
}
|
||||
|
||||
/// Tags are logged wherever they change, so the command that adds to them logs the same
|
||||
/// entry the one that replaces them does. The values come off the field rather than off
|
||||
/// the flag, so the entry records where the field went and not what the call added: an
|
||||
/// append of `beta` onto `alpha` reads as the pair, not as `beta`.
|
||||
#[test]
|
||||
fn appending_a_tag_writes_a_tags_entry() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane, "backlog");
|
||||
|
||||
run(&temp, &["append", UUID, "--tags", "beta"]);
|
||||
|
||||
let entry = only_entry(&worklane, "tags");
|
||||
assert!(entry.starts_with("**Tags**\nalpha → alpha, beta\n"), "{entry:?}");
|
||||
}
|
||||
|
||||
/// The sections are not logged, and appending to one is not a tag change: an append that
|
||||
/// touches no tag writes nothing, so the log does not fill with the edits it deliberately
|
||||
/// leaves out.
|
||||
#[test]
|
||||
fn appending_to_a_section_writes_nothing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane, "backlog");
|
||||
|
||||
run(&temp, &["append", UUID, "--acceptance", "One more criterion"]);
|
||||
|
||||
assert_eq!(entries(&worklane), vec![]);
|
||||
}
|
||||
|
||||
/// The entry names the campaign the way a reader knows it, the codename, not the uuid
|
||||
/// the field actually holds. A ticket never assigned starts from the sentinel an unset
|
||||
/// field reads as everywhere else.
|
||||
@@ -433,6 +463,7 @@ fn a_no_op_edit_writes_nothing() {
|
||||
vec!["mv", UUID, "--status", "backlog"],
|
||||
vec!["chown", "alice", UUID],
|
||||
vec!["set", UUID, "--tags", "alpha"],
|
||||
vec!["append", UUID, "--tags", "alpha"],
|
||||
] {
|
||||
let out = run(&temp, &args);
|
||||
assert!(
|
||||
@@ -577,10 +608,11 @@ fn the_actor_flag_names_the_writer_on_every_command_that_writes_one() {
|
||||
run(&temp, &["mv", UUID, "--status", "committed", "--actor", "opencode"]);
|
||||
run(&temp, &["chown", "bob", UUID, "--actor", "opencode"]);
|
||||
run(&temp, &["set", UUID, "--tags", "beta", "--actor", "opencode"]);
|
||||
run(&temp, &["append", UUID, "--tags", "gamma", "--actor", "opencode"]);
|
||||
run(&temp, &["assign", "v1", UUID, "--actor", "opencode"]);
|
||||
|
||||
let found = entries(&worklane);
|
||||
assert_eq!(found.len(), 5, "{found:?}");
|
||||
assert_eq!(found.len(), 6, "{found:?}");
|
||||
for (name, content) in found {
|
||||
assert!(content.contains("**Author**: opencode"), "{name}: {content:?}");
|
||||
}
|
||||
@@ -609,10 +641,11 @@ fn actor_from_git_names_the_git_user_on_every_command_that_writes_one() {
|
||||
run_for_the_human(&temp, &["mv", UUID, "--status", "committed", "--actor-from-git"]);
|
||||
run_for_the_human(&temp, &["chown", "bob", UUID, "--actor-from-git"]);
|
||||
run_for_the_human(&temp, &["set", UUID, "--tags", "beta", "--actor-from-git"]);
|
||||
run_for_the_human(&temp, &["append", UUID, "--tags", "gamma", "--actor-from-git"]);
|
||||
run_for_the_human(&temp, &["assign", "v1", UUID, "--actor-from-git"]);
|
||||
|
||||
let found = entries(&worklane);
|
||||
assert_eq!(found.len(), 5, "{found:?}");
|
||||
assert_eq!(found.len(), 6, "{found:?}");
|
||||
for (name, content) in found {
|
||||
assert!(content.contains("**Author**: Ansho Rei"), "{name}: {content:?}");
|
||||
}
|
||||
@@ -627,7 +660,7 @@ fn actor_and_actor_from_git_are_refused_together() {
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_ticket(&worklane, "backlog");
|
||||
|
||||
let calls: [&[&str]; 5] = [
|
||||
let calls: [&[&str]; 6] = [
|
||||
&[
|
||||
"comment",
|
||||
UUID,
|
||||
@@ -662,6 +695,15 @@ fn actor_and_actor_from_git_are_refused_together() {
|
||||
"opencode",
|
||||
"--actor-from-git",
|
||||
],
|
||||
&[
|
||||
"append",
|
||||
UUID,
|
||||
"--tags",
|
||||
"beta",
|
||||
"--actor",
|
||||
"opencode",
|
||||
"--actor-from-git",
|
||||
],
|
||||
&[
|
||||
"assign",
|
||||
"v1",
|
||||
|
||||
Reference in New Issue
Block a user