Compare commits

...
3 Commits
Author SHA1 Message Date
Ansho ReiandClaude Opus 5 5b0bac9c2d (7bfb9fc) Add campaigns, a ticket container assigned through worklane assign, and bump to 0.12.0
There was no way to group the tickets that have to be finished together. A
goal such as a v1 release was either one ticket that could not describe its
parts, or a set of tickets with the goal restated in every description and
nothing tying them together.

A campaign is a file of its own under `.worklane/campaigns/`, with a title, a
description and metadata, and it sits in no status directory. Its state is
derived instead: open until every member is done. Deriving it means there is
no such thing as a done campaign holding an open ticket, and no second
forward-only ruleset beside `mv`'s. An empty campaign is neither open nor
done, since calling it done would make a container nothing has been filed
against the most complete thing on the board.

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 make one file that every
assignment edits, contended the moment two agents share a board. So `add`
gains no `--campaign` and neither does `set`.

`add` does not write the field either. Every ticket written before campaigns
existed has none, so the insertion path has to exist regardless, and leaving
it out of `add` means one path that is always exercised rather than two. That
is the Relations argument from 4179958, applied to a field instead of a
section. `set_or_insert_metadata_field` is the upsert and `METADATA_ORDER` is
its anchor list, the way `SECTION_ORDER` is `ensure_section`'s, so Campaign
lands beside Status rather than at the end and Status stays last. A file with
no Metadata heading is an error rather than an insertion, per 641e3d5.

The three tiers came out of `resolve_ticket` into `resolve_in`, shared by both
kinds. 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. Two
things fell out of that. `Found.dir` is the status for a ticket and empty for
a campaign, which is what drops the bracket from the ambiguity listing for
one. And `resolve_ticket` can now explain a search that names a campaign, so
`mv`, `show`, `chown` and everything else that takes a ticket give the same
reason instead of a bare "no ticket found" — one place rather than a check per
command. Only on the zero-match path, so an ambiguous ticket error is never
replaced by a complaint about a directory the caller never mentioned.

The stored value is the full uuid, per the same rule the Relations section
follows, and the title is resolved for display. `reference_cell` is now shared
between the two, so a dangling campaign and a dangling relation target are
both `_missing_` rather than each inventing a spelling. `Resolved` carries
what `content_trim` cannot render from the file alone: a struct rather than
two more parameters, so the next such field is one entry instead of an edit at
every call site.

`campaign show` lists done members, unlike `ls`, which leaves the done column
out of its listing. What is finished against what is left is the whole
question a campaign asks. `ls --campaign` is the other way round and keeps
every rule `ls` already has.

Deliberately out of scope. The derived progress figure is 1cb999f, now
recorded as blocked by this, since nothing here can compute it yet.
Unassigning needs a field cleared back to unset, which is 74904dc. And the
board gets neither a campaign tab nor a card marker: the detail view resolves
the field because it renders the body, and that is all. A marker would want a
read per reload and the four corners are already spent, which is the b8ce18c
reasoning; filed as 61879a4.

Twenty-four integration tests and eleven unit tests, covering assign,
reassign, the no-op, a dangling campaign, the ls filter, `mv` refusing a
campaign, insertion placement, and a handwritten section and unknown metadata
field surviving an assignment verbatim.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-22 00:52:57 +02:00
Ansho ReiandClaude Opus 5 41a65f95b2 (2ec6508) Filter status directories to md files in ls, and bump to 0.11.1
A status directory is a plain directory, so anything can land in it.
`collect_ticket_items` read every entry it could, so a stray `notes.txt`
was listed as `(notes) _No title_` and counted in the per-status summary
beside the real tickets.

The extension check is the one every other scan of a status directory
already makes: `resolve_ticket`, `RelationIndex::load`, `find_ticket_file`
and the tui's `digest` all skip a non-md path. This was the only reader
without it, so the fix is to join them rather than to invent a rule.

Subdirectories were already excluded, but by accident: `read_to_string`
fails on a directory and `filter_map` dropped it. The filter now refuses
them on the extension, and the test keeps a subdirectory in place so a
later change to how the file is read cannot bring them back.

The count needed nothing. It comes from `collect_ticket_items().len()`
since the priority filter was added, so filtering the source fixed both
the rows and the number in one place.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-22 00:20:16 +02:00
Ansho ReiandClaude Opus 5 3085b0226f (4179958) Add a Relations section for blocked by, regression of and relates to, and bump to 0.11.0
`relate` is the only writer of the section, the way `chown` is the only writer of
Owner: a relation names a target that has to be resolved to a uuid first, so `set`
and `append` are deliberately kept out of it. One flag per kind, so an unknown kind
is a usage error rather than a line refused on the way back out.

One direction is stored and the inverse is derived by a scan. `blocked by` goes on
the gated ticket, whose move `mv` now refuses while the target is not done, naming
every open blocker; `-f` bypasses it beside the backward and skipping moves. A
target that is not on the board warns and allows the move.

