(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>
This commit is contained in:
Ansho Rei
2026-08-22 00:52:57 +02:00
co-authored by Claude Opus 5
parent 41a65f95b2
commit 5b0bac9c2d
11 changed files with 1694 additions and 84 deletions
+196 -6
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, RelateArgs, 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 {
@@ -304,14 +344,14 @@ pub fn cmd_show(search: &str, worklane_dir: &Path) -> Result<()> {
let ticket_uuid = parse_ticket_field(&content, "ID");
// Read before anything is printed, so a board that cannot be read fails instead of
// half printing a ticket.
let relations = relations_block(&content, worklane_dir, should_use_colors())?;
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, &relations));
println!("\n{}", content_trim_colored(&content, &resolved));
if ticket_uuid != "_Not set_" {
let comments_dir = worklane_dir.join("comments").join(&ticket_uuid);
@@ -883,6 +923,156 @@ pub fn cmd_relate(args: &RelateArgs, start: &Path) -> Result<()> {
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