Let check and uncheck take several criteria, and bump to 0.16.0

Finishing a ticket means ticking every box, and that was one invocation per
box: each one resolved the ticket, spliced one line and rewrote the file.

The criterion positional is now variadic, so numbers and substrings mix in a
single call, and `all` stands for every criterion on the ticket. `all` is a
keyword checked before the text, the way the index already is, so a criterion
whose own words include "all" is reached by its number or by a longer
substring. `is_all_criteria` sits beside `is_index` for that reason.

`resolve_criteria` resolves every term before a byte is written and refuses the
whole batch on the first term it cannot place, naming it. A call that ticked
what it understood and then failed would leave the ticket half-marked with
nothing in the file to say which half was meant. The offsets are sorted and
deduped, so the report reads in `show`'s order and a criterion named twice, or
by both `all` and its number, is marked once. `set_criterion` becomes
`set_criteria` and takes every line in one pass.

Each named criterion gets a line, printed after the write. One already in the
target state reads `Already checked 2: text` and does not count towards the
write, so a batch where every box is already ticked writes nothing.

The opencode wrapper takes the terms one per line, like the other list
arguments. REVIEW.md gains the one thing a reviewer must not do with this:
reach for `all`, which would erase the implementer's claim on the criteria the
review agreed with.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-22 16:30:40 +02:00
co-authored by Claude Opus 5
parent ae3ee1bb9e
commit 6784d80324
11 changed files with 452 additions and 80 deletions
+11 -5
View File
@@ -185,10 +185,10 @@ pub enum Command {
paths: Vec<std::path::PathBuf>,
},
/// Tick an acceptance criterion
/// Tick acceptance criteria
Check(CheckArgs),
/// Untick an acceptance criterion
/// Untick acceptance criteria
Uncheck(CheckArgs),
/// Add a comment to a ticket
@@ -452,14 +452,20 @@ impl RelateArgs {
/// because the two read as opposites at the call site and neither needs the other's
/// name to make sense.
///
/// The criterion is optional: without it the criteria are listed and the index asked
/// The criteria are optional: without any the criteria are listed and the index asked
/// for, or, where there is no terminal to ask at, returned as an error carrying the
/// same list.
///
/// Several terms in one call because finishing a ticket means ticking every box, and
/// one invocation per box resolved the ticket and rewrote the file each time. The
/// terms are variadic rather than a repeated flag: they address something that is
/// already there, the way the ticket positional does, instead of carrying content the
/// way `--acceptance` does.
#[derive(clap::Args)]
pub struct CheckArgs {
/// Ticket UUID or title
pub ticket: String,
/// Criterion index as shown by `show`, or a substring of its text. Prompts if omitted
pub criterion: Option<String>,
/// Criterion indexes as shown by `show`, substrings of their text, or `all`. Prompts if omitted
pub criteria: Vec<String>,
}
+98 -52
View File
@@ -1153,6 +1153,66 @@ fn ask_which_criterion(criteria: &[Criterion], title: &str) -> Result<usize> {
}
}
/// Every criterion the terms name, in the order `show` numbers them and without
/// repeats.
///
/// Resolved before a byte is written, and one bad term refuses the whole batch. A call
/// that ticked the terms it understood and then failed would leave the ticket
/// half-marked, with nothing in the file to say which half the caller meant, and the
/// obvious retry would be reading the ticket back to find out.
///
/// The offending term is named on its own rather than every failure at once: each
/// message carries the criteria listing, so a batch of them would repeat the list per
/// bad term and bury the first one.
fn resolve_criteria(criteria: &[Criterion], terms: &[String], title: &str) -> Result<Vec<usize>> {
let mut chosen: Vec<usize> = Vec::new();
for term in terms {
if is_all_criteria(term) {
chosen.extend(0..criteria.len());
continue;
}
let found = find_criteria(criteria, term);
match found.len() {
1 => chosen.push(found[0]),
0 if is_index(term) => {
return Err(anyhow!(
"'{}' is not one of the {} criteria of '{}':\n{}",
term.trim(),
criteria.len(),
title,
criteria_list(criteria)
));
}
0 => {
return Err(anyhow!(
"No criterion of '{}' matches '{}'. Its criteria are:\n{}",
title,
term,
criteria_list(criteria)
));
}
_ => {
return Err(anyhow!(
"'{}' matches {} criteria of '{}':\n{}\n\nUse the number instead.",
term,
found.len(),
title,
numbered_criteria(criteria, &found)
));
}
}
}
// Sorted so the report reads in the order `show` numbers the criteria whatever
// order the terms arrived in, and deduped so a criterion named twice, or by both
// `all` and its own number, is reported once.
chosen.sort_unstable();
chosen.dedup();
Ok(chosen)
}
pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
let worklane_dir = find_worklane_dir(start)?;
let (status, title, content) = resolve_ticket(&args.ticket, &worklane_dir)?;
@@ -1162,64 +1222,50 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
return Err(anyhow!("Ticket '{}' has no acceptance criteria", title));
}
let chosen = match &args.criterion {
None => ask_which_criterion(&criteria, &title)?,
Some(search) => {
let found = find_criteria(&criteria, search);
match found.len() {
1 => found[0],
0 if is_index(search) => {
return Err(anyhow!(
"'{}' is not one of the {} criteria of '{}':\n{}",
search.trim(),
criteria.len(),
title,
criteria_list(&criteria)
));
}
0 => {
return Err(anyhow!(
"No criterion of '{}' matches '{}'. Its criteria are:\n{}",
title,
search,
criteria_list(&criteria)
));
}
_ => {
return Err(anyhow!(
"'{}' matches {} criteria of '{}':\n{}\n\nUse the number instead.",
search,
found.len(),
title,
numbered_criteria(&criteria, &found)
));
}
}
}
let chosen = match args.criteria.as_slice() {
[] => vec![ask_which_criterion(&criteria, &title)?],
terms => resolve_criteria(&criteria, terms, &title)?,
};
let criterion = &criteria[chosen];
let verb = if checked { "checked" } else { "unchecked" };
// Only the criteria that are not already in the target state, so a batch where
// every box is already ticked writes nothing, the way a single one always has.
let changing: Vec<usize> = chosen
.iter()
.copied()
.filter(|offset| criteria[*offset].checked != checked)
.collect();
if criterion.checked == checked {
println!(
"Already {}: {}",
verb,
color_text(&criterion.text, Color::Green)
);
return Ok(());
if !changing.is_empty() {
let lines: Vec<usize> = changing
.iter()
.map(|offset| criteria[*offset].line)
.collect();
let updated = set_criteria(&content, &lines, checked);
let uuid = parse_ticket_field(&content, "ID");
save_ticket(&worklane_dir, &status, &uuid, &title, None, &updated)?;
}
let updated = set_criterion(&content, criterion.line, checked);
let uuid = parse_ticket_field(&content, "ID");
save_ticket(&worklane_dir, &status, &uuid, &title, None, &updated)?;
// Reported after the write, one line per criterion the call named, so nothing
// claims a mark the file does not carry.
let verb = if checked { "checked" } else { "unchecked" };
let past = if checked { "Checked" } else { "Unchecked" };
for offset in chosen {
let criterion = &criteria[offset];
let state = if criterion.checked == checked {
format!("Already {}", verb)
} else {
past.to_string()
};
println!(
"{} {}: {}",
state,
offset + 1,
color_text(&criterion.text, Color::Green)
);
}
println!(
"{} {}: {}",
if checked { "Checked" } else { "Unchecked" },
chosen + 1,
color_text(&criterion.text, Color::Green)
);
Ok(())
}
+20 -3
View File
@@ -2071,6 +2071,19 @@ pub fn is_index(search: &str) -> bool {
search.trim().parse::<usize>().is_ok()
}
/// Whether `search` is the keyword standing for every criterion.
///
/// Checked before `find_criteria`, the way the index is checked before the substring,
/// so a criterion whose text contains "all" is reachable only by its number or by a
/// different substring. The keyword wins because ticking every box is the reason the
/// word is typed, and a board where `all` sometimes means one criterion and sometimes
/// means the lot would be worse than one that can be addressed another way.
///
/// Case-insensitive, like the substring match it stands beside.
pub fn is_all_criteria(search: &str) -> bool {
search.trim().eq_ignore_ascii_case("all")
}
/// Which criterion `search` names: a one-based index as `show` prints, or a
/// case-insensitive substring of the text.
///
@@ -2096,16 +2109,20 @@ pub fn find_criteria(criteria: &[Criterion], search: &str) -> Vec<usize> {
.collect()
}
/// Tick or untick the criterion on `line`, leaving every other byte alone.
/// Tick or untick the criteria on `lines`, leaving every other byte alone.
///
/// Only the character between the brackets is spliced. Rebuilding the line would
/// normalise its indentation and whatever spacing it carried after the checkbox.
pub fn set_criterion(content: &str, line: usize, checked: bool) -> String {
///
/// Every line in one pass, so a batch is one rewrite and one save rather than one of
/// each per criterion. `lines` is searched rather than indexed because a ticket holds
/// a handful of criteria, and a set would only move the cost somewhere else.
pub fn set_criteria(content: &str, lines: &[usize], checked: bool) -> String {
let mark = if checked { 'x' } else { ' ' };
let mut out = String::with_capacity(content.len());
for (index, current) in content.lines().enumerate() {
match (index == line, current.find("- [")) {
match (lines.contains(&index), current.find("- [")) {
(true, Some(at)) => {
let opens = at + "- [".len();
out.push_str(&current[..opens]);