Compare commits

...
3 Commits
Author SHA1 Message Date
Ansho ReiandClaude Opus 5 a1bdb5df49 (87862df) Attribute an entry to WORKLANE_ACTOR, not to the git user, and bump to 0.28.0
Every comment the CLI wrote was attributed to the git user, so a board
several agents write to read as a list of things one human had done.
resolve_actor is now the single source: flag, then WORKLANE_ACTOR, then
get_git_user(), then unknown.

comment --owner is renamed to --actor with no alias, since it names the
writer of the entry and not the ticket's assignee, which is chown's.
add --owner and campaign add --owner still default to the git user.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-24 12:34:51 +02:00
Ansho Rei c2ee165108 (e4d0bb7) Colour the whole detail overlay body, not just its relations, and bump to 0.27.3
The block was the only coloured part because it arrived as rows while
everything else arrived as a painted string, and the board had to ask for
the unpainted one: an escape in a ratatui paragraph is drawn as literal
bytes.

content_parts now paints nothing. BodyPart::Text becomes
BodyPart::Cells, so content_trim is the cells through paint_cells and the
board is the same cells through span_from. push_heading, ordered_cells,
inline_cells, metadata_cells, metadata_value_cells and tag_cells replace
the painters they were. Resolved.campaign is cells too, which made
reference_cell dead at its last caller.

The colored flag still reaches content_parts and no longer means paint.
It says whether this renderer can carry a colour at all, and one thing
turns on it: **bold** gives its markers up to the colour that replaces
them, so a renderer with none has to keep them.