The rendered block is built outside `content_trim` and passed in, since half of it
comes from other tickets. The section is created on demand rather than by `add`, so
a ticket written before it existed gains it without being regenerated.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-21 22:33:12 +02:00
14 changed files with 3253 additions and 103 deletions
+34 -2
View File
@@ -5,17 +5,19 @@
- `src/command.rs` - CLI argument definitions using clap derive
- `src/handlers.rs` - one `cmd_*` per subcommand
- `src/util.rs` - the ticket format, resolution, rendering and the palette
- `src/campaign.rs` - the campaign file format, its resolution, its index and its members
- `src/tui.rs` - board state, the change digest, and the ratatui draw
- `src/install.rs` - the embedded agent assets and the compare-and-refuse install
- `assets/SKILL.md` - the agent skill `install-skill` ships, embedded with `include_str!`
- `tests/` - Integration tests using `assert_cmd` and `assert_fs`, one file per command
- Unit tests live beside the code in `#[cfg(test)] mod tests`, in `util.rs`, `handlers.rs` and `tui.rs`
- Ticket files stored as `.md` in `.worklane/<status>/` directories
- Campaign files stored as `.md` in `.worklane/campaigns/`, which is beside the status directories and deliberately not in `status_dirs()`
## Ticket File Format
- Filenames: `<uuid_v4>_<slug>.md`
- The slug is the title through `slug()`: lowercased, alphanumerics plus `-` and `_` kept, spaces turned into dashes. `Ticket 06` lands as `<uuid>_ticket-06.md`. Derive fixture filenames through `slug()`, never by hand
- Metadata fields parsed by `parse_ticket_field()`: `ID`, `Priority`, `Tags`, `Due`, `Owner`, `Created At`, `Status`
- Metadata fields parsed by `parse_ticket_field()`: `ID`, `Priority`, `Tags`, `Due`, `Owner`, `Created At`, `Campaign`, `Status`. `Campaign` is the one no ticket is born with: `add` does not write it, so it is inserted on demand
- Format: `**Field Name**: value`
- Ticket structure: `# Title` → `## Description` → `## Acceptance Criteria` → `## Implementation Plan` → `## Metadata`
- Comments stored in `.worklane/comments/<ticket_uuid>/<timestamp>.md` with `**Comment**`, `**Author**`, `**Time**` fields
@@ -32,7 +34,7 @@ and this file is for what someone changing worklane's own code needs.
## Testing
- Run: `cargo test`
- Tests use `assert_cmd` and `assert_fs` for CLI testing
- `setup_worklane()` creates temp `.worklane/` with all four status folders pre-created
- `setup_worklane()` creates temp `.worklane/` with all four 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
- `create_ticket()` writes fully-formed markdown files directly (no `--` separator for positional args in test commands)
- **`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
@@ -79,6 +81,36 @@ and this file is for what someone changing worklane's own code needs.
- With the criterion omitted: prompt when stdin is a terminal, otherwise return the numbered list as an error. Never prompt unconditionally, the opencode wrapper has no tty and would block on a stdin that never closes. This is the same choice `resolve_ticket` makes for an ambiguous match, and for the same reason
- `show` numbers the criteria as `1. [x] text`, so the index is visible where the ticket is read. The number replaces the list marker rather than joining it
### Relating Tickets
- **The Relations section is `relate`'s alone.** `RELATIONS` is in the section table but deliberately out of `section_args`, so `set` and `append` cannot reach it: a relation names a target that has to be resolved to a uuid first, and a prose flag would let an unresolvable line into the one section that is read back by machine. Same rule as Owner and Status, one field one writer
- **`add` does not write the section.** The plan on 4179958 asked for it in the ticket writer; it is out on purpose. A `_No relations._` block in every new ticket is noise in every `show`, and the insertion path has to exist regardless for every ticket written before the section did, so leaving it out means one path that is always exercised rather than two
- **The full uuid is stored, not the seven characters `ls` prints.** It resolves without a scan and cannot turn ambiguous as the board grows. `show` renders the short id and the target's title instead: the file is the machine's copy, the output is the reader's
- **One direction is stored and the inverse is derived.** `blocked by` goes on the gated ticket rather than `blocks` on the blocker, because the gated ticket is the one whose move is refused and whose author knows about the dependency. `relates to` is symmetric and is written once, on whichever end the caller ran it from. `RelationIndex::inbound` finds the far end by scanning, which is what keeps `relate` a single-file write
- **A line in the section that is not a relation is an error naming the ticket**, not a line quietly dropped. Nothing but `relate` writes there, so a bad line means a hand-edited file. The TUI is the deliberate exception: `detail_of` falls back to no block, since one corrupt ticket must not take the whole board down
- **The block is built outside `content_trim` and passed in.** Half of it comes from other tickets and `content_trim` has only the body. It is spliced over the stored lines where the file has the section, and injected ahead of the metadata where it does not, because a ticket that is only pointed at has no section of its own and still has relations to show
- `ensure_section` inserts against `SECTION_ORDER`, before the first following section that is actually in the file, and adds no blank line that was not already there. A handwritten `## Notes` between the plan and the metadata therefore keeps its place, and Metadata is in that list as an anchor rather than as something anything appends to
- **The blocker check runs on every move**, after the already-in-that-status return and behind `force`. An open blocker is a reason not to start and a reason not to finish, and one rule is easier to hold than a table of which transitions care. A move to the status the ticket is already in is not a move, so it is not refused. `-f` now bypasses three rules, which is the right home for it: each one is a deliberate override of something the board would otherwise keep true
- **A blocker that is not on the board warns and allows the move.** Refusing would wedge the ticket with no way out but `-f`, and a uuid nothing carries is a bookkeeping fault rather than a dependency. The refusal names **every** open blocker, since clearing the one that happened to be printed would leave the ticket blocked
- Left out on purpose: removing a relation, which 4179958 assigns to 74904dc, and a blocked marker on the TUI card, which is its own ticket. Nothing on a card is worth a scan of the board per tick until the card is designed for it
### Campaigns
- **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
- **`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 three 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
- **`resolve_ticket` explains a search that names a campaign**, rather than each command doing it. One place, so `mv`, `show`, `chown` and everything else that takes a ticket give the same reason instead of a bare "no ticket found". Checked only on the zero-match path, so it costs nothing normally, and only when exactly one campaign matches: an ambiguous ticket error must not be replaced by a complaint about a directory the caller never mentioned
- **`Resolved` carries what `content_trim` cannot render from the file.** The relations block and the campaign cell both come from elsewhere on the board. A struct rather than two more parameters, so the next such field is one entry here instead of an edit at every call site
- `campaign show` lists **done** members, unlike `ls`, which leaves the done column out of its listing. What is finished against what is left is the whole question a campaign asks, so hiding half the answer is not an option. `ls --campaign` is the other way round: it is the ordinary board filtered, and keeps every rule `ls` already has
- `campaign ls` scans the status directories **once per campaign** to count members. That is a scan per row rather than one walk reused, and it is deliberate: the map-from-uuid version is worth writing when a board has enough campaigns to notice
- **The TUI gets neither a campaign tab nor a card marker**, for now. The detail view resolves the field because it renders the body, and that is all. A marker on a card would want a campaigns read per reload and the four corners are already spent; same reasoning as the blocked marker, which is also its own ticket
- `campaign_body()` builds the file from `DESCRIPTION` and `METADATA_HEADING` rather than its own string literals, so the two file formats cannot drift apart on the spelling of a heading. A campaign has no acceptance criteria (its definition of done is derived), no implementation plan and no Status
- The campaigns directory is created by `init` and **on demand** by `campaign add`, since every board made before campaigns existed has none and a `worklane init` over a live board to get one would be a strange thing to have to do
### The Board View
- `worklane` with no subcommand and `worklane tui` both open it, the way a bare `frig` does. `Cli::command` is therefore an `Option`
- The worklane directory is looked for **before** the terminal, so running outside one gives the usual "No .worklane directory found" rather than a complaint about the tty. Both errors stay reachable and both are testable without a pty
Generated
+1 -1
View File
@@ -1494,7 +1494,7 @@ dependencies = [
[[package]]
name = "worklane"
version = "0.10.0"
version = "0.12.0"
dependencies = [
"anyhow",
"assert_cmd",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "worklane"
version = "0.10.0"
version = "0.12.0"
edition = "2024"
[dependencies]
+1
View File
@@ -13,6 +13,7 @@ Worklane is a local Kanban flow for agentic software development.
| `worklane mv <id> --status <target> [-f]` | Moves ticket between statuses. Default: forward only, one stage at a time. `-f` bypasses both restrictions |
| `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 |
| `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 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. `mv` refuses to move a ticket blocked by one that is not done, unless `-f` |
| `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 check <ticket> [criterion]` | Ticks one acceptance criterion, by number as shown by `show` or by a substring. Prompts with the numbered list if omitted, or errors with it when there is no terminal |
| `worklane uncheck <ticket> [criterion]` | Unticks one acceptance criterion, addressed the same way |
+64 -5
View File
@@ -32,6 +32,9 @@ go straight to `reviewing` and has to be walked through `committed` anyway. Doin
front is the same two commands in a more useful order. `-f` allows a backward or
skipping move, for correcting a mistake.
A move is also refused while the ticket is blocked by one that is not done yet, see
[Relating tickets](#relating-tickets).
## Reading the board
```
@@ -102,8 +105,63 @@ one command here that does not start with the ticket. The user is free text and
checked against nothing. Swap the two and the call fails, because the username has to
resolve as a ticket.
`worklane init` creates `.worklane/` with the four status directories, for a repo that
has no board yet.
`worklane init` creates `.worklane/` with the four status directories and the campaigns
directory beside them, for a repo that has no board yet.
## Relating tickets
```
worklane relate 1b78a24 --blocked-by 4179958 # this one waits on that one
worklane relate 1b78a24 --regression-of 6d327df # this one broke that one's fix
worklane relate 1b78a24 --relates-to 7bfb9fc # neighbours, no dependency
```
One flag per kind, and each repeats. The ticket comes first and the flag says what it is
to the target, so read the call as a sentence: `relate A --blocked-by B` means A waits
on B. **Only one side is stored**, on the ticket you name, and `show` derives the other
end for the ticket at the far side, so never record both directions.
`--blocked-by` is enforced: `mv` refuses to move a ticket while a ticket it is blocked by
is not in `done`, whichever move it is, and names every open blocker. `-f` moves it
anyway, beside the backward and skipping moves it already allows. The other two kinds are
reference data and never refuse anything.
Recording a relation the ticket already holds reports no change. A ticket cannot relate
to itself, and a target that later disappears shows as `_missing_` rather than silently
going away.
## Campaigns
A campaign groups the tickets that have to be finished together: a release, a migration,
anything whose parts are separate tickets but whose goal is one thing. It is a file of
its own under `.worklane/campaigns/`, with a title and a description, and it sits in no
status directory. Its state is derived instead, open until every member is done, so
there is no such thing as a done campaign holding an open ticket.
```
worklane campaign add --title "v1 release" \
--description "Everything that has to ship before the tag."
worklane campaign ls # every campaign and how far it has got
worklane campaign show "v1 release" # its body, then its members by status
worklane assign "v1 release" 1b78a24 # put a ticket in it
worklane ls --campaign "v1 release" # only that campaign's tickets
```
`assign` takes the **campaign first and the ticket second**, like `chown`, and is the
only writer of the field. `add` has no `--campaign` and neither has `set`, so membership
has one writer the way owner and status do.
A ticket is in at most one campaign, so assigning one that already belongs somewhere
moves it rather than adding a second. Assigning it to the campaign it already names
reports no change and writes nothing.
`campaign show` lists done members too, unlike `ls`, which leaves the done column out of
its listing: a campaign is precisely the question of what is finished against what is
left.
A campaign is addressed the way a ticket is, by uuid prefix, title or filename, but it
is not a ticket. Passing one where a ticket is expected is refused with a message saying
so, and there is no way to move a campaign, because it has no status to move.
## Search the backlog before filing
@@ -114,9 +172,10 @@ existing ticket will have been written from a different angle.
- Already there and still open: add what you learned as a comment, not a second ticket.
- Already there and closed, but the issue is back: file a **new** ticket naming the old
id, and say it is a regression. There is no way to reopen one, and moving a done
ticket back would destroy the record of the original fix.
- Related but not the same: file it and reference the neighbour by id.
id, and record it with `relate <new> --regression-of <old>`. There is no way to reopen
one, and moving a done ticket back would destroy the record of the original fix.
- Related but not the same: file it, and record it with `relate <new> --relates-to <old>`
rather than only mentioning the id in prose.
## Addressing a ticket
+294
View File
@@ -0,0 +1,294 @@
//! Campaigns: the container for tickets that have to be finished together.
//!
//! A campaign is a file of its own under `.worklane/campaigns/`, holding a title, a
//! description and metadata. It has no status directory and never sits in one. Its
//! state is derived instead: open until every member is done. Deriving it means there
//! is no such thing as a done campaign holding an open ticket, and no second
//! forward-only ruleset to reason about beside `mv`'s.
//!
//! Membership is one field on the *member*, `Campaign` in the ticket Metadata, written
//! only by `assign`. The member list is deliberately not stored 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.
use anyhow::{Result, anyhow};
use std::fs;
use std::path::{Path, PathBuf};
use crate::util::*;
/// Where campaigns live, beside the status directories rather than among them.
pub const CAMPAIGNS_DIR: &str = "campaigns";
pub fn campaigns_dir(worklane_dir: &Path) -> PathBuf {
worklane_dir.join(CAMPAIGNS_DIR)
}
/// The campaigns directory, created if the board predates it.
///
/// `init` writes it for a new board, but every board made before campaigns existed has
/// none, and refusing to file a campaign there would mean a `worklane init` over a live
/// board just to get a directory.
pub fn ensure_campaigns_dir(worklane_dir: &Path) -> Result<PathBuf> {
let dir = campaigns_dir(worklane_dir);
fs::create_dir_all(&dir)
.map_err(|e| anyhow!("Could not create {}: {}", dir.display(), e))?;
Ok(dir)
}
/// A campaign as it comes off disk.
pub struct Campaign {
pub uuid: String,
pub title: String,
pub content: String,
}
/// The campaigns directory as [`resolve_in`] takes it.
///
/// The name is empty because a campaign has no status: it is what makes the ambiguity
/// listing print an id and a title with no bracket after it.
fn campaign_paths(worklane_dir: &Path) -> Vec<(String, PathBuf)> {
vec![(String::new(), campaigns_dir(worklane_dir))]
}
/// A campaign by the same three tiers a ticket resolves by, scoped to its own
/// directory.
///
/// The tiers are [`resolve_in`]'s, not a second copy: a campaign is addressed the way
/// everything else here is, and two resolvers would be two sets of precedence rules to
/// keep in step.
pub fn resolve_campaign(search: &str, worklane_dir: &Path) -> Result<Campaign> {
let mut matches = resolve_in(search, &campaign_paths(worklane_dir))?;
if matches.is_empty() {
return Err(anyhow!("No campaign found matching '{}'", search));
}
if matches.len() > 1 {
return Err(ambiguous("campaign", search, &matches));
}
let found = matches.remove(0);
let uuid = parse_ticket_field(&found.content, "ID");
if uuid.trim().is_empty() || is_unknown_value(&uuid) {
return Err(anyhow!(
"Campaign '{}' has no ID field, so nothing can be assigned to it",
found.title
));
}
Ok(Campaign {
uuid,
title: found.title,
content: found.content,
})
}
/// The title of the campaign a search names, for a caller that only needs to say so.
///
/// Used by `resolve_ticket` to explain a search that names a campaign rather than a
/// ticket. Deliberately swallows both failures: nothing matched and too much matched
/// both mean "this is not the explanation", and an error here would replace a clear
/// "no ticket found" with a complaint about a directory the caller never mentioned.
pub fn campaign_named(search: &str, worklane_dir: &Path) -> Option<String> {
resolve_campaign(search, worklane_dir)
.ok()
.map(|campaign| campaign.title)
}
/// Every campaign on the board, read in one pass.
///
/// One pass for the same reason [`RelationIndex`] takes one: rendering a ticket's
/// Campaign field or listing the campaigns both need every one of them, and a lookup
/// per ticket would read the directory once per row.
pub struct CampaignIndex {
campaigns: Vec<Campaign>,
}
impl CampaignIndex {
pub fn load(worklane_dir: &Path) -> Result<Self> {
let dir = campaigns_dir(worklane_dir);
let mut campaigns = Vec::new();
// A board with no campaigns directory has no campaigns, which is not an error:
// every board made before campaigns existed is in that state.
if !dir.exists() {
return Ok(Self { campaigns });
}
for entry in fs::read_dir(&dir)?.filter_map(|e| e.ok()) {
let path = entry.path();
if !path.extension().is_some_and(|e| e == "md") {
continue;
}
let Ok(content) = fs::read_to_string(&path) else {
continue;
};
campaigns.push(Campaign {
uuid: parse_ticket_field(&content, "ID"),
title: heading_title(&content),
content,
});
}
// By title, so a listing does not depend on the order the directory hands its
// entries back in.
campaigns.sort_by_key(|campaign| campaign.title.to_lowercase());
Ok(Self { campaigns })
}
/// The campaign carrying `uuid`, or nothing when the board no longer has it.
pub fn get(&self, uuid: &str) -> Option<&Campaign> {
self.campaigns.iter().find(|campaign| campaign.uuid == uuid)
}
pub fn iter(&self) -> impl Iterator<Item = &Campaign> {
self.campaigns.iter()
}
pub fn is_empty(&self) -> bool {
self.campaigns.is_empty()
}
}
/// The Campaign field as it reads, or empty for a ticket in no campaign.
///
/// A uuid no campaign carries renders as `_missing_`, the way a dangling relation
/// 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 {
let Some(uuid) = parse_campaign(content) else {
return String::new();
};
reference_cell(
&uuid,
index.get(&uuid).map(|campaign| campaign.title.as_str()),
colored,
)
}
/// 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> {
Ok(Resolved {
relations: relations_block(content, worklane_dir, colored)?,
campaign: campaign_cell(content, &CampaignIndex::load(worklane_dir)?, colored),
})
}
/// The members of a campaign, grouped by status in flow order.
///
/// Read through `collect_ticket_items`, the source `ls` and the board already use, so
/// there is no second parser and the rows print the way every other listing does.
/// Empty groups are kept: a campaign's shape is the four statuses, and a caller that
/// wants only the filled ones can say so.
pub fn members(worklane_dir: &Path, uuid: &str) -> Result<Vec<(&'static str, Vec<TicketItem>)>> {
let mut grouped = Vec::new();
for status in status_dirs() {
let status_path = worklane_dir.join(status);
let items = match status_path.exists() {
true => collect_ticket_items(&status_path)?,
false => Vec::new(),
};
grouped.push((
status,
items
.into_iter()
.filter(|item| item.campaign.as_deref() == Some(uuid))
.collect(),
));
}
Ok(grouped)
}
/// How far a campaign has got: members done against members held.
pub struct Standing {
pub done: usize,
pub total: usize,
}
impl Standing {
pub fn of(grouped: &[(&'static str, Vec<TicketItem>)]) -> Self {
Self {
done: grouped
.iter()
.filter(|(status, _)| *status == DONE)
.map(|(_, items)| items.len())
.sum(),
total: grouped.iter().map(|(_, items)| items.len()).sum(),
}
}
/// The count as it reads, or `no members` for a campaign nothing has been filed
/// against.
pub fn label(&self) -> String {
match self.total {
0 => "no members".to_string(),
total => format!("{}/{} done", self.done, total),
}
}
/// A campaign is done when it holds members and every one of them is done.
///
/// An empty campaign is neither, hence the `None`: calling it done would make a
/// container nothing has been filed against the most complete thing on the board,
/// and calling it open would claim work that does not exist.
pub fn state(&self) -> Option<&'static str> {
match (self.total, self.done == self.total) {
(0, _) => None,
(_, true) => Some(DONE),
(_, false) => Some("open"),
}
}
}
/// The campaign file as it is written.
///
/// The same shape a ticket has, minus what a campaign has no use for: no acceptance
/// criteria, because its definition of done is derived from its members rather than
/// written down, no implementation plan, and no Status, because it sits in no status
/// directory. The headings and the placeholder come from the section table in
/// `util.rs`, so the two file formats cannot drift apart on the spelling of a heading.
pub fn campaign_body(
title: &str,
description: &[String],
id: &uuid::Uuid,
owner: Option<&str>,
created_at: &str,
) -> String {
// Joined with a single newline, so an empty value is how a caller spells a
// paragraph break, exactly as it is for a ticket.
let description = trim_blank_ends(description);
let description_text = match description.is_empty() {
true => DESCRIPTION.placeholder.to_string(),
false => description.join("\n"),
};
format!(
"# {title}\n\
\n\
{description_heading}\n\
{description_text}\n\
\n\
{metadata_heading}\n\
\n\
- **ID**: {id}\n\
- **Owner**: {owner}\n\
- **Created At**: {created_at}\n\
",
description_heading = DESCRIPTION.heading,
metadata_heading = METADATA_HEADING,
owner = owner.unwrap_or("_Not set_"),
)
}
+116 -1
View File
@@ -2,7 +2,7 @@ use clap::Parser;
use std::sync::LazyLock;
use crate::util::{PRIORITY_RANGE, priority_legend};
use crate::util::{PRIORITY_RANGE, RelationKind, priority_legend};
/// clap wants a `&str` with a long enough lifetime, and the legend is built from
/// the same ramp the listing uses rather than spelled out a second time.
@@ -81,6 +81,10 @@ pub enum Command {
/// Only show tickets at this priority, 1 (most urgent) to 5 (least)
#[arg(long, value_parser = priority_level)]
priority: Option<u8>,
/// Only show the members of this campaign, by UUID or title
#[arg(long, value_parser = non_empty)]
campaign: Option<String>,
},
/// Show a ticket by UUID or title
@@ -109,6 +113,9 @@ pub enum Command {
/// Add to a section of an existing ticket
Append(AppendArgs),
/// Record a relation from one ticket to another
Relate(RelateArgs),
/// Change the owner of a ticket
///
/// User first, ticket second, after Unix `chown`. That reverses the ticket-first
@@ -156,6 +163,28 @@ pub enum Command {
owner: Option<String>,
},
/// Group tickets that have to be finished together
Campaign {
#[command(subcommand)]
command: CampaignCommand,
},
/// Put a ticket in a campaign
///
/// Campaign first, ticket second, after `chown` and for the same reason: the
/// container is what the call is about, and the order is worth being consistent
/// about across the two commands that name two things.
///
/// The only writer of the Campaign field. `add` has no `--campaign` and `set` has
/// no `--campaign`, so the field keeps one writer the way Owner and Status do.
Assign {
/// Campaign UUID or title
campaign: String,
/// Ticket UUID or title
ticket: String,
},
/// Install the agent skill that teaches an agent to use worklane
InstallSkill {
/// Overwrite an existing copy that has been modified
@@ -168,6 +197,48 @@ pub enum Command {
},
}
/// What a campaign can be asked for.
///
/// No `mv`: a campaign has no status to move it to, its state is derived from its
/// members. No `set` or `append` either, which is a gap rather than a decision, since
/// nothing yet edits a campaign after it is filed.
#[derive(clap::Subcommand)]
pub enum CampaignCommand {
/// File a new campaign
Add(CampaignAddArgs),
/// List campaigns with their member counts
Ls,
/// Show a campaign and its members grouped by status
Show {
/// Campaign UUID or title
campaign: String,
},
}
/// What a campaign holds: a title, a description and an owner.
///
/// Deliberately narrower than [`AddArgs`]. There are no acceptance criteria, because a
/// campaign's definition of done is derived from its members rather than written down,
/// and no implementation plan. Priority, tags and a due date are left out because
/// nothing reads them yet, and a field written but never shown is a field that goes
/// stale unnoticed.
#[derive(clap::Args)]
pub struct CampaignAddArgs {
/// Campaign title
#[arg(short, long, allow_hyphen_values = PROSE)]
pub title: String,
/// What the campaign is for. Use multiple flags for multiline descriptions
#[arg(short, long, allow_hyphen_values = PROSE)]
pub description: Vec<String>,
/// Owner. Defaults to the git user
#[arg(short, long)]
pub owner: Option<String>,
}
/// `add` carries every field a new ticket can hold, so it is a struct rather than an
/// inline variant: nine parameters at the call site is what `too_many_arguments` is
/// for, and `set`, `append` and `check` already pass their arguments this way.
@@ -280,6 +351,50 @@ pub struct AppendArgs {
pub plan: Vec<String>,
}
/// `relate` is the only writer of the Relations section, the way `chown` is the only
/// writer of Owner. One flag per kind rather than a `--kind` value: the accepted kinds
/// are then clap's business, an unknown one is a usage error, and a call reads as a
/// sentence about the ticket it names.
///
/// Each flag repeats, so several relations of one kind land in a single call. The
/// targets are ticket searches, resolved by the same three tiers every other ticket
/// argument is, and stored as the target's uuid.
#[derive(clap::Args)]
#[command(group(
clap::ArgGroup::new("relation_kinds")
.required(true)
.multiple(true)
.args(["blocked_by", "regression_of", "relates_to"])
))]
pub struct RelateArgs {
/// Ticket UUID or title
pub ticket: String,
/// Ticket this one waits on. Its own moves are refused until the target is done
#[arg(long, value_parser = non_empty)]
pub blocked_by: Vec<String>,
/// Ticket whose fix this one broke
#[arg(long, value_parser = non_empty)]
pub regression_of: Vec<String>,
/// Ticket this one is merely related to. Symmetric, so it is recorded once
#[arg(long, value_parser = non_empty)]
pub relates_to: Vec<String>,
}
impl RelateArgs {
/// The relations asked for, one entry per kind, so the handler walks a table
/// instead of repeating itself three times.
pub fn requested(&self) -> [(RelationKind, &[String]); 3] {
[
(RelationKind::BlockedBy, &self.blocked_by),
(RelationKind::RegressionOf, &self.regression_of),
(RelationKind::RelatesTo, &self.relates_to),
]
}
}
/// `check` and `uncheck` are separate commands rather than one verb with a flag,
/// because the two read as opposites at the call site and neither needs the other's
/// name to make sense.
+328 -5
View File
@@ -4,7 +4,8 @@ use std::fs;
use std::io::{BufRead, IsTerminal, Write};
use std::path::Path;
use crate::command::{AddArgs, AppendArgs, CheckArgs, SetArgs};
use crate::campaign::*;
use crate::command::{AddArgs, AppendArgs, CampaignAddArgs, CheckArgs, RelateArgs, SetArgs};
use crate::install;
use crate::util::*;
@@ -27,6 +28,11 @@ pub fn cmd_init(start: &Path) -> Result<()> {
fs::create_dir_all(worklane_dir.join(folder))?;
}
// Beside the status directories, not among them: a campaign has no status. Created
// here for a new board, and on demand by `campaign add` for a board that predates
// campaigns, which is why `status_dirs()` is untouched.
fs::create_dir_all(campaigns_dir(&worklane_dir))?;
println!("Initialized worklane in: {}", worklane_dir.display());
Ok(())
}
@@ -34,8 +40,25 @@ pub fn cmd_init(start: &Path) -> Result<()> {
pub fn cmd_ls(
status_filter: &Option<String>,
priority_filter: Option<u8>,
campaign_filter: &Option<String>,
worklane_dir: &Path,
) -> Result<()> {
// Resolved before anything is read, so an unknown campaign is refused rather than
// silently listing nothing, and the name is available for the heading.
let campaign = match campaign_filter {
Some(search) => Some(resolve_campaign(search, worklane_dir)?),
None => None,
};
let uuid = campaign.as_ref().map(|campaign| campaign.uuid.as_str());
if let Some(campaign) = &campaign {
println!(
"Members of campaign ({}) {}\n",
color_text(short_id(&campaign.uuid), Color::Red),
color_text(&campaign.title, Color::Green),
);
}
if let Some(status) = status_filter {
let status_path = worklane_dir.join(status);
if !status_path.exists() {
@@ -45,7 +68,7 @@ pub fn cmd_ls(
));
}
let items = filter_by_priority(collect_ticket_items(&status_path)?, priority_filter);
let items = filtered(collect_ticket_items(&status_path)?, priority_filter, uuid);
if items.is_empty() {
println!("No tickets in '{}' status.", status);
@@ -63,7 +86,7 @@ pub fn cmd_ls(
if !status_path.exists() {
continue;
}
let items = filter_by_priority(collect_ticket_items(&status_path)?, priority_filter);
let items = filtered(collect_ticket_items(&status_path)?, priority_filter, uuid);
let count = items.len();
let label = if count == 1 { "ticket" } else { "tickets" };
println!(" [{}] {} {}", status.to_uppercase(), count, label);
@@ -79,7 +102,7 @@ pub fn cmd_ls(
continue;
}
let items = match collect_ticket_items(&status_path) {
Ok(items) => filter_by_priority(items, priority_filter),
Ok(items) => filtered(items, priority_filter, uuid),
Err(_) => continue,
};
if items.is_empty() {
@@ -94,6 +117,23 @@ pub fn cmd_ls(
Ok(())
}
/// The listing filters in one call, so the three places `ls` collects a column cannot
/// end up applying a different set of them.
fn filtered(items: Vec<TicketItem>, level: Option<u8>, campaign: Option<&str>) -> Vec<TicketItem> {
filter_by_campaign(filter_by_priority(items, level), campaign)
}
/// Keep only the members of `campaign`, or everything when none was asked for.
fn filter_by_campaign(items: Vec<TicketItem>, campaign: Option<&str>) -> Vec<TicketItem> {
match campaign {
Some(uuid) => items
.into_iter()
.filter(|item| item.campaign.as_deref() == Some(uuid))
.collect(),
None => items,
}
}
/// Keep only the tickets at `level`, or everything when no level was asked for.
fn filter_by_priority(items: Vec<TicketItem>, level: Option<u8>) -> Vec<TicketItem> {
match level {
@@ -302,13 +342,16 @@ fn write_new_comment(comments_dir: &Path, stem: &str, content: &str) -> Result<S
pub fn cmd_show(search: &str, worklane_dir: &Path) -> Result<()> {
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.
let resolved = resolved_for(&content, worklane_dir, should_use_colors())?;
// 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
// 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));
println!("\n{}", content_trim_colored(&content, &resolved));
if ticket_uuid != "_Not set_" {
let comments_dir = worklane_dir.join("comments").join(&ticket_uuid);
@@ -434,6 +477,59 @@ fn move_ticket_file(
})
}
/// Refuse a move while a ticket it is `blocked by` is not done.
///
/// Every move, not only the one into committed: an open blocker is a reason not to
/// start and a reason not to finish, and one rule is easier to hold than a table of
/// which transitions care. Called before anything is written, so a refusal leaves no
/// rename, no rewritten field and no half moved ticket.
///
/// A target the board does not have warns and allows the move. Refusing there would
/// wedge the ticket behind a bookkeeping fault with no way out but `--force`, and a
/// dangling uuid is not a dependency.
fn check_blockers(worklane_dir: &Path, content: &str, title: &str) -> Result<()> {
let blockers: Vec<Relation> = parse_relations(content, title)?
.into_iter()
.filter(|relation| relation.kind == RelationKind::BlockedBy)
.collect();
if blockers.is_empty() {
return Ok(());
}
let index = RelationIndex::load(worklane_dir)?;
let mut open: Vec<String> = Vec::new();
for blocker in &blockers {
match index.get(&blocker.target) {
Some(target) if target.status == DONE => {}
Some(target) => open.push(format!(
" ({}) {} [{}]",
color_text(short_id(&target.uuid), Color::Red),
target.title,
color_text(&target.status, Color::Orange),
)),
None => eprintln!(
"Warning: ticket '{}' is blocked by {}, which is not on the board.",
title,
short_id(&blocker.target),
),
}
}
if open.is_empty() {
return Ok(());
}
// Every open blocker, not the first: a ticket waiting on three of them is not
// unblocked by clearing the one the message happened to name.
Err(anyhow!(
"Cannot move '{}' while it is blocked by:\n{}\nUse --force (-f) to move it anyway.",
color_text(title, Color::Green),
open.join("\n"),
))
}
pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -> Result<()> {
let valid_statuses = ["backlog", "committed", "reviewing", "done"];
let forward_order = ["backlog", "committed", "reviewing", "done"];
@@ -480,6 +576,13 @@ pub fn cmd_mv(ticket_id: &str, target_status: &str, force: bool, start: &Path) -
return Ok(());
}
// After the no-op above, so a ticket is never refused for a move it is not making,
// and behind `force`, which is where the other two overrides of a rule the board
// keeps true already live.
if !force {
check_blockers(&worklane_dir, &resolved, &title)?;
}
let current_path = worklane_dir.join(&current_status);
let target_path = worklane_dir.join(target_status);
@@ -750,6 +853,226 @@ pub fn cmd_append(args: &AppendArgs, start: &Path) -> Result<()> {
Ok(())
}
/// Record a relation from one ticket to another.
///
/// One side is written and the inverse is derived wherever it is shown. `blocked by`
/// goes on the gated ticket rather than `blocks` on the blocker: the gated ticket is the
/// one whose move is refused and whose author knows about the dependency. `relates to`
/// is symmetric, so it is written once, on whichever end the caller ran it from.
///
/// The kinds are a flag each rather than a `--kind` value, so an unknown kind is a
/// usage error at the door instead of a line written into the file and refused on the
/// way back out.
pub fn cmd_relate(args: &RelateArgs, start: &Path) -> 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");
let existing = parse_relations(&original, &title)?;
// Every target resolved and every refusal raised before a byte is written, so a
// call naming one good ticket and one bad one records neither.
let mut items: Vec<String> = Vec::new();
let mut changed: Vec<&str> = Vec::new();
for (kind, targets) in args.requested() {
for search in targets {
let (_target_status, target_title, target) = resolve_ticket(search, &worklane_dir)?;
let target_uuid = parse_ticket_field(&target, "ID");
if target_uuid.trim().is_empty() || is_unknown_value(&target_uuid) {
return Err(anyhow!(
"Ticket '{}' has no ID field, so nothing can point at it",
target_title
));
}
if target_uuid == uuid {
return Err(anyhow!(
"A ticket cannot relate to itself, and '{}' is the ticket being edited",
title
));
}
let relation = Relation {
kind,
target: target_uuid,
};
// Already held, either in the file or earlier in this call. Recording it
// twice would read as two dependencies on one ticket.
if existing.contains(&relation) || items.contains(&relation.item()) {
continue;
}
items.push(relation.item());
if !changed.contains(&kind.label()) {
changed.push(kind.label());
}
}
}
if items.is_empty() {
report(&[], &title, "Recorded");
return Ok(());
}
let content = append_section_body(&ensure_section(&original, &RELATIONS), &RELATIONS, &items)?;
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
report(&changed, &title, "Recorded");
Ok(())
}
// ------------------------------------------------------------------- campaigns --
/// File a new campaign.
///
/// 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<()> {
let CampaignAddArgs {
title,
description,
owner,
} = args;
let worklane_dir = find_worklane_dir(start)?;
let dir = ensure_campaigns_dir(&worklane_dir)?;
let owner = match owner {
Some(owner) => Some(owner.clone()),
None => get_git_user(),
};
let id = uuid::Uuid::new_v4();
let filename = format!("{}_{}.md", id, slug(title));
let path = dir.join(&filename);
let body = campaign_body(
title,
description,
&id,
owner.as_deref(),
&Local::now().format(TIMESTAMP_FORMAT).to_string(),
);
write_then_replace(&worklane_dir, &path, &filename, &body, title)?;
println!("Created campaign: {}", filename);
Ok(())
}
/// List the campaigns with how far each has got.
///
/// The counts come from one pass over the status directories per campaign. That is a
/// 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) -> Result<()> {
let index = CampaignIndex::load(worklane_dir)?;
if index.is_empty() {
println!("No campaigns yet. `worklane campaign add --title` files one.");
return Ok(());
}
let colored = should_use_colors();
println!("Campaigns:\n");
for campaign in index.iter() {
let standing = Standing::of(&members(worklane_dir, &campaign.uuid)?);
let state = match standing.state() {
Some(state) => format!(" [{}]", paint(state, Color::Orange, colored)),
None => String::new(),
};
println!(
" ({}) {} | {}{}",
paint(short_id(&campaign.uuid), Color::Red, colored),
campaign.title,
standing.label(),
state,
);
}
Ok(())
}
/// Show a campaign, then its members grouped by status.
///
/// 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<()> {
let campaign = resolve_campaign(search, worklane_dir)?;
println!("{}", color_text(&campaign.title, Color::Green));
println!("{}", "─".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())
);
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());
for (status, items) in &grouped {
if items.is_empty() {
continue;
}
println!(
"\n{}",
color_text(&format!("[{}]", status.to_uppercase()), Color::Orange)
);
display_ticket_items(items);
}
Ok(())
}
/// Put a ticket in a campaign, the only writer of the Campaign field.
///
/// The campaign is resolved first, so a call naming a good ticket and a bad campaign
/// writes nothing. A ticket names at most one campaign because the field is rewritten
/// rather than added to, so assigning a ticket that is already in one moves it.
///
/// No-op detection compares the whole file, the way `set` and `chown` do, so assigning
/// a ticket to the campaign it already names writes nothing.
pub fn cmd_assign(campaign_search: &str, ticket_id: &str, start: &Path) -> Result<()> {
let worklane_dir = find_worklane_dir(start)?;
let campaign = resolve_campaign(campaign_search, &worklane_dir)?;
let (status, title, original) = resolve_ticket(ticket_id, &worklane_dir)?;
let uuid = parse_ticket_field(&original, "ID");
let content =
set_or_insert_metadata_field(&original, CAMPAIGN_FIELD, &campaign.uuid, &title)?;
if content == original {
println!(
"Ticket '{}' is already in campaign '{}'",
color_text(&title, Color::Green),
campaign.title,
);
return Ok(());
}
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
println!(
"Assigned '{}' to campaign '{}'",
color_text(&title, Color::Green),
campaign.title,
);
Ok(())
}
/// Which criterion to act on, asked for when the caller did not say.
///
/// A terminal gets the list and a prompt. Anything else gets the same list as an
+20 -2
View File
@@ -1,6 +1,7 @@
use anyhow::Result;
use clap::Parser;
mod campaign;
mod command;
mod handlers;
mod install;
@@ -44,9 +45,13 @@ fn main() -> Result<()> {
Some(Command::Tui { paths }) => run_tui(&paths, &start),
Some(Command::Init) => cmd_init(&start),
Some(Command::Add(args)) => cmd_add(&args, &start),
Some(Command::Ls { status, priority }) => {
Some(Command::Ls {
status,
priority,
campaign,
}) => {
let worklane_dir = find_worklane_dir(&start)?;
cmd_ls(&status, priority, &worklane_dir)
cmd_ls(&status, priority, &campaign, &worklane_dir)
}
Some(Command::Show { id }) => {
let worklane_dir = find_worklane_dir(&start)?;
@@ -59,6 +64,7 @@ fn main() -> Result<()> {
}) => cmd_mv(&ticket, &status, force, &start),
Some(Command::Set(args)) => cmd_set(&args, &start),
Some(Command::Append(args)) => cmd_append(&args, &start),
Some(Command::Relate(args)) => cmd_relate(&args, &start),
Some(Command::Chown { user, ticket }) => cmd_chown(&user, &ticket, &start),
Some(Command::Check(args)) => cmd_check(&args, true, &start),
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
@@ -67,6 +73,18 @@ fn main() -> Result<()> {
body,
owner,
}) => cmd_comment(&ticket, &body, &owner, &start),
Some(Command::Campaign { command }) => match command {
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
CampaignCommand::Ls => {
let worklane_dir = find_worklane_dir(&start)?;
cmd_campaign_ls(&worklane_dir)
}
CampaignCommand::Show { campaign } => {
let worklane_dir = find_worklane_dir(&start)?;
cmd_campaign_show(&campaign, &worklane_dir)
}
},
Some(Command::Assign { campaign, ticket }) => cmd_assign(&campaign, &ticket, &start),
// No board is looked for: the point of the skill is to teach an agent worklane
// before there is a `.worklane` anywhere.
Some(Command::InstallSkill { force, print }) => cmd_install_skill(force, print),
+133 -3
View File
@@ -501,16 +501,27 @@ impl Board {
fn detail_of(card: &Card) -> Detail {
let ticket = &card.ticket;
let content = std::fs::read_to_string(&ticket.path).unwrap_or_default();
let mut out = content_trim(&content, false);
let uuid = parse_ticket_field(&content, "ID");
let comments = match ticket.path.parent().and_then(|status| status.parent()) {
let worklane_dir = ticket.path.parent().and_then(|status| status.parent());
// All of these read the tree beside the ticket, and all fall back to nothing: one
// unreadable file must not take the board down with it. The relations cost a scan of
// the board, paid only while a ticket is open and only on a tick that changed
// something, which is what already reloads every card. The campaign title costs a
// 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())
.unwrap_or_default();
let comments = match worklane_dir {
Some(worklane_dir) => {
read_comments(&worklane_dir.join("comments").join(&uuid)).unwrap_or_default()
}
None => Vec::new(),
};
let mut out = content_trim(&content, false, &resolved);
out.push('\n');
out.push_str(&format_comments_with(&comments, false));
Detail {
@@ -2666,4 +2677,123 @@ mod tests {
}
/// The detail view is the second renderer of a ticket body, so it resolves a
/// relation the way `show` does rather than printing the uuid the file stores.
///
/// The section goes in `extra`, after the metadata, which is not where `relate`
/// writes it. Position is the CLI's test to make; this one is about the lookup.
#[test]
fn the_detail_view_resolves_a_relation_to_a_title() {
let dir = board_dir();
let target = "22222222-0000-4000-8000-000000000000";
write_ticket(&dir, "backlog", target, "The target", "");
write_ticket(
&dir,
"backlog",
"11111111-0000-4000-8000-000000000000",
"A holder",
&format!("\n## Relations\n- blocked by {target}\n"),
);
let mut board = one_board(&dir);
board.toggle_detail();
let text = &board.detail.as_ref().expect("no detail").text;
assert!(text.contains("blocked by (2222222) The target"), "{text:?}");
assert!(!text.contains(target), "the bare uuid was drawn: {text:?}");
}
/// The far end of a relation stores nothing, so the board derives it too.
#[test]
fn the_detail_view_derives_the_other_end() {
let dir = board_dir();
let holder = "11111111-0000-4000-8000-000000000000";
write_ticket(
&dir,
"backlog",
holder,
"A holder",
"\n## Relations\n- blocked by 22222222-0000-4000-8000-000000000000\n",
);
write_ticket(&dir, "backlog", "22222222-0000-4000-8000-000000000000", "The target", "");
let mut board = one_board(&dir);
// The holder sorts first by title, so the target is the card below it.
board.select_card(1, SCREEN);
board.toggle_detail();
let text = &board.detail.as_ref().expect("no detail").text;
assert!(text.contains("blocks (1111111) A holder"), "{text:?}");
}
/// The detail view resolves the Campaign field the way `show` does. The field stores
/// a uuid, so an unresolved one would put thirty-six characters of hex on screen.
#[test]
fn the_detail_view_shows_the_campaign_title() {
let dir = board_dir();
let campaign = "cccccccc-0000-4000-8000-000000000000";
std::fs::create_dir_all(dir.join("campaigns")).unwrap();
std::fs::write(
dir.join("campaigns").join(format!("{campaign}_v1-release.md")),
format!("# v1 release\n\n## Metadata\n\n- **ID**: {campaign}\n"),
)
.unwrap();
write_ticket(
&dir,
"backlog",
"11111111-0000-4000-8000-000000000000",
"A member",
&format!("- **Campaign**: {campaign}\n"),
);
let mut board = one_board(&dir);
board.toggle_detail();
let text = &board.detail.as_ref().expect("no detail").text;
assert!(text.contains("(ccccccc) v1 release"), "{text:?}");
assert!(!text.contains(campaign), "the bare uuid reached the screen: {text:?}");
}
/// A board with no campaigns directory is every board made before campaigns existed.
/// The detail view still has to draw.
#[test]
fn a_board_with_no_campaigns_directory_still_draws_a_ticket() {
let dir = board_dir();
write_ticket(
&dir,
"backlog",
"11111111-0000-4000-8000-000000000000",
"A ticket",
"- **Campaign**: cccccccc-0000-4000-8000-000000000000\n",
);
let mut board = one_board(&dir);
board.toggle_detail();
let text = &board.detail.as_ref().expect("no detail").text;
assert!(text.contains("A description."), "the body was lost: {text:?}");
// No campaigns to resolve against, so the reference reads as gone.
assert!(text.contains("_missing_"), "{text:?}");
}
/// The CLI refuses a relations line it cannot read, naming the ticket. The board
/// cannot: one hand-edited file must not take every other card down with it.
#[test]
fn a_relations_line_that_cannot_be_read_still_draws_the_ticket() {
let dir = board_dir();
write_ticket(
&dir,
"backlog",
"11111111-0000-4000-8000-000000000000",
"A holder",
"\n## Relations\n- depends on 22222222-0000-4000-8000-000000000000\n",
);
let mut board = one_board(&dir);
board.toggle_detail();
let text = &board.detail.as_ref().expect("no detail").text;
assert!(text.contains("A description."), "the body was lost: {text:?}");
}
}
+1068 -83
View File
File diff suppressed because it is too large Load Diff
+602
View File
@@ -0,0 +1,602 @@
use assert_cmd::Command;
use assert_fs::TempDir;
use assert_fs::fixture::{PathChild, PathCreateDir};
use std::fs;
use std::path::{Path, PathBuf};
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
/// Two campaigns, so a filter has something to exclude, and three tickets: one in each
/// campaign and one in neither.
const CAMP_A: &str = "aa11bb22-33cc-4dd4-8ee5-ff6677889900";
const CAMP_B: &str = "bb22cc33-44dd-4ee5-8ff6-001122334455";
const MEMBER: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
const OTHER: &str = "b1b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d";
const LONER: &str = "f1f2f3f4-5a6b-4c7d-8e9f-0a1b2c3d4e5f";
fn setup_worklane(temp: &TempDir) -> PathBuf {
let worklane = temp.child(".worklane");
worklane.create_dir_all().unwrap();
for dir in ["backlog", "committed", "reviewing", "done", "campaigns"] {
worklane.child(dir).create_dir_all().unwrap();
}
worklane.path().to_path_buf()
}
fn slug(title: &str) -> String {
title
.to_lowercase()
.chars()
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
.map(|c| if c == ' ' { '-' } else { c })
.collect()
}
/// A ticket with a ticked criterion, a section the tool knows nothing about and a
/// metadata field it has never heard of, so every test can check that an assignment
/// leaves all three exactly as they were.
///
/// Deliberately carries no Campaign field: no ticket written before campaigns existed
/// has one, and `add` still does not write one, so the insertion path is what every
/// assignment goes through.
fn create_ticket(worklane: &Path, status: &str, title: &str, uuid: &str) -> PathBuf {
let path = worklane
.join(status)
.join(format!("{}_{}.md", uuid, slug(title)));
fs::write(
&path,
format!(
"# {title}\n\
\n\
## Description\n\
Prose that mentions **Campaign**: not a field, in the body.\n\
\n\
## Acceptance Criteria\n\
- [x] Crit one\n\
\n\
## Implementation Plan\n\
1. Step one\n\
\n\
## Notes\n\
A handwritten note the tool knows nothing about.\n\
\n\
## Metadata\n\
\n\
- **ID**: {uuid}\n\
- **Priority**: 3\n\
- **Tags**: alpha\n\
- **Due**: _Not set_\n\
- **Handled By Team**: ops\n\
- **Owner**: alice\n\
- **Created At**: 2026-08-21 02:10:17\n\
- **Status**: {status}\n"
),
)
.unwrap();
path
}
fn create_campaign(worklane: &Path, title: &str, uuid: &str) -> PathBuf {
let path = worklane
.join("campaigns")
.join(format!("{}_{}.md", uuid, slug(title)));
fs::write(
&path,
format!(
"# {title}\n\
\n\
## Description\n\
What has to ship together.\n\
\n\
## Metadata\n\
\n\
- **ID**: {uuid}\n\
- **Owner**: alice\n\
- **Created At**: 2026-08-21 02:10:17\n"
),
)
.unwrap();
path
}
fn board(temp: &TempDir) -> PathBuf {
let worklane = setup_worklane(temp);
create_campaign(&worklane, "v1 release", CAMP_A);
create_campaign(&worklane, "v2 release", CAMP_B);
create_ticket(&worklane, "backlog", "The member", MEMBER);
create_ticket(&worklane, "done", "The other member", OTHER);
create_ticket(&worklane, "backlog", "The loner", LONER);
worklane
}
fn run(temp: &TempDir, args: &[&str]) -> std::process::Output {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(args);
cmd.assert().get_output().clone()
}
fn stdout(out: &std::process::Output) -> String {
String::from_utf8_lossy(&out.stdout).to_string()
}
fn stderr(out: &std::process::Output) -> String {
String::from_utf8_lossy(&out.stderr).to_string()
}
fn find(worklane: &Path, uuid: &str) -> PathBuf {
for status in ["backlog", "committed", "reviewing", "done"] {
for entry in fs::read_dir(worklane.join(status))
.unwrap()
.filter_map(|e| e.ok())
{
if entry.file_name().to_string_lossy().starts_with(uuid) {
return entry.path();
}
}
}
panic!("no file for ticket {uuid}");
}
fn ticket(worklane: &Path, uuid: &str) -> String {
fs::read_to_string(find(worklane, uuid)).unwrap()
}
fn campaigns(worklane: &Path) -> Vec<String> {
let mut names: Vec<String> = fs::read_dir(worklane.join("campaigns"))
.unwrap()
.filter_map(|e| e.ok())
.map(|e| e.file_name().to_string_lossy().to_string())
.collect();
names.sort();
names
}
// ------------------------------------------------------------------ filing one --
#[test]
fn campaign_add_writes_a_uuid_title_description_and_metadata() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let out = run(
&temp,
&[
"campaign",
"add",
"--title",
"v1 release",
"--description",
"Everything that ships together.",
"--owner",
"alice",
],
);
assert!(out.status.success(), "{}", stderr(&out));
let names = campaigns(&worklane);
assert_eq!(names.len(), 1, "{names:?}");
let name = &names[0];
assert!(name.ends_with("_v1-release.md"), "{name}");
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
assert!(content.starts_with("# v1 release\n"), "{content}");
assert!(content.contains("Everything that ships together."), "{content}");
assert!(content.contains("- **Owner**: alice"), "{content}");
assert!(content.contains("- **Created At**: 20"), "{content}");
// The uuid in the file is the one in the filename, since that is what `assign`
// stores and what every lookup compares against.
let uuid = name.split('_').next().unwrap();
assert!(content.contains(&format!("- **ID**: {uuid}")), "{content}");
}
/// A campaign has no status, so its file carries none. A Status field would be a second
/// place for a state that is derived, and the two would disagree the moment a member
/// moved.
#[test]
fn a_campaign_carries_no_status_and_no_criteria() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
run(&temp, &["campaign", "add", "--title", "v1 release"]);
let name = campaigns(&worklane).remove(0);
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
assert!(!content.contains("**Status**"), "{content}");
assert!(!content.contains("Acceptance Criteria"), "{content}");
assert!(!content.contains("Implementation Plan"), "{content}");
}
#[test]
fn nothing_is_created_without_a_title() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let out = run(&temp, &["campaign", "add", "--description", "No title here."]);
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
assert!(campaigns(&worklane).is_empty(), "{:?}", campaigns(&worklane));
}
#[test]
fn init_creates_the_campaigns_directory() {
let temp = TempDir::new().unwrap();
let out = run(&temp, &["init"]);
assert!(out.status.success(), "{}", stderr(&out));
assert!(temp.child(".worklane").child("campaigns").path().is_dir());
}
/// A board made before campaigns existed has no such directory, and a `worklane init`
/// over a live board to get one would be a strange thing to have to do.
#[test]
fn the_campaigns_directory_is_created_for_a_board_that_predates_it() {
let temp = TempDir::new().unwrap();
let worklane = temp.child(".worklane");
worklane.create_dir_all().unwrap();
for dir in ["backlog", "committed", "reviewing", "done"] {
worklane.child(dir).create_dir_all().unwrap();
}
assert!(!worklane.child("campaigns").path().exists());
let out = run(&temp, &["campaign", "add", "--title", "v1 release"]);
assert!(out.status.success(), "{}", stderr(&out));
assert_eq!(campaigns(worklane.path()).len(), 1);
}
// -------------------------------------------------------------------- assigning --
#[test]
fn assign_writes_the_campaign_field_in_the_metadata_section() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let out = run(&temp, &["assign", "v1 release", MEMBER]);
assert!(out.status.success(), "{}", stderr(&out));
let content = ticket(&worklane, MEMBER);
assert!(content.contains(&format!("- **Campaign**: {CAMP_A}")), "{content}");
// Scoped to the section: the description quotes the marker, and the field has to
// land under the heading rather than over the prose.
let metadata = content.split("## Metadata").nth(1).unwrap();
assert!(metadata.contains(&format!("- **Campaign**: {CAMP_A}")), "{content}");
assert!(
content.contains("Prose that mentions **Campaign**: not a field, in the body."),
"the description was rewritten: {content}"
);
}
/// The field goes in its place among the others rather than at the end, so Status stays
/// last, which is where every file already keeps it.
#[test]
fn the_field_is_inserted_before_status() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
let content = ticket(&worklane, MEMBER);
let campaign_at = content.find("- **Campaign**:").unwrap();
let status_at = content.find("- **Status**:").unwrap();
assert!(campaign_at < status_at, "{content}");
}
/// All three tiers, since a campaign is addressed the way a ticket is: a uuid prefix, a
/// title substring, and a substring reaching the middle of the filename.
#[test]
fn a_campaign_resolves_by_uuid_prefix_title_or_filename() {
for search in ["aa11", "v1 release", "4dd4"] {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let out = run(&temp, &["assign", search, MEMBER]);
assert!(out.status.success(), "{search}: {}", stderr(&out));
assert!(
ticket(&worklane, MEMBER).contains(&format!("- **Campaign**: {CAMP_A}")),
"{search}: {}",
ticket(&worklane, MEMBER)
);
}
}
#[test]
fn a_ticket_names_at_most_one_campaign() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
let out = run(&temp, &["assign", "v2 release", MEMBER]);
assert!(out.status.success(), "{}", stderr(&out));
let content = ticket(&worklane, MEMBER);
assert_eq!(
content.matches("- **Campaign**:").count(),
1,
"reassigning added a second field: {content}"
);
assert!(content.contains(&format!("- **Campaign**: {CAMP_B}")), "{content}");
assert!(!content.contains(CAMP_A), "{content}");
}
#[test]
fn assigning_the_campaign_already_named_writes_nothing() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
let before = ticket(&worklane, MEMBER);
let out = run(&temp, &["assign", "v1 release", MEMBER]);
assert!(out.status.success(), "{}", stderr(&out));
assert!(stdout(&out).contains("already in campaign"), "{}", stdout(&out));
assert_eq!(ticket(&worklane, MEMBER), before);
}
/// The campaign is resolved before the ticket is touched, so a call naming a good
/// ticket and a campaign that does not exist writes nothing at all.
#[test]
fn an_unknown_campaign_leaves_the_ticket_alone() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let before = ticket(&worklane, MEMBER);
let out = run(&temp, &["assign", "v9 release", MEMBER]);
assert!(!out.status.success());
assert!(stderr(&out).contains("No campaign found matching"), "{}", stderr(&out));
assert_eq!(ticket(&worklane, MEMBER), before);
}
#[test]
fn content_the_tool_does_not_know_survives_an_assignment() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
let content = ticket(&worklane, MEMBER);
assert!(content.contains("## Notes"), "{content}");
assert!(
content.contains("A handwritten note the tool knows nothing about."),
"{content}"
);
assert!(content.contains("- **Handled By Team**: ops"), "{content}");
// And the ticked criterion is still ticked.
assert!(content.contains("- [x] Crit one"), "{content}");
}
/// One field, one writer. `assign` owns Campaign the way `chown` owns Owner.
#[test]
fn neither_add_nor_set_offers_a_campaign_flag() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let added = run(&temp, &["add", "--title", "New one", "--campaign", "v1 release"]);
assert_eq!(added.status.code(), Some(2), "{}", stderr(&added));
let set = run(&temp, &["set", MEMBER, "--campaign", "v1 release"]);
assert_eq!(set.status.code(), Some(2), "{}", stderr(&set));
// The stored shape, not the bare marker: the fixture description quotes the marker
// on purpose, so an unscoped match here would pass whatever the commands did.
assert!(!ticket(&worklane, MEMBER).contains("- **Campaign**:"));
}
// --------------------------------------------------------------------- reading --
#[test]
fn campaign_ls_lists_campaigns_with_their_member_counts() {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
run(&temp, &["assign", "v1 release", OTHER]);
let out = run(&temp, &["campaign", "ls"]);
assert!(out.status.success(), "{}", stderr(&out));
let listing = stdout(&out);
// One of the two members is in done, so the campaign is open and half finished.
assert!(listing.contains("v1 release | 1/2 done [open]"), "{listing}");
// Nothing has been filed against the other one.
assert!(listing.contains("v2 release | no members"), "{listing}");
}
/// A campaign is done when it holds members and every one of them is done. An empty one
/// is neither, which is why it reads `no members` rather than `0/0 done`.
#[test]
fn a_campaign_whose_every_member_is_done_reads_done() {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
run(&temp, &["assign", "v1 release", OTHER]);
let listing = stdout(&run(&temp, &["campaign", "ls"]));
assert!(listing.contains("v1 release | 1/1 done [done]"), "{listing}");
}
#[test]
fn campaign_show_prints_the_body_and_the_members_grouped_by_status() {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
run(&temp, &["assign", "v1 release", OTHER]);
let out = run(&temp, &["campaign", "show", "aa11"]);
assert!(out.status.success(), "{}", stderr(&out));
let shown = stdout(&out);
assert!(shown.contains("v1 release"), "{shown}");
assert!(shown.contains("What has to ship together."), "{shown}");
assert!(shown.contains("1/2 done"), "{shown}");
assert!(shown.contains("[BACKLOG]"), "{shown}");
assert!(shown.contains("The member"), "{shown}");
// Done members are shown here, unlike in `ls`: what is finished against what is
// left is the whole question a campaign asks.
assert!(shown.contains("[DONE]"), "{shown}");
assert!(shown.contains("The other member"), "{shown}");
// And a ticket in no campaign is not a member of this one.
assert!(!shown.contains("The loner"), "{shown}");
}
#[test]
fn ls_campaign_lists_only_that_campaigns_members() {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
run(&temp, &["assign", "v2 release", LONER]);
let out = run(&temp, &["ls", "--campaign", "v1 release"]);
assert!(out.status.success(), "{}", stderr(&out));
let listing = stdout(&out);
assert!(listing.contains("The member"), "{listing}");
assert!(!listing.contains("The loner"), "{listing}");
assert!(listing.contains("[BACKLOG] 1 ticket"), "{listing}");
}
#[test]
fn ls_campaign_refuses_a_campaign_that_does_not_exist() {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
let out = run(&temp, &["ls", "--campaign", "v9 release"]);
assert!(!out.status.success());
assert!(stderr(&out).contains("No campaign found matching"), "{}", stderr(&out));
}
/// The stored value is a full uuid, so a campaign that has been deleted has to be
/// reported as gone rather than shown raw, the way a dangling relation target is.
#[test]
fn a_campaign_that_no_longer_exists_reads_as_missing() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
fs::remove_file(worklane.join("campaigns").join(format!("{CAMP_A}_v1-release.md"))).unwrap();
let out = run(&temp, &["show", MEMBER]);
assert!(out.status.success(), "{}", stderr(&out));
let shown = stdout(&out);
assert!(shown.contains("_missing_"), "{shown}");
// The short id survives, since it is the only thing left to go looking for.
assert!(shown.contains("(aa11bb2)"), "{shown}");
assert!(!shown.contains(CAMP_A), "the bare uuid was shown: {shown}");
}
/// The title is shown rather than the uuid the file stores: thirty-six characters of
/// hex in a metadata table say nothing about which campaign it is.
#[test]
fn a_ticket_shows_the_campaign_title_not_its_uuid() {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
run(&temp, &["assign", "v1 release", MEMBER]);
let shown = stdout(&run(&temp, &["show", MEMBER]));
assert!(shown.contains("(aa11bb2) v1 release"), "{shown}");
assert!(!shown.contains(CAMP_A), "{shown}");
}
// -------------------------------------------------------------- not a ticket --
/// A campaign is in no status directory, so `mv` has nothing to move. It says so rather
/// than reporting a ticket it could not find, which would send the caller hunting for a
/// typo in a name that is perfectly correct.
#[test]
fn mv_refuses_a_campaign() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let out = run(&temp, &["mv", "v1 release", "--status", "committed"]);
assert!(!out.status.success());
let message = stderr(&out);
assert!(message.contains("is a campaign, not a ticket"), "{message}");
assert!(message.contains("no status directory"), "{message}");
// And it stayed where it was: nothing was moved into a status directory.
assert!(
worklane
.join("campaigns")
.join(format!("{CAMP_A}_v1-release.md"))
.exists()
);
for status in ["backlog", "committed", "reviewing", "done"] {
let moved = fs::read_dir(worklane.join(status))
.unwrap()
.filter_map(|e| e.ok())
.any(|e| e.file_name().to_string_lossy().starts_with(CAMP_A));
assert!(!moved, "a campaign reached the {status} directory");
}
}
/// Every command that takes a ticket gives the same explanation, because the refusal is
/// in resolution rather than in `mv`.
#[test]
fn a_campaign_is_refused_wherever_a_ticket_is_expected() {
for args in [
vec!["show", "v1 release"],
vec!["comment", "v1 release", "A note."],
vec!["chown", "bob", "v1 release"],
] {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
let out = run(&temp, &args);
assert!(!out.status.success(), "{args:?}");
assert!(
stderr(&out).contains("is a campaign, not a ticket"),
"{args:?}: {}",
stderr(&out)
);
}
}
/// A search that names neither still says nothing was found, rather than complaining
/// about a directory the caller never mentioned.
#[test]
fn a_search_that_names_nothing_still_reports_no_ticket() {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
let out = run(&temp, &["show", "nothing at all"]);
assert!(!out.status.success());
assert!(
stderr(&out).contains("No ticket found matching"),
"{}",
stderr(&out)
);
}
/// A campaign resolves by the same tiers a ticket does, so it can be ambiguous the same
/// way, and the listing has to name campaigns rather than tickets.
#[test]
fn an_ambiguous_campaign_lists_the_candidates() {
let temp = TempDir::new().unwrap();
let _worklane = board(&temp);
let out = run(&temp, &["campaign", "show", "release"]);
assert!(!out.status.success());
let message = stderr(&out);
assert!(message.contains("Multiple campaigns found matching"), "{message}");
assert!(message.contains("v1 release"), "{message}");
assert!(message.contains("v2 release"), "{message}");
}
+233
View File
@@ -645,3 +645,236 @@ fn mv_moves_the_resolved_ticket_when_two_share_a_title() {
vec!["11111111-aaaa-bbbb-cccc-dddddddddddd_foo.md".to_string()]
);
}
// --------------------------------------------------------------- blocked by --
/// A ticket waiting on another, and a second one for it to wait on. Returns the
/// filename of the gated ticket, whose relations the moves are then checked against.
fn create_gated_pair(worklane: &std::path::Path, temp: &TempDir, status: &str) -> String {
let filename = create_ticket(
worklane,
status,
"Gated Task",
"Waits on the blocker.",
"aaaa1111aaaa1111aaaa1111aaaa1111aaaa",
"alice",
"_Not set_",
"test",
);
create_ticket(
worklane,
"backlog",
"The Blocker",
"Nothing waits on this.",
"bbbb2222bbbb2222bbbb2222bbbb2222bbbb",
"bob",
"_Not set_",
"test",
);
// Through the command, so the fixture cannot store a relation in a shape the tool
// does not actually write.
Command::cargo_bin(BIN_NAME)
.unwrap()
.current_dir(temp.path())
.args(["relate", "aaaa1111", "--blocked-by", "bbbb2222"])
.assert()
.success();
filename
}
fn move_ticket(temp: &TempDir, ticket: &str, status: &str, force: bool) -> std::process::Output {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["mv", ticket, "--status", status]);
if force {
cmd.arg("-f");
}
cmd.assert().get_output().clone()
}
/// Refused, and nothing written: not the rename, not the Status field, not a stray
/// temp file. The blocker is named with its status, since that is what has to change.
#[test]
fn mv_refuses_a_move_while_a_blocker_is_open() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = create_gated_pair(&worklane, &temp, "backlog");
let before = fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap();
let out = move_ticket(&temp, "aaaa1111", "committed", false);
assert!(!out.status.success());
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("blocked by"), "{stderr}");
assert!(stderr.contains("The Blocker"), "{stderr}");
assert!(stderr.contains("backlog"), "{stderr}");
assert!(stderr.contains("--force"), "{stderr}");
assert!(worklane.join("backlog").join(&filename).exists());
assert_eq!(md_files(&worklane.join("committed")).len(), 0);
assert_eq!(
fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap(),
before,
"a refused move rewrote the ticket"
);
assert_eq!(stray_files(&worklane), Vec::<String>::new());
}
/// Every open blocker, not the first: clearing the one the message happened to name
/// would leave the ticket blocked and the reader surprised.
#[test]
fn mv_names_every_open_blocker() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_gated_pair(&worklane, &temp, "backlog");
create_ticket(
&worklane,
"reviewing",
"The Second Blocker",
"Also not done.",
"cccc3333cccc3333cccc3333cccc3333cccc",
"bob",
"_Not set_",
"test",
);
Command::cargo_bin(BIN_NAME)
.unwrap()
.current_dir(temp.path())
.args(["relate", "aaaa1111", "--blocked-by", "cccc3333"])
.assert()
.success();
let out = move_ticket(&temp, "aaaa1111", "committed", false);
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("The Blocker"), "{stderr}");
assert!(stderr.contains("The Second Blocker"), "{stderr}");
}
/// `-f` is where the deliberate overrides live, beside the backward and skipping moves.
#[test]
fn mv_moves_a_blocked_ticket_with_force() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = create_gated_pair(&worklane, &temp, "backlog");
let out = move_ticket(&temp, "aaaa1111", "committed", true);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert!(worklane.join("committed").join(&filename).exists());
}
#[test]
fn mv_allows_the_move_once_the_blocker_is_done() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = create_gated_pair(&worklane, &temp, "backlog");
for status in ["committed", "reviewing", "done"] {
assert!(
move_ticket(&temp, "bbbb2222", status, false).status.success(),
"the blocker itself could not be moved to {status}"
);
}
let out = move_ticket(&temp, "aaaa1111", "committed", false);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert!(worklane.join("committed").join(&filename).exists());
}
/// Every move, not only the one into committed. An open blocker is a reason not to
/// finish as much as a reason not to start.
#[test]
fn mv_checks_the_blockers_on_every_move() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = create_gated_pair(&worklane, &temp, "reviewing");
let out = move_ticket(&temp, "aaaa1111", "done", false);
assert!(!out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert!(worklane.join("reviewing").join(&filename).exists());
}
/// A move to the status the ticket is already in is not a move, so it is reported the
/// way it always was rather than refused.
#[test]
fn mv_does_not_check_the_blockers_on_a_no_op() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_gated_pair(&worklane, &temp, "backlog");
let out = move_ticket(&temp, "aaaa1111", "backlog", false);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert!(String::from_utf8_lossy(&out.stdout).contains("already in"));
}
/// A dangling target is a bookkeeping fault, not a dependency. Refusing there would
/// wedge the ticket with no way out but `--force`.
#[test]
fn mv_warns_and_allows_when_a_blocker_is_not_on_the_board() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = create_gated_pair(&worklane, &temp, "backlog");
fs::remove_file(
worklane
.join("backlog")
.join("bbbb2222bbbb2222bbbb2222bbbb2222bbbb_the-blocker.md"),
)
.unwrap();
let out = move_ticket(&temp, "aaaa1111", "committed", false);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert!(
String::from_utf8_lossy(&out.stderr).contains("not on the board"),
"{}",
String::from_utf8_lossy(&out.stderr)
);
assert!(worklane.join("committed").join(&filename).exists());
}
/// Only `blocked by` gates a move. The other two kinds are reference data.
#[test]
fn mv_ignores_the_kinds_that_are_not_blockers() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
let filename = create_ticket(
&worklane,
"backlog",
"Related Task",
"Points at an open ticket.",
"aaaa1111aaaa1111aaaa1111aaaa1111aaaa",
"alice",
"_Not set_",
"test",
);
create_ticket(
&worklane,
"backlog",
"The Other",
"Still open.",
"bbbb2222bbbb2222bbbb2222bbbb2222bbbb",
"bob",
"_Not set_",
"test",
);
Command::cargo_bin(BIN_NAME)
.unwrap()
.current_dir(temp.path())
.args([
"relate",
"aaaa1111",
"--regression-of",
"bbbb2222",
"--relates-to",
"bbbb2222",
])
.assert()
.success();
let out = move_ticket(&temp, "aaaa1111", "committed", false);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
assert!(worklane.join("committed").join(&filename).exists());
}
+358
View File
@@ -0,0 +1,358 @@
use assert_cmd::Command;
use assert_fs::TempDir;
use assert_fs::fixture::{PathChild, PathCreateDir};
use std::fs;
use std::path::{Path, PathBuf};
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
/// The ticket under edit, the one it points at, and one that is already done.
const GATED: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
const BLOCKER: &str = "b1b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d";
const FIXED: &str = "f1f2f3f4-5a6b-4c7d-8e9f-0a1b2c3d4e5f";
fn setup_worklane(temp: &TempDir) -> PathBuf {
let worklane = temp.child(".worklane");
worklane.create_dir_all().unwrap();
for dir in ["backlog", "committed", "reviewing", "done"] {
worklane.child(dir).create_dir_all().unwrap();
}
worklane.path().to_path_buf()
}
fn slug(title: &str) -> String {
title
.to_lowercase()
.chars()
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
.map(|c| if c == ' ' { '-' } else { c })
.collect()
}
/// A ticket with a ticked criterion and a section the tool knows nothing about, so
/// every test can check that recording a relation leaves both exactly as they were.
fn create_ticket(worklane: &Path, status: &str, title: &str, uuid: &str) -> PathBuf {
let path = worklane
.join(status)
.join(format!("{}_{}.md", uuid, slug(title)));
fs::write(
&path,
format!(
"# {}\n\
\n\
## Description\n\
Prose.\n\
\n\
## Acceptance Criteria\n\
- [x] Crit one\n\
\n\
## Implementation Plan\n\
1. Step one\n\
\n\
## Notes\n\
A handwritten note the tool knows nothing about.\n\
\n\
## Metadata\n\
\n\
- **ID**: {}\n\
- **Priority**: 3\n\
- **Tags**: alpha\n\
- **Due**: _Not set_\n\
- **Owner**: alice\n\
- **Created At**: 2026-08-21 02:10:17\n\
- **Status**: {}\n",
title, uuid, status
),
)
.unwrap();
path
}
/// The three tickets every test starts from: the one being edited, one it can wait on,
/// and one in done.
fn board(temp: &TempDir) -> PathBuf {
let worklane = setup_worklane(temp);
create_ticket(&worklane, "backlog", "The gated one", GATED);
create_ticket(&worklane, "backlog", "The blocker", BLOCKER);
create_ticket(&worklane, "done", "The old fix", FIXED);
worklane
}
fn run(temp: &TempDir, args: &[&str]) -> std::process::Output {
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(args);
cmd.assert().get_output().clone()
}
fn stdout(out: &std::process::Output) -> String {
String::from_utf8_lossy(&out.stdout).to_string()
}
fn find(worklane: &Path, uuid: &str) -> PathBuf {
for status in ["backlog", "committed", "reviewing", "done"] {
let dir = worklane.join(status);
for entry in fs::read_dir(&dir).unwrap().filter_map(|e| e.ok()) {
if entry.file_name().to_string_lossy().starts_with(uuid) {
return entry.path();
}
}
}
panic!("no file for ticket {uuid}");
}
fn ticket(worklane: &Path, uuid: &str) -> String {
fs::read_to_string(find(worklane, uuid)).unwrap()
}
/// All three tiers, since the target is a ticket argument like any other: a uuid
/// prefix, a title substring, and a substring reaching the middle of the filename.
#[test]
fn a_target_resolves_by_uuid_prefix_title_or_filename() {
for search in ["b1b2", "blocker", "4a7b"] {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let out = run(&temp, &["relate", GATED, "--blocked-by", search]);
assert!(
out.status.success(),
"{search}: {}",
String::from_utf8_lossy(&out.stderr)
);
assert!(
ticket(&worklane, GATED).contains(&format!("- blocked by {}", BLOCKER)),
"{search}: {}",
ticket(&worklane, GATED)
);
}
}
#[test]
fn every_kind_is_recorded_under_its_own_label() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let out = run(
&temp,
&[
"relate",
GATED,
"--blocked-by",
BLOCKER,
"--regression-of",
FIXED,
"--relates-to",
"old fix",
],
);
assert!(out.status.success());
let content = ticket(&worklane, GATED);
assert!(content.contains(&format!("- blocked by {}", BLOCKER)), "{content}");
assert!(content.contains(&format!("- regression of {}", FIXED)), "{content}");
assert!(content.contains(&format!("- relates to {}", FIXED)), "{content}");
// Each kind named once in the report, whatever the order of the flags.
let reported = stdout(&out);
for kind in ["blocked by", "regression of", "relates to"] {
assert!(reported.contains(kind), "{reported}");
}
}
/// The kinds are flags, so anything else never reaches the file: clap refuses it with
/// a usage error, exit code 2, and nothing is written.
#[test]
fn an_unknown_kind_is_a_usage_error() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let before = ticket(&worklane, GATED);
let out = run(&temp, &["relate", GATED, "--depends-on", BLOCKER]);
assert_eq!(out.status.code(), Some(2), "{}", stdout(&out));
assert_eq!(ticket(&worklane, GATED), before);
}
/// A bare `relate <ticket>` is a usage error too, not a silent no-op, the same way a
/// bare `set` and a bare `append` are.
#[test]
fn a_relate_with_no_kind_is_a_usage_error() {
let temp = TempDir::new().unwrap();
board(&temp);
assert_eq!(run(&temp, &["relate", GATED]).status.code(), Some(2));
}
/// Between the plan and the metadata, created for a ticket written before the section
/// existed, and behind a handwritten section rather than in front of it.
#[test]
fn the_section_is_created_in_its_place() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
let content = ticket(&worklane, GATED);
let at = |heading: &str| content.find(heading).unwrap_or_else(|| panic!("{heading}"));
assert!(at("## Implementation Plan") < at("## Relations"), "{content}");
assert!(at("## Notes") < at("## Relations"), "{content}");
assert!(at("## Relations") < at("## Metadata"), "{content}");
}
/// The full uuid, not the seven characters `ls` prints, which is what makes the link
/// survive a rename of the target and stay unambiguous as the board grows.
#[test]
fn the_stored_target_is_the_full_uuid() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
assert!(
ticket(&worklane, GATED).contains(&format!("- blocked by {}\n", BLOCKER)),
"{}",
ticket(&worklane, GATED)
);
run(&temp, &["set", BLOCKER, "--title", "Renamed entirely"]);
let shown = stdout(&run(&temp, &["show", GATED]));
assert!(shown.contains("Renamed entirely"), "{shown}");
}
#[test]
fn a_ticket_cannot_relate_to_itself() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let before = ticket(&worklane, GATED);
let out = run(&temp, &["relate", GATED, "--relates-to", "gated"]);
assert!(!out.status.success());
assert!(
String::from_utf8_lossy(&out.stderr).contains("cannot relate to itself"),
"{}",
String::from_utf8_lossy(&out.stderr)
);
assert_eq!(ticket(&worklane, GATED), before);
}
#[test]
fn a_relation_already_held_reports_no_change_and_writes_nothing() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
let before = ticket(&worklane, GATED);
let out = run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
assert!(out.status.success());
assert!(stdout(&out).contains("No changes"), "{}", stdout(&out));
assert_eq!(
ticket(&worklane, GATED),
before,
"the relation was recorded twice"
);
}
/// One direction is stored. The inverse is derived by a scan, so the ticket at the
/// other end is not touched at all.
#[test]
fn only_the_ticket_named_is_written() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let before = ticket(&worklane, BLOCKER);
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
assert_eq!(ticket(&worklane, BLOCKER), before);
assert!(!ticket(&worklane, BLOCKER).contains("Relations"));
}
/// The tick, the handwritten section and the prose are what a regenerated file would
/// lose, and the section is spliced in rather than rewritten around them.
#[test]
fn relate_leaves_everything_it_was_not_asked_about_alone() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
let content = ticket(&worklane, GATED);
assert!(content.contains("- [x] Crit one"), "the tick was lost: {content}");
assert!(
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
"the unknown section was lost: {content}"
);
assert!(content.contains("1. Step one"), "{content}");
assert!(content.contains("- **Owner**: alice"), "{content}");
}
/// The kind, the short id and the title, so the section reads without a second lookup.
#[test]
fn show_renders_the_kind_the_short_id_and_the_title() {
let temp = TempDir::new().unwrap();
board(&temp);
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
let shown = stdout(&run(&temp, &["show", GATED]));
assert!(shown.contains("Relations"), "{shown}");
assert!(shown.contains("blocked by (b1b2c3d) The blocker"), "{shown}");
// Never the stored line: a bare uuid says nothing about what it points at.
assert!(!shown.contains(BLOCKER), "{shown}");
}
/// Derived by scanning, since the file at this end holds nothing at all.
#[test]
fn show_lists_the_relation_the_other_ticket_holds() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
run(&temp, &["relate", GATED, "--relates-to", FIXED]);
let shown = stdout(&run(&temp, &["show", BLOCKER]));
assert!(shown.contains("blocks (641e3d5) The gated one"), "{shown}");
assert!(!ticket(&worklane, BLOCKER).contains("Relations"));
// `relates to` is symmetric, so it reads the same way from either end.
let shown = stdout(&run(&temp, &["show", FIXED]));
assert!(shown.contains("relates to (641e3d5) The gated one"), "{shown}");
}
#[test]
fn a_target_that_no_longer_exists_renders_as_missing() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
fs::remove_file(find(&worklane, BLOCKER)).unwrap();
let shown = stdout(&run(&temp, &["show", GATED]));
assert!(shown.contains("blocked by (b1b2c3d) _missing_"), "{shown}");
}
/// The section is the one part of a ticket read back by machine, so a line nobody can
/// parse is an error naming the ticket rather than a line quietly skipped.
#[test]
fn a_line_that_is_not_a_relation_is_an_error() {
let temp = TempDir::new().unwrap();
let worklane = board(&temp);
let path = find(&worklane, GATED);
let content = fs::read_to_string(&path)
.unwrap()
.replace(
"## Metadata",
&format!("## Relations\n- depends on {}\n\n## Metadata", BLOCKER),
);
fs::write(&path, content).unwrap();
let out = run(&temp, &["show", GATED]);
assert!(!out.status.success());
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("is not a relation"), "{stderr}");
assert!(stderr.contains("The gated one"), "{stderr}");
}