Color::Magenta.ansi() is \x1b[1;35m, so span_from adds the bold modifier
on the board's side, since From<Color> carries only the colour and the
same cell must not be painted two ways.

show's output is pinned byte for byte against what it printed before,
both by a fixture holding one of every painted run and by diffing the
old binary against the new one over every ticket and campaign on this
board, coloured and piped.
2026-08-24 11:57:25 +02:00
Ansho Rei 407cb14fe6 (e6e3a1b) Guard the README command table against a missing row
The campaign and assign rows landed with 528566d. What was left was the
checking, done here against the built binary rather than against the
ticket that added them.

The campaign ls row was incomplete: the listing also prints the derived
state, [open] until every member is done and [done] after, and reads
"no members" with no state for a campaign nothing has been filed
against, which is neither. Corrected.

every_subcommand_has_a_row_in_the_readme_command_table walks clap's own
subcommands, one level of nesting included, against the table's rows.
Two commands hid behind an otherwise complete table for two minor
versions because the only thing walking it was somebody remembering to.
The tag subcommands are named in a PENDING list rather than skipped,
since f7dd1a1 rewrites that row.
2026-08-24 11:28:32 +02:00
13 changed files with 804 additions and 187 deletions
+27 -11
View File
@@ -175,7 +175,7 @@ and this file is for what someone changing worklane's own code needs.
- **A campaign's state is derived, never stored.** Open until every member is done, computed by `Standing` from the members. A `Status` field on the campaign would be the same state in two places, and the two would disagree the moment a member moved. It is also why there is no `campaign mv` and no forward-only ruleset beside `mv`'s
- **A campaign with no members is neither open nor done.** `Standing::state()` returns `None` there, and both callers print `no members`. Calling it done would make a container nothing has been filed against the most complete thing on the board; calling it open would claim work that does not exist
- **Membership is one field on the member**, `Campaign` in the ticket Metadata, written only by `assign`. The member list is deliberately *not* on the campaign: that would put membership in two places, and would make one file that every assignment edits, which is contended the moment two agents share a board. So `add` has no `--campaign` and `set` has no `--campaign`, the same rule as Owner and Status
- **The full uuid is stored and the title is resolved for display**, as the Relations section already does. `reference_cell` is shared between the two, so a dangling campaign and a dangling relation target are both spelled `_missing_` rather than each inventing a spelling
- **The full uuid is stored and the title is resolved for display**, as the Relations section already does. `reference_cells` is shared between the two, so a dangling campaign and a dangling relation target are both spelled `_missing_` rather than each inventing a spelling
- **`add` does not write the field.** Every ticket written before campaigns existed has none, so the insertion path has to exist regardless; leaving it out of `add` means one path that is always exercised rather than two. Same reasoning as the Relations section
- `set_or_insert_metadata_field()` is the upsert, and `METADATA_ORDER` is its anchor list, the way `SECTION_ORDER` is `ensure_section`'s. Campaign is placed before Status, so Status stays last where every file already keeps it. A file with no `## Metadata` heading is an **error, not an insertion**: per 641e3d5 such a file has no fields at all, and writing one above the prose would invent a shape nothing reads
- **The four tiers are `resolve_in()`, shared by tickets and campaigns.** A campaign is addressed exactly the way a ticket is, and a second resolver would be a second copy of the precedence rules to keep in step. `Found.dir` is the status for a ticket and empty for a campaign, which is what makes the ambiguity listing drop the bracket for one
@@ -242,7 +242,7 @@ and this file is for what someone changing worklane's own code needs.
- **`the_count_is_read_when_the_items_are_collected_and_not_per_draw` takes the comments directory away after the board is built**, and is paired with `a_comment_added_after_the_board_was_built_reaches_the_card_on_reload`, because a count that never asks the filesystem again would pass the first test by never changing. The digest already moves when a comment lands, so the reload is what recounts
- **A card names its campaign on the label row, before the tags, in bold.** `labels_line` draws both, `CAMPAIGN_MARK` (`~`) for the campaign and `#` for a tag, and the campaign takes the row's width first: two cards in one campaign is what a reader looking for a campaign is looking for, and the tags are the context around it. So a row too narrow for both drops the tags whole and keeps the campaign, the order `corner_line` and `project_label` already follow, and a campaign the row will not hold at all goes whole too. A ticket in neither spends no row, so **a ticket in no campaign renders exactly as it did before campaigns reached the card**
- **`Card::campaign` is a resolved `Cell`, not a uuid**, settled at reload the way `project` and `blocked` are. `TicketItem::campaign` already carries the uuid off the pass that builds the card; the name is in another directory, so `columns_of` reads `CampaignIndex` once per project and hands it to every card. Never per draw, the rule `criteria` and `tags` already hold. The merge carries the resolved cell rather than looking it up again, for the reason it carries `blocked`: a campaign is addressed inside one `.worklane`, so a merged lookup could answer one project's uuid with another project's campaign
- **A campaign the board does not hold labels nothing**, the answer `mark_blocked` gives a dangling blocker. `campaign_cell` renders that case as `_missing_` because a metadata table is a place to report a dangling reference; a card is not
- **A campaign the board does not hold labels nothing**, the answer `mark_blocked` gives a dangling blocker. `campaign_cells` renders that case as `_missing_` because a metadata table is a place to report a dangling reference; a card is not
- **`c` opens the campaign picker, and taking a campaign filters the tab's columns to its members.** Not a fifth tab: a campaign groups across the flow, so the shape of the answer is the four statuses with fewer cards in them, which is what `campaign show` already answers the question in. Every column is kept, empty ones included. The filter is applied in `reload`, where the columns are built, so nothing downstream has to ask whether a campaign is selected — the board simply holds fewer cards, and `first_match`, `done_count` and the copy key all keep working unchanged
- **`Tab::campaign` is a uuid on the tab, not on the `Board`.** A campaign belongs to one `.worklane`, so a filter carried onto another project's tab would empty it and say nothing about why. It is looked up by uuid rather than held as an index, and a selection whose campaign has left the board is cleared by `reload` rather than left filtering the board to nothing
- **The frame above the columns has two heights, and `Chrome` is what every measurement takes.** `Chrome::campaign` is an `Option<FrameSize>`, not a bool: `None` for a tab showing the whole board, and `Collapsed` or `Expanded` for one filtered to a campaign, because both heights have to be measured the same way by everything that measures the board. `frame_rows` grew a row, so the two bools that decide the geometry became one `Chrome`, copied from `Board::chrome`: adjacent same-typed parameters are what the Rust Style rule warns about, and the draw and `follow_selection` have to measure one answer or a keypress scrolls against a board the next frame does not draw. The row indices are named (`TAB_ROW`, `CAMPAIGN_ROW`, `BOARD_ROW`, `FOOTER_ROW`), since an index written out by hand goes on meaning what it used to
@@ -328,7 +328,7 @@ and this file is for what someone changing worklane's own code needs.
### The Relations Block
- **One builder, two painters.** `relation_rows` decides which edges there are, what they are called and which direction comes first; `relation_cells` decides the layout, the mark and the colours; `paint_cells` turns cells into escapes for the CLI and `span_of` turns the same cells into ratatui spans for the board. Two builders producing one block in two shapes is a pair free to disagree about ordering or padding, which is what this shape exists to prevent
- **`Cell` is the unit both renderers take**: a run of text and the colour it is drawn in, `None` for the default foreground. The same trick as the palette itself, where `Color::ansi()` and `From<Color> for ratatui::style::Color` keep one colour from existing for one renderer and not the other
- **`reference_cells` is the one spelling of a cross reference**, and `reference_cell` is it painted. The relations block and the Campaign field both go through it, so a dangling reference reads the same way wherever it is shown
- **`reference_cells` is the one spelling of a cross reference.** The relations block and the Campaign field both go through it, so a dangling reference reads the same way wherever it is shown. There was a `reference_cell` beside it that painted the cells for the CLI; once the whole body became cells the Campaign field stopped needing a string and it was the last caller, so it is gone
- **A row carries two marks, kind then status**: what sort of edge this is, then how far the ticket at the other end has got. `blocked by × ◐ (6ce2c47) Title`. Two questions are asked of this block and one glyph could not answer both: which rows hold this ticket up, and whether the ones that do are finished
- The status went through one bad shape first. It was a rising bar, `▁▄▆█`, as the only mark, which read as an undifferentiated column of blocks and left the kind to five long words that blur when a ticket carries several. Then the kind took the column alone and the status was lost. Both, in that order, is the answer
- **Both directions of a kind carry one mark.** `blocked by` and `blocks` are the same edge read from two ends, and the label is what says which end you are on. `both_directions_of_a_kind_carry_one_mark` pins it
@@ -340,11 +340,15 @@ and this file is for what someone changing worklane's own code needs.
- **Committed and reviewing are told apart by colour alone**, both being `◐`, so a pipe cannot tell them apart: `should_use_colors` is false and both read as under way. Accepted, because `●` and `○` are the two answers usually wanted and `show` on the target settles the rest, and `assets/SKILL.md` says so outright rather than leaving an agent to infer it. Do not fix this by giving one of them a colour that means something else
- `RelationTarget` carries the title and the status in one `Option`, because they come from the same lookup and are absent together. It was taken out when the mark keyed on the kind alone and put back one commit later, which is the cost of a field nothing reads: correct at the time, and churn either way
- **`show` and the board carry the same mark**, decided rather than left to be discovered: the rows are one builder, so giving the CLI the mark cost nothing, and two views disagreeing about what a relation shows would be the kind of difference nobody can explain later. That makes it a change to what the CLI prints, so it is a minor
- **`Resolved.relations` is rows, not a rendered block.** That is what lets the board style them: an escape sequence in a ratatui paragraph is drawn as literal bytes (6d327df), so the block cannot arrive pre-painted. `content_parts` hands the text through already painted and the rows through untouched, which is the asymmetry the two renderers need
- **`BodyPart` splits the body rather than building it twice.** Everything outside the relations block is rendered once, by `content_parts`; `content_trim` is that with the rows painted, and the board is that with the rows styled. `Body` is the accumulator, so a caller pushes text and rows without tracking which it pushed last
- **`Resolved.relations` is rows, not a rendered block, and `Resolved.campaign` is cells for the same reason.** An escape sequence in a ratatui paragraph is drawn as literal bytes (6d327df), so nothing in `Resolved` can arrive pre-painted. This was the asymmetry the two renderers needed while the rest of the body was a painted string; there is no asymmetry left, since `content_parts` paints nothing at all
- **`BodyPart` splits the body rather than building it twice.** It is `Cells` or `Relations`: everything outside the block is laid out once, by `content_parts`, and `content_trim` is that run through `paint_cells` while the board is the same cells run through `span_from`. `Body` is the accumulator, so a caller pushes cells and rows without tracking which it pushed last, and it merges a run into the trailing cell when the colour matches, because the board draws a span per cell and the body is pushed a character at a time in places
- **`Detail.body` is a `Text`, and it is the only thing measured.** `last_offset` and the `Paragraph` both take it, so the clamp cannot wrap the body differently from the draw. `Detail::plain()` flattens it for the suite and is `#[cfg(test)]`: a second representation carried alongside the spans is a second thing to disagree
- `detail_body` closes a line only where the text says, so a part that does not end on a newline runs on into the next one. The seam between text and rows is wherever the body put it rather than wherever a part happened to end
- **The relations block is the only coloured part of the overlay body, and that is a decision, not an oversight.** The headings, the plan numbers, the criteria marks, the bold runs and the grey unset values are all painted by `show` and all flat on the board. The block earned its colour because it is where a reader compares several references at once, and because it was already data rather than prose: it arrives as rows for the status mark, so styling it cost nothing extra. Colouring the rest means giving every painted run in `content_parts` the `Cell` treatment, which is a much larger change with no reader's question behind it, and it is its own ticket. Do not paint one more section here without taking that on: two coloured sections and five plain ones reads as a bug, where one clearly does not
- `detail_body` closes a line only where the text says, so a part that does not end on a newline runs on into the next one. The seam between text and rows is wherever the body put it rather than wherever a part happened to end. It now splits **per cell** rather than per part, since a `Cells` part holds many runs and a newline can fall inside any of them
- **The whole overlay body is coloured now, and `content_parts` paints nothing.** The block used to be the only coloured part, because it arrived as rows while everything else arrived as a painted string; e4d0bb7 gave the rest the same `Cell` treatment. So the headings, the plan numbers, the criteria numbers and marks, the bold runs, the field names, the priority glyph, the tags and the grey unset values are one layout that `show` paints and the board styles. Do not reintroduce a `paint` call in `content_parts`: the flat overlay was exactly that, a renderer forced to ask for the unpainted string because the painted one held escapes
- **`colored` still reaches `content_parts`, and it no longer means paint.** It says whether *this* renderer can carry a colour at all, and one thing turns on it: `**bold**` gives its markers up to the colour that replaces them, so a renderer with none has to keep them or the emphasis is lost rather than moved. The board passes `true`, `content_trim` passes the CLI's decision, and a piped `show` still reads its markers. Nothing else in the body consults it
- **Magenta means bold, and `span_from` is where the board learns that.** `Color::Magenta.ansi()` is `\x1b[1;35m`, so the CLI draws every bold run bold as well as magenta, and `From<Color>` can carry only the colour. Without the modifier added on the board's side the same cell would be painted two ways, which is the one thing the shared layout exists to prevent
- **The conversion is pinned from both ends.** `show_prints_the_same_body_it_printed_before_the_cells_conversion` holds a body with one of every painted run and asserts the CLI's output byte for byte, written from what it printed before the change, so the risk in sharing a layout, the CLI's output drifting to suit the board, fails the suite. `the_whole_body_is_styled_in_the_overlay_and_no_escape_reached_it` is the other end and is paired the way the guideline demands: a renderer that dropped every colour passes the absence, and one that went back to painting strings passes the presence
- **The comments block is still flat, and it is the last piece that is.** `format_comments_with` is a string the board appends after the body rather than part of what `content_parts` lays out, so it was outside e4d0bb7. Its own ticket
### Finding the Board
- **`find_worklane_dir` classifies the entry before it follows it.** `exists()` follows a link, so a `.worklane` that was a dangling symlink answered the same as no `.worklane` at all: the walk carried on up the tree and the first board above the project became the one every write landed in, silently. `classify` reads `symlink_metadata` first and answers one of four, `Absent`, `Board`, `Dangling` or `NotADirectory`, and **`Absent` is the only one the walk carries on from**. A `.worklane` that is there but unusable is this project's board and is reported, not handed upward
@@ -367,6 +371,17 @@ and this file is for what someone changing worklane's own code needs.
- **The tab row is drawn only when there is more than one board**, so a single board is the view it has always been. `frame_rows()` gives it `Length(0)` otherwise, which keeps the row indices the same for both cases and is shared with `card_width` and `column_text_height` for the reason `column_areas` is: geometry reproduced by hand drifts from the draw
- `digest_of` hashes each board's `digest` into one value, so a change in any of them redraws. Do not watch only the first
### Who Wrote an Entry
- **Identity is supplied, not detected.** Every option that needs no cooperation fails: a harness variable such as `CLAUDECODE` names the tool rather than the instance and breaks across versions, walking the parent process is platform specific and also only names the harness, and a terminal check separates interactive from not, which a human piping output is too. So the actor is `WORKLANE_ACTOR`, set once per session, with `--actor` as the per-call override
- **Precedence: flag, then `WORKLANE_ACTOR`, then `get_git_user()`, then `unknown`.** `resolve_actor` is the only caller of `get_git_user` for an entry's author, and every entry the CLI writes goes through it. The two halves are separate pure functions, `session_actor` and `entry_actor`, tested without touching the process environment for the reason `colors_wanted` is split that way
- **The session half is cached in a `OnceLock`, the way `should_use_colors` is:** neither the variable nor the git user can change mid-run, and the fallback costs a `git config` subprocess. `session_actor` takes the git user as a closure so that subprocess is not run when the variable already answered
- An **empty `WORKLANE_ACTOR` counts as unset**, the convention `colors_wanted` follows for `NO_COLOR`, so a wrapper script can clear an inherited one. Whitespace counts the same, since a shell quoting a missing value writes one
- **The actor is free text, checked against nothing**, like the `chown` user: there is no registry of actors, and the same reason `ls --tag` refuses to validate a tag
- **It was `comment --owner`, renamed with no alias.** Owner is the ticket's assignee and has one writer, `chown`; this names the writer of the entry, which is a different field. Pre-1.0, and two names for one thing is what splitting `set` and `chown` avoided. `the_owner_flag_is_gone` pins the refusal, since an alias kept "for now" is what makes the wrong name permanent
- **`add --owner` and `campaign add --owner` still default to the git user, deliberately.** Those write the assignee, and a ticket an agent files is work for the person whose board it is; attributing it to the agent would put its name in the Owner column of everything it reported
- **An entry does not record whether the call had a terminal.** It is the one agent signal that needs no cooperation, so it was worth considering, and it was rejected: it cannot name an actor, a human piping output produces the same value, and once the actor is explicit the extra field answers no question anybody asks
- **Set it in the agent's configuration, not per call.** `env` in `~/.claude/settings.json` reaches every command Claude Code runs. opencode has no equivalent: its config is JSON with no `env` block for the tools it spawns, so it inherits the environment it was started with, which means a wrapper or a shell function around `opencode`. Both are documented in `assets/SKILL.md` rather than assumed
### 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
- **`assets/SKILL.md` is the only worklane skill document in this repo, and nothing may reintroduce a second.** There was one: `.opencode/skill/worklane-kanban-skill/SKILL.md`, 223 lines of the same document that nothing shipped and no test checked, and it drifted exactly as far as a copy nobody reads does. Its frontmatter still called the skill `worklane_kanban`, its examples still used short flags the CLI had stopped accepting, and it knew nothing about `relate`, `campaign`, `chown`, `check` or the four-status flow. It was **not** inert while it existed: `opencode debug skill` listed it, so an agent working in this repo saw two worklane skills and could load either. Deleted by b2c5531. A copy under `.opencode/`, in a second assets file, or in the README is the same mistake; the document has one home and `install-skill` is how it travels
@@ -394,11 +409,12 @@ and this file is for what someone changing worklane's own code needs.
- **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
- **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
### Color and Output
- Use `color_text()` for coloured output — it respects `should_use_colors()` (terminal detection), and `paint()` is the same with the decision passed in
- **`color_text()` is for the CLI's own printing only. Anything reachable from `content_trim` takes the decision as an argument and calls `paint()`**, because the board renders with colour off and an escape sequence in a ratatui paragraph is drawn as literal bytes. `nothing_the_body_renders_asks_the_terminal_for_the_colour_decision` scans this file and fails on a new caller; the allowlist is `ambiguous`, which builds a failed-search message for stderr
- A function that takes an `enabled` flag must use it all the way down. `colorize_inline` honoured its flag on the early return and then asked `should_use_colors()` for the bold run, which made the flag a lie in half the function
- A function that takes an `enabled` flag must use it all the way down. The inline pass honoured its flag on the early return and then asked `should_use_colors()` for the bold run, which made the flag a lie in half the function. The better answer, where it fits, is to take no flag: `ordered_cells` and `metadata_value_cells` return the colour rather than a decision about it
- **A test that asserts an absence has to be paired with one that asserts the presence.** The guard for this, an assert that the detail view holds no escape byte, could not fail: a test binary has no tty, so `should_use_colors()` was false and the leaking branch was never taken. The pair is now `content_trim(.., false)` has no escape and `content_trim(.., true)` still colours, which pins the flag as the only thing that decides
- **The palette is the `Color` enum, not a string.** `Color::ansi()` gives the CLI its SGR sequence and `From<Color> for ratatui::style::Color` gives the TUI its equivalent, so a colour that exists for one renderer and not the other is a compile error. The stringly-typed version needed a test for exactly that, and a missing entry silently produced an empty prefix, which is how `magenta` came to be undefined
- Reset color with `\x1b[0m` after colored text
@@ -427,9 +443,9 @@ and this file is for what someone changing worklane's own code needs.
- Grey is indexed colour 8 in the 256-colour form, not SGR 90 or 37. Both of those failed on a real palette: 90 leans on the bright-black slot and 37 can sit on top of the default foreground. `\x1b[38;5;8m` is byte for byte what crossterm emits for ratatui's `Color::DarkGray`, the grey frig and pantop use for dimmed rows
### Code Organization
- Colorization functions (`colorize_ordered`, `colorize_inline`, `content_trim_colored`) handle markdown formatting. `colorize_line` is gone: it was a `pub` alias for the bold pass with one caller, and the only thing it added was asking the terminal
- **`colorize_inline` walks the line once for both inline markers**, `**bold**` and `[text](url)`, rather than running one pass over the output of the other. A second pass would be scanning text that already holds escape sequences, and `\x1b[36m` carries an opening bracket, so the link scan would take the escape for markup. The source is the only string in which either marker means what it says. It was `colorize_bold` while links lived in a branch of their own in `content_parts`; that branch is gone, which is also what gives the criteria text and the metadata `Other` rows their links, since those already went through this function
- `show` renders the Metadata section as a two column table via `render_metadata_table`, not line by line. Column width is measured on the raw field names in characters and padding is applied before anything is styled: measuring a coloured string counts its escapes towards its width. `paint()` is `color_text()` with the colour decision passed in, which is what lets a test render both ways in one process
- The body's painters return cells, not strings: `ordered_cells`, `inline_cells`, `metadata_cells`, `metadata_value_cells`, `tag_cells` and `push_heading`. `content_trim_colored` is the CLI entry point and `paint_cells` is the only thing that writes an escape. `colorize_line` is gone: it was a `pub` alias for the bold pass with one caller, and the only thing it added was asking the terminal
- **`inline_cells` walks the line once for both inline markers**, `**bold**` and `[text](url)`, rather than running one pass over the output of the other. A second pass would be scanning text that already holds escape sequences, and `\x1b[36m` carries an opening bracket, so the link scan would take the escape for markup. The source is the only string in which either marker means what it says. It was `colorize_bold` while links lived in a branch of their own in `content_parts`; that branch is gone, which is also what gives the criteria text and the metadata `Other` rows their links, since those already went through this function
- `show` renders the Metadata section as a two column table via `metadata_cells`, not line by line. Column width is measured on the raw field names in characters and the padding goes into a cell of its own, so nothing is ever measured with a colour on it: measuring a painted string counts its escapes towards its width. `paint()` is `color_text()` with the colour decision passed in, which is what lets a test render both ways in one process
- The title is printed once, by `cmd_show`. `content_trim_colored` skips the `# ` heading in the file content
- Rules under headings are measured on the displayed name in characters, never on the raw line or in bytes
- `resolve_ticket()` scans all status directories — it's the single source for ticket lookup by UUID prefix, title, or filename
Generated
+1 -1
View File
@@ -1503,7 +1503,7 @@ dependencies = [
[[package]]
name = "worklane"
version = "0.27.2"
version = "0.28.0"
dependencies = [
"anyhow",
"assert_cmd",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "worklane"
version = "0.27.2"
version = "0.28.0"
edition = "2024"
[dependencies]
+10 -2
View File
@@ -17,11 +17,11 @@ Worklane is a local Kanban flow for agentic software development.
| `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 |
| `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 |
| `worklane uncheck <ticket> [criteria...]` | Unticks acceptance criteria, addressed the same way |
| `worklane comment <ticket> <body>` | Adds a comment to a ticket by UUID or title |
| `worklane comment <ticket> <body>` | Adds a comment to a ticket by UUID or title. The author is `--actor`, or `WORKLANE_ACTOR`, or the git user, in that order |
| `worklane campaign add` | Files a campaign in `.worklane/campaigns/` with `--title`, `--description`, `--codename` and `--owner`. A campaign has no status: its state is derived, open until every member is done. `--codename` is one word to call it by, `v1` or `beaver`, which is what the board draws on every card in it and what every command that takes a campaign will also resolve it by |
| `worklane campaign set <campaign>` | Replaces `--title`, which renames the file keeping the uuid, `--description` and `--codename`. At least one required. The way a campaign filed before codenames existed gets one, and the way a description filed with a typo in it gets fixed. Replacing a codename the campaign already has needs `--force`, since that is the word it is referred to by everywhere; setting the one it already has is a no-op either way. A description needs no `--force`: it is prose written to be revised. No `--clear` and no `--owner` |
| `worklane campaign append <campaign>` | Adds a paragraph to a campaign's description with `--description`, which is required. The other half of `campaign set --description`, so adding a line to a description does not mean retyping the rest of it. Repeat the flag for more lines within the one paragraph. Its own subcommand rather than the top-level `append`, which resolves a ticket |
| `worklane campaign ls` | Lists the campaigns as their short id, their codename, their title and how many members are done. `--ids` prints one per line as the id, a tab and the title, unstyled, for a script or a completion |
| `worklane campaign ls` | Lists the campaigns as their short id, their codename, their title, how many members are done, and the state that count derives: `[open]` until every member is done and `[done]` after. A campaign nothing has been filed against reads `no members` and carries no state, being neither. `--ids` prints one per line as the id, a tab and the title, unstyled and without the counts, which read every ticket on the board, for a script or a completion |
| `worklane campaign show <campaign>` | Shows a campaign and its members grouped by status, done included, since what is finished against what is left is the question a campaign asks |
| `worklane assign <campaign> <ticket>` | Puts a ticket in a campaign, the only command that writes the Campaign field. Campaign first and ticket second, after `chown`. A ticket is in at most one, so assigning one that already belongs somewhere moves it |
| `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 |
@@ -29,6 +29,14 @@ Worklane is a local Kanban flow for agentic software development.
| `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 |
## Environment
| Variable | Effect |
|----------|--------|
| `WORKLANE_ACTOR` | Who every entry the CLI writes is attributed to: today the author of a comment. Set it once, in the environment an agent runs in, and every call it makes is attributed to it instead of to the git user of whoever's machine it is on. `--actor` overrides it per call, an empty value counts as unset, and with neither supplied the author is the git user and then `unknown`. Free text, checked against nothing |
| `NO_COLOR` | Set and non-empty turns colour off, whatever the value, per no-color.org. Colour is also off when output is not a terminal, and when `TERM` is `dumb` or empty |
| `XDG_CONFIG_HOME` | Where `install-tool` looks for opencode's config root, `$XDG_CONFIG_HOME/opencode`, defaulting to `~/.config`. `install-skill` does not follow it: `~/.claude` is not an XDG path |
## Completions
```sh
+26 -2
View File
@@ -270,6 +270,27 @@ existing ticket will have been written from a different angle.
- Related but not the same: file it, and record it with `relate <new> --relates-to <old>`
rather than only mentioning the id in prose.
## Who your entries are attributed to
Every comment carries an author, and by default that is the git user of the machine you
are running on, which is the human whose checkout it is and not you. Set
`WORKLANE_ACTOR` in your own environment and it becomes the author of every entry you
write, so a board several agents write to says which of them said what:
```
WORKLANE_ACTOR=claude worklane comment 1b78a24 "The offset was never passed to the widget."
```
Set it once where your session's environment is configured, not on each call: `env` in
`~/.claude/settings.json` for Claude Code, and the environment opencode is started with
for opencode, since it passes its own environment to the tools it runs. `--actor` on
`comment` overrides it for one call, an empty value counts as unset and falls back to the
git user, and with nothing at all the author is `unknown`. It is free text, checked
against nothing: name yourself something a person reading the board will recognise.
If the variable is not set and you cannot set it, pass `--actor` rather than letting the
comment claim to be the user's.
## Shell completions
```
@@ -300,8 +321,8 @@ the candidates and exits 1 rather than guessing.
`--print is supported` is stored, not parsed as a flag. The cost is that a genuinely
mistyped flag there lands as content instead of failing, so read back what you wrote
with `worklane show`.
- `--due`, `--priority`, `--tags`, `--owner` and `--status` do *not* accept one, so a
mistyped flag on those is a usage error and nothing is written.
- `--due`, `--priority`, `--tags`, `--owner`, `--actor` and `--status` do *not* accept one,
so a mistyped flag on those is a usage error and nothing is written.
- A ticket argument that starts with a hyphen needs the flags first and a separator:
`worklane mv --status committed -- -leading-title`.
- A comment body of exactly `--` needs its own separator:
@@ -309,4 +330,7 @@ the candidates and exits 1 rather than guessing.
- An empty value for a scalar is a usage error, not a way to clear the field: use
`--clear`. For a section an empty value is a paragraph break, so it cannot mean empty
the section either, and an all-blank one is refused with the `--clear` for it named.
- **`comment` has no `--owner`.** Owner is the ticket's assignee, which `chown` writes;
the author of a comment is `--actor` or `WORKLANE_ACTOR`. The old spelling is a usage
error, not an alias.
- Piping is safe: `worklane ls | head -3` exits on the closed pipe instead of panicking.
+3 -3
View File
@@ -247,9 +247,9 @@ export const comment = tool({
body: tool.schema
.string()
.describe("Comment body text (required). Supports markdown formatting and multiple paragraphs separated by newlines."),
owner: tool.schema
actor: tool.schema
.string()
.describe("Comment author. If omitted, defaults to the git user.")
.describe("Who the comment 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) {
@@ -261,7 +261,7 @@ export const comment = tool({
}
const cmd: string[] = ["comment", args.ticket, args.body];
if (args.owner) cmd.push("--owner", args.owner);
if (args.actor) cmd.push("--actor", args.actor);
try {
return await run(cmd, context);
+5 -5
View File
@@ -173,22 +173,22 @@ impl CampaignIndex {
/// target does, rather than as the bare value the file stores: the value is a full
/// uuid, so showing it raw is thirty-six characters that say nothing about what is
/// gone.
pub fn campaign_cell(content: &str, index: &CampaignIndex, colored: bool) -> String {
pub fn campaign_cells(content: &str, index: &CampaignIndex) -> Vec<Cell> {
let Some(uuid) = parse_campaign(content) else {
return String::new();
return Vec::new();
};
reference_cell(&uuid, index.get(&uuid).map(|campaign| campaign.title.as_str()), colored)
reference_cells(&uuid, index.get(&uuid).map(|campaign| campaign.title.as_str()))
}
/// The parts [`content_trim`] cannot render from the ticket file alone.
///
/// Both halves read the tree beside the ticket, so they are gathered in one place
/// rather than at each call site.
pub fn resolved_for(content: &str, worklane_dir: &Path, colored: bool) -> Result<Resolved> {
pub fn resolved_for(content: &str, worklane_dir: &Path) -> Result<Resolved> {
Ok(Resolved {
relations: relations_for(content, worklane_dir)?,
campaign: campaign_cell(content, &CampaignIndex::load(worklane_dir)?, colored),
campaign: campaign_cells(content, &CampaignIndex::load(worklane_dir)?),
})
}
+72 -3
View File
@@ -267,9 +267,13 @@ pub enum Command {
#[arg(allow_hyphen_values = PROSE)]
body: String,
/// Owner
#[arg(short, long)]
owner: Option<String>,
/// Who the comment is attributed to, overriding `WORKLANE_ACTOR` and the git
/// user. Free text, checked against nothing
///
/// Named after the writer of the entry, not after the ticket's assignee, which
/// is `chown`'s. It was `--owner`, which said the wrong one of the two.
#[arg(long)]
actor: Option<String>,
},
/// Group tickets that have to be finished together
@@ -881,3 +885,68 @@ pub struct CheckArgs {
/// Criterion indexes as shown by `show`, substrings of their text, or `all`. Prompts if omitted
pub criteria: Vec<String>,
}
#[cfg(test)]
mod tests {
use super::*;
use clap::CommandFactory;
/// The command names as the README table would have to spell them: `campaign add`
/// for a nested one, the bare name for a top level one. `help` is clap's own and
/// documents nothing.
fn documented_names() -> Vec<String> {
let cli = Cli::command();
let mut names = Vec::new();
for sub in cli.get_subcommands() {
if sub.get_name() == "help" {
continue;
}
names.push(sub.get_name().to_string());
for nested in sub.get_subcommands() {
if nested.get_name() == "help" {
continue;
}
names.push(format!("{} {}", sub.get_name(), nested.get_name()));
}
}
names
}
/// Every subcommand has a row in the README's command table.
///
/// `campaign` and `assign` went undocumented for two minor versions, e6e3a1b, and
/// the `--campaign` flag went with them, because the only thing walking the table
/// was somebody remembering to. This is what walks it. A command whose row is
/// missing is a command a reader of the README cannot discover at all, which is a
/// worse failure than a row that is merely out of date.
#[test]
fn every_subcommand_has_a_row_in_the_readme_command_table() {
// The tag subcommands are f7dd1a1's, which rewrites the `worklane tags` row
// once the vocabulary work above it has landed. Listed rather than skipped, so
// emptying this is part of closing that ticket rather than something to
// rediscover.
const PENDING: [&str; 3] = ["tags add", "tags set", "tags ls"];
let readme = include_str!("../README.md");
let table: String = readme.lines().filter(|line| line.starts_with('|')).collect();
let missing: Vec<String> = documented_names()
.into_iter()
.filter(|name| !PENDING.contains(&name.as_str()))
.filter(|name| !table.contains(&format!("`worklane {}", name)))
.collect();
assert!(
missing.is_empty(),
"no row in the README command table for {missing:?}. A new command is not \
shipped until the table lists it: that table is the only place a reader \
discovers one, and two commands hid behind an otherwise complete table \
for two minor versions."
);
}
}
+3 -6
View File
@@ -443,7 +443,7 @@ pub fn cmd_show(search: &str, worklane_dir: &Path) -> Result<()> {
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.
let resolved = resolved_for(&content, worklane_dir, should_use_colors())?;
let resolved = resolved_for(&content, worklane_dir)?;
// The only title in the output: content_trim_colored used to print it a second
// time from the file content. Green per the colour guideline, and the rule is
@@ -725,7 +725,7 @@ pub fn cmd_mv(ticket_id: &str, target: Status, force: bool, start: &Path) -> Res
pub fn cmd_comment(
ticket_id: &str,
body: &str,
owner: &Option<String>,
actor: &Option<String>,
start: &Path,
) -> Result<()> {
if body.is_empty() {
@@ -745,10 +745,7 @@ pub fn cmd_comment(
let stem = Local::now().format(COMMENT_FILE_FORMAT).to_string();
let author = match owner {
Some(o) => o.clone(),
None => get_git_user().unwrap_or_else(|| "unknown".to_string()),
};
let author = resolve_actor(actor.as_deref());
let comment_content = format!(
"**Comment**\n\
+2 -2
View File
@@ -63,8 +63,8 @@ fn main() -> Result<()> {
Some(Command::Chown(args)) => cmd_chown(&args, &start),
Some(Command::Check(args)) => cmd_check(&args, true, &start),
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
Some(Command::Comment { ticket, body, owner }) => {
cmd_comment(&ticket, &body, &owner, &start)
Some(Command::Comment { ticket, body, actor }) => {
cmd_comment(&ticket, &body, &actor, &start)
}
Some(Command::Campaign { command }) => match command {
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
+116 -19
View File
@@ -1902,7 +1902,7 @@ fn detail_of(card: &Card) -> Detail {
// read of one small directory beside it, for the same reason `show` pays it: the
// field stores a uuid, and a card that displayed one raw would say nothing.
let resolved = worklane_dir
.and_then(|dir| crate::campaign::resolved_for(&content, dir, false).ok())
.and_then(|dir| crate::campaign::resolved_for(&content, dir).ok())
.unwrap_or_default();
let comments = match worklane_dir {
Some(worklane_dir) => {
@@ -1911,10 +1911,16 @@ fn detail_of(card: &Card) -> Detail {
None => Vec::new(),
};
// Colour off for the text, which is what keeps escapes out of the paragraph, and the
// relations arrive as rows so the board can style them itself.
let mut parts = content_parts(&content, false, &resolved);
parts.push(BodyPart::Text(format!("\n{}", format_comments_with(&comments, false))));
// Colour on, and nothing here is painted: the body arrives as cells and the
// relations as rows, and `detail_body` turns both into styled spans. An escape
// sequence never enters, which is what a ratatui paragraph would draw as literal
// bytes. The comments are still flat, being a string the board appends rather than
// part of the rendered body.
let mut parts = content_parts(&content, true, &resolved);
parts.push(BodyPart::Cells(vec![Cell::plain(format!(
"\n{}",
format_comments_with(&comments, false)
))]));
Detail {
title: ticket.title.clone(),
@@ -1936,17 +1942,19 @@ fn detail_body(parts: &[BodyPart]) -> Text<'static> {
for part in parts {
match part {
BodyPart::Text(text) => {
let mut rest = text.as_str();
while let Some((line, tail)) = rest.split_once('\n') {
if !line.is_empty() {
open.push(Span::raw(line.to_string()));
BodyPart::Cells(cells) => {
for cell in cells {
let mut rest = cell.text.as_str();
while let Some((line, tail)) = rest.split_once('\n') {
if !line.is_empty() {
open.push(span_from(line, cell.color));
}
lines.push(Line::from(std::mem::take(&mut open)));
rest = tail;
}
if !rest.is_empty() {
open.push(span_from(rest, cell.color));
}
lines.push(Line::from(std::mem::take(&mut open)));
rest = tail;
}
if !rest.is_empty() {
open.push(Span::raw(rest.to_string()));
}
}
// One line each, from the same cells `render_relations` paints, so the block
@@ -1972,10 +1980,26 @@ fn detail_body(parts: &[BodyPart]) -> Text<'static> {
/// The other half of `paint_cells`, which is the CLI's. `From<Color>` is what makes the
/// two agree about what the colour is.
fn span_of(cell: Cell) -> Span<'static> {
match cell.color {
Some(color) => Span::styled(cell.text, Style::default().fg(color.into())),
None => Span::raw(cell.text),
span_from(cell.text, cell.color)
}
/// The same, for a renderer holding the two halves of a cell rather than the cell.
///
/// The bold on magenta is not a flourish. `Color::Magenta.ansi()` is `\x1b[1;35m`, so
/// the CLI draws every bold run bold as well as magenta, and a board that dropped the
/// modifier would be painting the same cell differently from the CLI. The colour is the
/// only thing `From<Color>` can carry, so the attribute has to be added on this side.
fn span_from(text: impl Into<String>, color: Option<Color>) -> Span<'static> {
let Some(color) = color else {
return Span::raw(text.into());
};
let mut style = Style::default().fg(color.into());
if color == Color::Magenta {
style = style.add_modifier(Modifier::BOLD);
}
Span::styled(text.into(), style)
}
/// The four columns of one board, with each card's campaign already named.
@@ -2189,7 +2213,7 @@ fn retain_campaign(mut columns: Vec<Column>, campaign: Option<&str>) -> Vec<Colu
/// The label for the campaign a ticket names, or nothing when it names none.
///
/// Nothing, too, for a uuid the index does not hold. `campaign_cell` renders that case as
/// Nothing, too, for a uuid the index does not hold. `campaign_cells` renders that case as
/// `_missing_` because a metadata table is a place to report a dangling reference; a card
/// is not, and the answer here is the one `mark_blocked` gives a blocker nobody holds.
fn campaign_of(ticket: &TicketItem, campaigns: &CampaignIndex) -> Option<Cell> {
@@ -6658,6 +6682,79 @@ mod tests {
);
}
/// Every painted run in the body reaches the overlay as a style, e4d0bb7.
///
/// The block was the only coloured part of the body; the rest was flat because
/// `content_parts` painted into a string and the board had to ask for the unpainted
/// one. It hands out cells now, so the CLI paints them and the board styles them,
/// and there is one layout behind both.
///
/// Paired the way the guideline demands, and both halves are load bearing here: a
/// renderer that dropped every colour would pass the absence, and one that went back
/// to painting strings would pass the presence.
#[test]
fn the_whole_body_is_styled_in_the_overlay_and_no_escape_reached_it() {
let dir = board_dir();
let uuid = "11111111-0000-4000-8000-000000000000";
std::fs::write(
dir.join("backlog").join(format!("{uuid}_a-painted-one.md")),
format!(
"# A painted one\n\n## Description\n\nA line with **emphasis** in it.\n\n\
## Acceptance Criteria\n\n- [ ] Something\n\n\
## Implementation Plan\n\n1. A step\n\n\
## Metadata\n\n- **ID**: {uuid}\n- **Due**: _Not set_\n\
- **Tags**: bug\n- **Status**: backlog\n"
),
)
.unwrap();
let mut board = one_board(&dir);
board.toggle_detail();
let detail = board.detail.as_ref().expect("no detail");
// One run per colour the guideline gives the body, each asked for by name so a
// run that goes flat names itself in the failure.
let heading = body_line(detail, "Description");
assert_eq!(span_color(&heading, "Description"), Some(Color::Orange.into()));
let emphasis = body_line(detail, "emphasis");
assert_eq!(span_color(&emphasis, "emphasis"), Some(Color::Magenta.into()));
let criterion = body_line(detail, "Something");
assert_eq!(span_color(&criterion, "1."), Some(Color::Cyan.into()));
assert_eq!(span_color(&criterion, "[ ]"), Some(Color::Grey.into()));
let step = body_line(detail, "A step");
assert_eq!(span_color(&step, "1."), Some(Color::Cyan.into()));
let due = body_line(detail, "_Not set_");
assert_eq!(span_color(&due, "Due"), Some(Color::Red.into()));
assert_eq!(span_color(&due, "_Not set_"), Some(Color::Grey.into()));
let tags = body_line(detail, "bug");
assert_eq!(span_color(&tags, "bug"), Some(tag_color("bug").into()));
// `Color::Magenta.ansi()` is `\x1b[1;35m`, so the CLI draws a bold run bold as
// well as magenta. The board has to add the modifier itself, since `From<Color>`
// carries only the colour.
let bold = emphasis
.spans
.iter()
.find(|span| span.content.as_ref() == "emphasis")
.expect("no emphasis span");
assert!(
bold.style.add_modifier.contains(Modifier::BOLD),
"the bold run is magenta but not bold: {bold:?}"
);
// The other half: none of that arrived as bytes.
assert!(
!detail.plain().contains('\x1b'),
"escapes reached the body: {:?}",
detail.plain()
);
}
/// A target the board no longer holds keeps the id, which is the only thing left to
/// go looking for, and says `_missing_` in the grey that means an unset value. The
/// colour must not turn a gap into something that reads like a real target.
+406 -120
View File
@@ -416,6 +416,63 @@ pub fn get_git_user() -> Option<String> {
}
})
}
/// The variable that names the writer of an entry, set once per session.
///
/// A per-call flag can be forgotten on the fortieth call; a variable set by an agent's
/// own configuration is inherited by every call it makes.
pub const ACTOR_ENV: &str = "WORKLANE_ACTOR";
/// The author written when nothing names one.
pub const UNKNOWN_ACTOR: &str = "unknown";
/// The actor for the whole run: the variable, then the git user.
///
/// Split out from the caching wrapper for the reason `colors_wanted` is: a threaded test
/// binary cannot mutate the process environment to reach one branch at a time.
///
/// An empty `WORKLANE_ACTOR` counts as unset, the convention `colors_wanted` follows for
/// `NO_COLOR`, so a wrapper script can clear an inherited one. `git_user` is a closure
/// rather than a value because the fallback costs a subprocess and the variable usually
/// answers first.
fn session_actor(env: Option<&str>, git_user: impl FnOnce() -> Option<String>) -> Option<String> {
match env.map(str::trim).filter(|value| !value.is_empty()) {
Some(value) => Some(value.to_string()),
None => git_user(),
}
}
/// The actor for one entry: the flag wins, otherwise the session's, otherwise unknown.
///
/// Free text, validated against nothing, the way the `chown` user is: there is no
/// registry of actors to check a name against.
fn entry_actor(flag: Option<&str>, session: Option<&str>) -> String {
[flag, session]
.into_iter()
.flatten()
.map(str::trim)
.find(|value| !value.is_empty())
.unwrap_or(UNKNOWN_ACTOR)
.to_string()
}
/// Who to attribute an entry to, from the flag the call carried.
///
/// Precedence: flag, then `WORKLANE_ACTOR`, then the git user, then `unknown`. Every
/// entry the CLI writes goes through here, so a board several agents write to says which
/// of them wrote what instead of attributing all of it to one human.
pub fn resolve_actor(flag: Option<&str>) -> String {
// The session half is decided once, the way should_use_colors is: neither input can
// change mid-run, and the git user costs a subprocess.
static SESSION: OnceLock<Option<String>> = OnceLock::new();
let session = SESSION.get_or_init(|| {
let env = std::env::var(ACTOR_ENV).ok();
session_actor(env.as_deref(), get_git_user)
});
entry_actor(flag, session.as_deref())
}
/// One file a search matched, and where it was found.
pub struct Found {
/// The name the match is reported under: the status directory for a ticket, and
@@ -656,9 +713,11 @@ pub struct Resolved {
/// Rows rather than the rendered block: the CLI paints them into escapes and the
/// board styles the same rows itself, since a paragraph is no place for an escape.
pub relations: Vec<RelationRow>,
/// The Campaign value as it reads, from [`reference_cell`]. Empty leaves the stored
/// The Campaign value as it reads, from [`campaign_cells`]. Empty leaves the stored
/// value to render as it sits, which is what a ticket in no campaign wants.
pub campaign: String,
///
/// [`campaign_cells`]: crate::campaign::campaign_cells
pub campaign: Vec<Cell>,
}
pub fn content_trim_colored(content: &str, resolved: &Resolved) -> String {
@@ -670,35 +729,32 @@ pub fn content_trim_colored(content: &str, resolved: &Resolved) -> String {
/// The rule is measured on the name as displayed, in characters. It used to span the
/// raw line, so it ran three past the heading for the `## `, and byte length over-drew
/// anything non-ASCII.
fn push_heading(out: &mut Body, heading: &str, colored: bool) {
fn push_heading(out: &mut Body, heading: &str) {
let name = heading.strip_prefix("## ").unwrap_or(heading);
out.push_str(&paint(name, Color::Orange, colored));
out.push_cell(Cell::colored(name, Color::Orange));
out.push('\n');
out.push_str(&"─".repeat(name.chars().count()));
out.push('\n');
out.push('\n');
}
/// The ticket body rendered for display, with the colour decision passed in.
/// One piece of the rendered body: a run of cells, or relations still as rows.
///
/// The TUI needs the plain form: ratatui draws styled spans, and an escape sequence
/// embedded in a paragraph would be printed as literal bytes.
/// The body is one string to the CLI and a run of styled lines to the board. Neither
/// half is rendered here: a [`Cell`] carries the text and the colour it is drawn in, and
/// the renderer decides what a colour is, an escape sequence for the CLI and a ratatui
/// style for the board. That is what makes the two views one layout rather than two
/// that have to be kept in step.
///
/// [`Resolved`] carries the parts that come from elsewhere on the board, since the
/// body alone cannot render them.
/// One piece of the rendered body: text as it prints, or relations still as rows.
///
/// The body is one string to the CLI and a run of styled lines to the board, and the
/// only part that differs is the relations block. Splitting the body here rather than
/// building it twice is what keeps the two views from drifting: everything outside the
/// block is rendered once, by [`content_parts`], and the rows are handed on unpainted.
/// The relations stay rows rather than becoming cells here because their layout needs
/// the whole block at once: the label column is padded to the widest label.
pub enum BodyPart {
Text(String),
Cells(Vec<Cell>),
Relations(Vec<RelationRow>),
}
/// The body under construction. Text accumulates into the trailing run, and a relations
/// The body under construction. Cells accumulate into the trailing run, and a relations
/// block closes it, so a caller pushes text and rows without tracking which it pushed
/// last.
#[derive(Default)]
@@ -707,17 +763,37 @@ struct Body {
}
impl Body {
/// A run in the default foreground.
fn push_str(&mut self, text: &str) {
match self.parts.last_mut() {
Some(BodyPart::Text(run)) => run.push_str(text),
_ => self.parts.push(BodyPart::Text(text.to_string())),
}
self.push_cell(Cell::plain(text));
}
fn push(&mut self, c: char) {
self.push_cell(Cell::plain(c.to_string()));
}
/// One run, merged into the trailing cell when it is the same colour.
///
/// Merging is not an optimisation. The board draws a span per cell, and the body is
/// pushed a character at a time in places, so without this a plain line arrives as
/// forty single-character spans for ratatui to wrap.
fn push_cell(&mut self, cell: Cell) {
if cell.text.is_empty() {
return;
}
match self.parts.last_mut() {
Some(BodyPart::Text(run)) => run.push(c),
_ => self.parts.push(BodyPart::Text(c.to_string())),
Some(BodyPart::Cells(cells)) => match cells.last_mut() {
Some(last) if last.color == cell.color => last.text.push_str(&cell.text),
_ => cells.push(cell),
},
_ => self.parts.push(BodyPart::Cells(vec![cell])),
}
}
fn push_cells(&mut self, cells: Vec<Cell>) {
for cell in cells {
self.push_cell(cell);
}
}
@@ -727,26 +803,42 @@ impl Body {
/// Whether the text written so far ends with `suffix`. A relations block never does,
/// since it is not text yet.
///
/// Over the whole trailing run rather than its last cell: a colour change starts a
/// new cell, and the question here is what the body reads like, not how it is split.
fn ends_with(&self, suffix: &str) -> bool {
match self.parts.last() {
Some(BodyPart::Text(run)) => run.ends_with(suffix),
Some(BodyPart::Cells(cells)) => {
let run: String = cells.iter().map(|cell| cell.text.as_str()).collect();
run.ends_with(suffix)
}
_ => false,
}
}
}
/// The ticket body as the CLI prints it.
///
/// [`Resolved`] carries the parts that come from elsewhere on the board, since the
/// body alone cannot render them.
pub fn content_trim(content: &str, colored: bool, resolved: &Resolved) -> String {
content_parts(content, colored, resolved)
.iter()
.map(|part| match part {
BodyPart::Text(text) => text.clone(),
BodyPart::Cells(cells) => paint_cells(cells, colored),
BodyPart::Relations(rows) => render_relations(rows, colored),
})
.collect()
}
/// The body rendered into its parts, with the colour decision already applied to the
/// text and deliberately not to the relations.
/// The body laid out as cells, for a renderer to colour as it colours anything.
///
/// `colored` no longer paints anything here, and it is not the CLI's flag: it says
/// whether *this* renderer can carry a colour at all, which is the one question the
/// layout still turns on. `**bold**` and `[text](url)` give their markers up to a
/// colour, so a renderer with no colour has to keep them, or the emphasis is lost
/// rather than moved. The board passes `true`, since it styles spans; `content_trim`
/// passes the CLI's decision, so a piped `show` still reads its markers.
pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<BodyPart> {
let relations = resolved.relations.as_slice();
let lines: Vec<&str> = content.trim().lines().collect();
@@ -772,24 +864,20 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
// file would have kept it, ahead of the metadata, rather than tacked on
// after everything.
if is_metadata_heading(line) && !stores_relations && !relations.is_empty() {
push_heading(&mut result, RELATIONS.heading, colored);
push_heading(&mut result, RELATIONS.heading);
result.push_relations(relations);
result.push('\n');
shown_relations = true;
}
push_heading(&mut result, section_name, colored);
push_heading(&mut result, section_name);
i += 1;
// Metadata is rendered as a block, so it is consumed here rather than
// falling through to the line-at-a-time cases below.
if is_metadata_heading(line) {
let end = section_end(&lines, i);
result.push_str(&render_metadata_table(
&lines[i..end],
colored,
&resolved.campaign,
));
result.push_cells(metadata_cells(&lines[i..end], colored, &resolved.campaign));
i = end;
}
@@ -825,7 +913,7 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
// Implementation Plan - color numbers in cyan
if current_section == "## Implementation Plan" {
result.push_str(&colorize_ordered(line, colored));
result.push_cells(ordered_cells(line));
result.push('\n');
continue;
}
@@ -837,17 +925,17 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
&& let Some((checked, text)) = checkbox(line)
{
criterion += 1;
result.push_str(&paint(&format!("{}.", criterion), Color::Cyan, colored));
result.push_cell(Cell::colored(format!("{}.", criterion), Color::Cyan));
result.push(' ');
result.push_str(&paint(if checked { "[x]" } else { "[ ]" }, Color::Grey, colored));
result.push_cell(Cell::colored(if checked { "[x]" } else { "[ ]" }, Color::Grey));
result.push(' ');
result.push_str(&colorize_inline(text, colored));
result.push_cells(inline_cells(text, colored));
result.push('\n');
continue;
}
// Regular content, with its inline markup coloured in place.
result.push_str(&colorize_inline(line, colored));
// Regular content, with its inline markup carried as cells of its own.
result.push_cells(inline_cells(line, colored));
result.push('\n');
}
@@ -857,42 +945,42 @@ pub fn content_parts(content: &str, colored: bool, resolved: &Resolved) -> Vec<B
if !result.ends_with("\n\n") {
result.push('\n');
}
push_heading(&mut result, RELATIONS.heading, colored);
push_heading(&mut result, RELATIONS.heading);
result.push_relations(relations);
}
result.parts
}
/// Colour the `1.` at the head of a numbered line, leaving the rest alone.
/// The `1.` at the head of a numbered line as a cell of its own, the rest as it stands.
///
/// Takes the decision rather than asking for it. Asking is what put `\x1b[36m` and
/// `\x1b[0m` around every Implementation Plan number in the board's detail view,
/// which renders with colour off precisely because a paragraph is not a place an
/// escape sequence can go.
fn colorize_ordered(line: &str, colored: bool) -> String {
/// No colour flag. The cell says cyan and the renderer decides what cyan is, which is
/// what stopped this asking `should_use_colors()` and putting `\x1b[36m` around every
/// Implementation Plan number in the board's detail view.
fn ordered_cells(line: &str) -> Vec<Cell> {
if line.chars().next().is_none_or(|c| !c.is_ascii_digit()) {
return line.to_string();
return vec![Cell::plain(line)];
}
// Match "1. " pattern and color the number in cyan
let mut result = String::new();
// Match "1. " pattern and colour the number in cyan
let chars: Vec<char> = line.chars().collect();
for (i, c) in chars.iter().enumerate() {
if c.is_ascii_digit() {
// still scanning digits
} else if *c == '.' && i + 1 < chars.len() && chars[i + 1] == ' ' {
let number = &line[..i + 1];
result.push_str(&paint(number, Color::Cyan, colored));
result.push_str(&line[i + 1..]);
return result;
// Byte indexing on a char index, which holds because everything walked to
// get here is an ASCII digit or the dot itself.
return vec![
Cell::colored(&line[..i + 1], Color::Cyan),
Cell::plain(&line[i + 1..]),
];
} else {
break;
}
}
line.to_string()
vec![Cell::plain(line)]
}
/// Space between a label column and the value beside it, in the metadata table and in
@@ -930,33 +1018,36 @@ fn metadata_row(line: &str) -> MetadataRow<'_> {
/// `campaign` is the resolved cell for the Campaign field, empty when there is none.
/// The file stores the full uuid, per the rule the Relations section already follows,
/// so a bare value here would be thirty-six characters saying nothing.
fn metadata_value_cell(name: &str, value: &str, colored: bool, campaign: &str) -> String {
fn metadata_value_cells(name: &str, value: &str, campaign: &[Cell]) -> Vec<Cell> {
if name == CAMPAIGN_FIELD && !campaign.is_empty() {
return campaign.to_string();
return campaign.to_vec();
}
if name == "Priority" {
// Reads as a glyph, while the file keeps storing the number.
let (glyph, colour) = priority_mark(priority_from_value(value));
return format!("{} {}", paint(glyph, colour, colored), value);
return vec![
Cell::colored(glyph, colour),
Cell::plain(format!(" {}", value)),
];
}
if is_unknown_value(value) {
return paint(value, Color::Grey, colored);
return vec![Cell::colored(value, Color::Grey)];
}
// The same word in the same colour as the label a card draws, since `tag_color` is a
// pure function of it. No mark here: the field name has already said what this is,
// and the mark is what tells a campaign from a tag on a row that holds both.
if name == CODENAME_FIELD {
return paint(value, tag_color(value), colored);
return vec![Cell::colored(value, tag_color(value))];
}
if name == "Tags" {
return paint_tags(value, colored);
return tag_cells(value);
}
value.to_string()
vec![Cell::plain(value)]
}
/// The stored tag list with each tag in its own colour.
@@ -965,25 +1056,28 @@ fn metadata_value_cell(name: &str, value: &str, colored: bool, campaign: &str) -
/// holds come back unchanged. `bug, cli` and `bug,cli` are both written by hand at some
/// point, and a cell that normalised them would be the display quietly disagreeing with
/// the file it is showing.
fn paint_tags(value: &str, colored: bool) -> String {
value
.split(',')
.map(|piece| {
let tag = piece.trim();
if tag.is_empty() {
return piece.to_string();
}
fn tag_cells(value: &str) -> Vec<Cell> {
let mut cells = Vec::new();
let lead = piece.len() - piece.trim_start().len();
format!(
"{}{}{}",
&piece[..lead],
paint(tag, tag_color(tag), colored),
&piece[lead + tag.len()..]
)
})
.collect::<Vec<_>>()
.join(",")
for (index, piece) in value.split(',').enumerate() {
if index > 0 {
cells.push(Cell::plain(","));
}
let tag = piece.trim();
if tag.is_empty() {
cells.push(Cell::plain(piece));
continue;
}
let lead = piece.len() - piece.trim_start().len();
cells.push(Cell::plain(&piece[..lead]));
cells.push(Cell::colored(tag, tag_color(tag)));
cells.push(Cell::plain(&piece[lead + tag.len()..]));
}
cells.retain(|cell| !cell.text.is_empty());
cells
}
/// Render the Metadata section as two aligned columns.
@@ -991,7 +1085,7 @@ fn paint_tags(value: &str, colored: bool) -> String {
/// Taken as a block rather than a line at a time because the field column cannot be
/// sized until every name has been seen. The file is untouched by this: it goes on
/// storing the markdown list, and this is only how the list is shown.
fn render_metadata_table(lines: &[&str], colored: bool, campaign: &str) -> String {
fn metadata_cells(lines: &[&str], colored: bool, campaign: &[Cell]) -> Vec<Cell> {
// The heading already emits its own blank separator, so the one the template
// puts under it would otherwise open the section with a gap.
let start = lines
@@ -1012,21 +1106,23 @@ fn render_metadata_table(lines: &[&str], colored: bool, campaign: &str) -> Strin
.max()
.unwrap_or(0);
let mut result = String::new();
let mut result = Vec::new();
for row in &rows {
match row {
MetadataRow::Field { name, value } => {
result.push_str(&paint(name, Color::Red, colored));
result.push_str(&" ".repeat(field_width - name.chars().count()));
result.push_str(COLUMN_GUTTER);
result.push_str(&metadata_value_cell(name, value, colored, campaign));
result.push(Cell::colored(*name, Color::Red));
result.push(Cell::plain(format!(
"{}{}",
" ".repeat(field_width - name.chars().count()),
COLUMN_GUTTER
)));
result.extend(metadata_value_cells(name, value, campaign));
}
// The decision this row is rendered under, not the one the terminal
// would give: `colorize_line` asked `should_use_colors()` here, which is
// how escapes reached the board's detail view.
MetadataRow::Other(text) => result.push_str(&colorize_inline(text, colored)),
// `colored` reaches only this row, and only for the markers: a hand-written
// line is the one thing in the section that can carry inline markup.
MetadataRow::Other(text) => result.extend(inline_cells(text, colored)),
}
result.push('\n');
result.push(Cell::plain("\n"));
}
result
@@ -1059,26 +1155,27 @@ pub fn is_unknown_value(value: &str) -> bool {
trimmed == NONE || trimmed == NOT_SET
}
/// Replace `**bold**` with colour and paint `[text](url)`, or leave the line exactly
/// as it is.
/// `**bold**` and `[text](url)` split into their own cells, or the line as one cell.
///
/// Taking `enabled` rather than asking makes both paths testable, and the
/// disabled path matters: stripping the markers when there is no colour to
/// replace them with loses the emphasis altogether, which is what happens to
/// every piped `show` and to everything the opencode tools read.
/// `enabled` is the only place in the body where the renderer's colour still changes
/// the layout, and it is why [`content_parts`] still takes the flag. The bold pair
/// gives its markers up to the colour that replaces them, so a renderer with none has
/// to keep them: stripping them there loses the emphasis rather than moving it, which
/// is what a piped `show` and everything the opencode tools read would get.
///
/// One walk for both markers rather than two passes. A pass over the output of
/// another would be scanning text that already holds escape sequences, and `\x1b[36m`
/// carries an opening bracket: a link scan run afterwards would take the escape for
/// markup. Walking the source once is the only place either marker can be recognised
/// for what it is.
fn colorize_inline(line: &str, enabled: bool) -> String {
fn inline_cells(line: &str, enabled: bool) -> Vec<Cell> {
if !enabled {
return line.to_string();
return vec![Cell::plain(line)];
}
let chars: Vec<char> = line.chars().collect();
let mut result = String::new();
let mut cells: Vec<Cell> = Vec::new();
let mut plain = String::new();
let mut i = 0;
while i < chars.len() {
@@ -1088,10 +1185,11 @@ fn colorize_inline(line: &str, enabled: bool) -> String {
if is_delimiter(&chars, i)
&& let Some(close) = (i + 2..chars.len()).find(|&at| is_delimiter(&chars, at))
{
let bold: String = chars[i + 2..close].iter().collect();
// `enabled`, not `should_use_colors()`. Asking again here made the
// flag a lie: the early return above respected it and this did not.
result.push_str(&paint(&bold, Color::Magenta, enabled));
flush(&mut cells, &mut plain);
cells.push(Cell::colored(
chars[i + 2..close].iter().collect::<String>(),
Color::Magenta,
));
i = close + 2;
continue;
}
@@ -1102,17 +1200,26 @@ fn colorize_inline(line: &str, enabled: bool) -> String {
// Markers and url kept, unlike the bold pair. The url is content: a
// reader of `show` wants to see where the link goes, and the terminal
// that would make it clickable is not something worklane can count on.
let link: String = chars[i..end].iter().collect();
result.push_str(&paint(&link, Color::Cyan, enabled));
flush(&mut cells, &mut plain);
cells.push(Cell::colored(chars[i..end].iter().collect::<String>(), Color::Cyan));
i = end;
continue;
}
result.push(chars[i]);
plain.push(chars[i]);
i += 1;
}
result
flush(&mut cells, &mut plain);
cells
}
/// The plain run built so far, closed off ahead of a coloured one. An empty run pushes
/// nothing, so a line opening on a marker does not start with an empty cell.
fn flush(cells: &mut Vec<Cell>, plain: &mut String) {
if !plain.is_empty() {
cells.push(Cell::plain(std::mem::take(plain)));
}
}
fn is_delimiter(chars: &[char], at: usize) -> bool {
@@ -2163,21 +2270,16 @@ impl RelationIndex {
}
}
/// A cross reference as it reads: the short id, then the name it points at.
/// A cross reference in cells: the short id, then the name it points at.
///
/// `_missing_` rather than a bare uuid for something the board no longer holds. The id
/// is kept either way, since it is the only thing left to go looking for. Shared by the
/// relations block and the Campaign field, so a dangling reference is spelled one way
/// wherever it is shown.
pub fn reference_cell(uuid: &str, name: Option<&str>, colored: bool) -> String {
paint_cells(&reference_cells(uuid, name), colored)
}
/// The same cross reference in cells, for a renderer that is not writing escapes.
/// is kept either way, since it is the only thing left to go looking for.
///
/// The one spelling of a reference, so the relations block and the Campaign field cannot
/// come to say a dangling one differently, and the board draws the id in the colour the
/// guideline gives it rather than dropping every colour to stay safe.
/// come to say a dangling one differently, and every renderer draws the id in the colour
/// the guideline gives it rather than dropping every colour to stay safe. There was a
/// `reference_cell` beside this that painted the cells for the CLI; the Campaign field
/// was its last caller, and it now takes the cells like everything else.
pub fn reference_cells(uuid: &str, name: Option<&str>) -> Vec<Cell> {
let mut cells = vec![
Cell::plain("("),
@@ -2322,7 +2424,7 @@ pub struct Cell {
}
impl Cell {
fn plain(text: impl Into<String>) -> Self {
pub fn plain(text: impl Into<String>) -> Self {
Cell { text: text.into(), color: None }
}
@@ -3217,6 +3319,37 @@ impl Drop for Fixture {
#[cfg(test)]
mod tests {
/// One line's inline markup as a string, the shape these tests were written
/// against. `enabled` is both the marker decision and, here, the painting one,
/// which is what it was before the cells conversion split the two.
fn colorize_inline(line: &str, enabled: bool) -> String {
paint_cells(&inline_cells(line, enabled), enabled)
}
/// One metadata value as a string, the shape these tests were written against.
fn metadata_value_cell(name: &str, value: &str, colored: bool, campaign: &str) -> String {
let campaign = match campaign.is_empty() {
true => Vec::new(),
false => vec![Cell::plain(campaign)],
};
paint_cells(&metadata_value_cells(name, value, &campaign), colored)
}
/// The metadata section as a string, the shape these tests were written against.
///
/// `metadata_cells` returns cells now, one layout for both renderers, so the CLI's
/// form is `paint_cells` over them. The campaign cell is a `&str` here because that
/// is all any of these needs: one run, already resolved.
fn render_metadata_table(lines: &[&str], colored: bool, campaign: &str) -> String {
let campaign = match campaign.is_empty() {
true => Vec::new(),
false => vec![Cell::plain(campaign)],
};
paint_cells(&metadata_cells(lines, colored, &campaign), colored)
}
use super::*;
/// The guard removes the directory when it goes out of scope, which is what makes the
@@ -3301,6 +3434,54 @@ mod tests {
assert!(colors_wanted(true, None, None));
}
/// The variable answers when no flag does, and the git user is never asked: the
/// closure returns a name that must not appear.
#[test]
fn the_variable_names_the_actor() {
let session = session_actor(Some("claude"), || Some("Ansho Rei".to_string()));
assert_eq!(entry_actor(None, session.as_deref()), "claude");
}
#[test]
fn the_flag_overrides_the_variable() {
let session = session_actor(Some("claude"), || None);
assert_eq!(entry_actor(Some("opencode"), session.as_deref()), "opencode");
}
/// With neither supplied the author is still the git user.
#[test]
fn the_git_user_is_the_fallback() {
let session = session_actor(None, || Some("Ansho Rei".to_string()));
assert_eq!(entry_actor(None, session.as_deref()), "Ansho Rei");
}
/// An empty variable counts as unset, the way `NO_COLOR` does, so a wrapper script
/// can clear an inherited one and get the git user back.
#[test]
fn an_empty_variable_reads_as_unset() {
let session = session_actor(Some(""), || Some("Ansho Rei".to_string()));
assert_eq!(entry_actor(None, session.as_deref()), "Ansho Rei");
// Whitespace is the same case: a shell that quotes a missing value writes one
let session = session_actor(Some(" "), || Some("Ansho Rei".to_string()));
assert_eq!(entry_actor(None, session.as_deref()), "Ansho Rei");
}
/// And with nothing at all, including a git that has no user configured.
#[test]
fn nothing_at_all_is_unknown() {
let session = session_actor(None, || None);
assert_eq!(entry_actor(None, session.as_deref()), UNKNOWN_ACTOR);
// An empty flag falls through rather than writing a blank author
assert_eq!(entry_actor(Some(""), None), UNKNOWN_ACTOR);
}
/// Free text, validated against nothing, the way the `chown` user is.
#[test]
fn an_actor_is_free_text() {
let session = session_actor(Some("claude-code, session 3 (opus)"), || None);
assert_eq!(entry_actor(None, session.as_deref()), "claude-code, session 3 (opus)");
}
#[test]
fn unset_values_are_dimmed_and_set_ones_are_not() {
// Both paths, now that the colour decision is a parameter: with colour off the
@@ -4233,6 +4414,111 @@ mod tests {
assert_eq!(rendered, "Metadata\n────────\n\nID abc\nOwner alice\n");
}
/// A body holding one of everything the renderer paints, pinned byte for byte.
///
/// The guard for extending `Cell` to the whole body, e4d0bb7: the board and the CLI
/// now share one layout, and the risk in that is the CLI's output moving to suit the
/// board. Written from what `show` printed before the conversion, so a difference is
/// a regression rather than a rewrite. Every run the guideline gives a colour is in
/// here: heading, plan number, criterion number and mark, bold, link, field name,
/// priority glyph, tag, unset value, and a hand-written line the table carries
/// through.
const EVERY_PAINTED_RUN: &str = "\
# The Title
## Description
Plain line with **bold** and a [link](http://x.test/a).
## Acceptance Criteria
- [x] First, with **bold**
- [ ] Second
## Implementation Plan
1. Step one
2. Step two
## Metadata
- **ID**: 641e3d5a-0000-0000-0000-000000000000
- **Priority**: 2
- **Tags**: bug, cli
- **Due**: _Not set_
- **Owner**: alice
- A hand-written note with **bold**
- **Status**: backlog
";
#[test]
fn show_prints_the_same_body_it_printed_before_the_cells_conversion() {
let orange = |text: &str| paint(text, Color::Orange, true);
let cyan = |text: &str| paint(text, Color::Cyan, true);
let red = |text: &str| paint(text, Color::Red, true);
let bold = |text: &str| paint(text, Color::Magenta, true);
let grey = |text: &str| paint(text, Color::Grey, true);
let expected = format!(
"{}\n───────────\n\n\nPlain line with {} and a {}.\n\n\
{}\n───────────────────\n\n\n\
{} {} First, with {}\n{} {} Second\n\n\
{}\n───────────────────\n\n\n{} Step one\n{} Step two\n\n\
{}\n────────\n\n\
{} 641e3d5a-0000-0000-0000-000000000000\n\
{} {} 2\n\
{} {}, {}\n\
{} {}\n\
{} alice\n\
- A hand-written note with {}\n\
{} backlog\n",
orange("Description"),
bold("bold"),
cyan("[link](http://x.test/a)"),
orange("Acceptance Criteria"),
cyan("1."),
grey("[x]"),
bold("bold"),
cyan("2."),
grey("[ ]"),
orange("Implementation Plan"),
cyan("1."),
cyan("2."),
orange("Metadata"),
red("ID"),
red("Priority"),
paint("●◐", Color::Red, true),
red("Tags"),
paint("bug", tag_color("bug"), true),
paint("cli", tag_color("cli"), true),
red("Due"),
grey(NOT_SET),
red("Owner"),
bold("bold"),
red("Status"),
);
assert_eq!(content_trim(EVERY_PAINTED_RUN, true, &Resolved::default()), expected);
}
/// The other half of the pin: with colour off the same body carries no escape byte
/// at all. Asserted beside the coloured form so neither can pass vacuously, the rule
/// 6d327df's guard was written under.
#[test]
fn the_same_body_with_colour_off_carries_no_escape() {
let plain = content_trim(EVERY_PAINTED_RUN, false, &Resolved::default());
assert!(!plain.contains('\x1b'), "{plain:?}");
// The markers stay, since with no colour to carry the emphasis they are the
// emphasis. That is `colorize_inline`'s disabled path, not a gap in the pin.
assert!(
plain.contains("Plain line with **bold** and a [link](http://x.test/a)."),
"{plain:?}"
);
assert!(plain.contains("1. [x] First, with **bold**"), "{plain:?}");
assert!(plain.contains("Priority ●◐ 2"), "{plain:?}");
}
#[test]
fn a_section_after_metadata_still_renders() {
let content = "# T\n\n## Metadata\n\n- **ID**: abc\n\n## Notes\n\nafter\n";
+132 -12
View File
@@ -41,6 +41,24 @@ fn create_ticket(worklane_dir: &Path, status: &str, title: &str) -> String {
uuid
}
/// The one comment on a ticket, which every author test writes exactly one of.
fn only_comment(worklane_dir: &Path, uuid: &str) -> String {
let files: Vec<_> = fs::read_dir(worklane_dir.join("comments").join(uuid))
.unwrap()
.filter_map(|e| e.ok())
.collect();
assert_eq!(files.len(), 1, "expected one comment");
fs::read_to_string(files[0].path()).unwrap()
}
/// A git config file holding nothing but a `user.name`, for the tests that need the
/// fallback to answer something known instead of whatever the machine is configured with.
fn git_config_naming(temp: &TempDir, name: &str) -> PathBuf {
let path = temp.path().join("gitconfig");
fs::write(&path, format!("[user]\n\tname = {}\n", name)).unwrap();
path
}
#[test]
fn comment_creates_file_with_valid_ticket_uuid() {
let temp = TempDir::new().unwrap();
@@ -162,32 +180,134 @@ fn comment_creates_comments_directory() {
}
#[test]
fn comment_uses_owner_flag_when_provided() {
fn comment_uses_actor_flag_when_provided() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let uuid = create_ticket(&worklane, "backlog", "Owner Test");
let uuid = create_ticket(&worklane, "backlog", "Actor Test");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.arg("comment")
.args([&uuid, "Test comment with owner"])
.arg("-o")
.arg("TestUser")
.args([&uuid, "Test comment with actor"])
.args(["--actor", "TestUser"])
.assert()
.success();
let comments_dir = worklane.join("comments").join(&uuid);
let files: Vec<_> = fs::read_dir(&comments_dir)
assert!(only_comment(&worklane, &uuid).contains("**Author**: TestUser"));
}
/// The flag it was, which named the ticket's assignee and not the writer of the entry.
/// Renamed without an alias, so the old spelling is a usage error rather than something
/// that half works.
#[test]
fn the_owner_flag_is_gone() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let uuid = create_ticket(&worklane, "backlog", "Gone Test");
for flag in ["--owner", "-o"] {
Command::cargo_bin(BIN_NAME)
.unwrap()
.current_dir(temp.path())
.arg("comment")
.args([&uuid, "A body"])
.args([flag, "TestUser"])
.assert()
.failure();
}
assert!(
!worklane.join("comments").join(&uuid).exists(),
"a comment was written despite the usage error"
);
}
/// The variable is the case an agent runs in: set once by its configuration and
/// inherited by every call, where a flag can be forgotten on the fortieth one.
#[test]
fn comment_takes_the_author_from_the_actor_variable() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let uuid = create_ticket(&worklane, "backlog", "Variable Test");
Command::cargo_bin(BIN_NAME)
.unwrap()
.filter_map(|e| e.ok())
.collect();
let content = fs::read_to_string(files[0].path()).unwrap();
assert!(content.contains("**Author**: TestUser"));
.current_dir(temp.path())
.env("WORKLANE_ACTOR", "claude")
.arg("comment")
.args([&uuid, "Written by an agent"])
.assert()
.success();
assert!(only_comment(&worklane, &uuid).contains("**Author**: claude"));
}
#[test]
fn comment_falls_back_to_git_user_when_owner_omitted() {
fn the_actor_flag_overrides_the_variable() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let uuid = create_ticket(&worklane, "backlog", "Override Test");
Command::cargo_bin(BIN_NAME)
.unwrap()
.current_dir(temp.path())
.env("WORKLANE_ACTOR", "claude")
.arg("comment")
.args([&uuid, "Written by the other one"])
.args(["--actor", "opencode"])
.assert()
.success();
assert!(only_comment(&worklane, &uuid).contains("**Author**: opencode"));
}
/// An empty variable counts as unset, the convention `NO_COLOR` follows, so a wrapper
/// script can clear an inherited one and get the git user back.
#[test]
fn an_empty_actor_variable_falls_through_to_the_git_user() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let uuid = create_ticket(&worklane, "backlog", "Empty Variable Test");
Command::cargo_bin(BIN_NAME)
.unwrap()
.current_dir(temp.path())
.env("WORKLANE_ACTOR", "")
.env("GIT_CONFIG_GLOBAL", git_config_naming(&temp, "Configured User"))
.env("GIT_CONFIG_NOSYSTEM", "1")
.arg("comment")
.args([&uuid, "Written by a person"])
.assert()
.success();
assert!(only_comment(&worklane, &uuid).contains("**Author**: Configured User"));
}
/// The last resort. Reached with a git that has no `user.name`, which is why the config
/// files are redirected: the machine running the suite has one.
#[test]
fn the_author_is_unknown_when_nothing_names_one() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let uuid = create_ticket(&worklane, "backlog", "Unknown Test");
Command::cargo_bin(BIN_NAME)
.unwrap()
.current_dir(temp.path())
.env_remove("WORKLANE_ACTOR")
.env("GIT_CONFIG_GLOBAL", temp.path().join("no-such-gitconfig"))
.env("GIT_CONFIG_NOSYSTEM", "1")
.arg("comment")
.args([&uuid, "Written by nobody in particular"])
.assert()
.success();
assert!(only_comment(&worklane, &uuid).contains("**Author**: unknown"));
}
#[test]
fn comment_falls_back_to_git_user_when_actor_omitted() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);