(eadaca9) Add check and uncheck for one acceptance criterion, and bump to 0.6.0

Criteria are stored as - [ ] lines and nothing could tick one, so marking
progress meant replacing the whole list through set, losing the state of every
other item.

check and uncheck are separate commands rather than one verb with a flag,
sharing CheckArgs and cmd_check. The criterion is an index first and a substring
second, so a criterion whose text is literally "2" is reachable only by
substring. A number out of range is reported as a bad index rather than as a
substring that missed.

Only the character between the brackets is spliced, so the text keeps whatever
indentation and spacing it had. Criteria are counted inside the Acceptance
Criteria section only, so a checkbox written into a description is not a
criterion and a handwritten line in the section takes no number.

With the criterion omitted, the criteria are listed and the number asked for
when stdin is a terminal. Where it is not, the same list comes back as an error
instead. Prompting regardless would leave the opencode wrapper blocked on a
stdin that never closes, and that is the choice resolve_ticket already makes for
an ambiguous match, for the same reason: the wrapper keeps stderr and throws on
the code, so a list printed to stdout would be discarded.

Any listing of a subset keeps the real numbers. Renumbering the matches from one
would contradict the advice to use the number and point at the wrong criterion.

show now numbers the criteria as "1. [x] text", so the index is visible where
the ticket is read. That also drops a manual prefix strip, so clippy is one
warning below where it started.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-21 10:46:07 +02:00
co-authored by Claude Opus 5
parent 3810e442c6
commit bbb1568a0f
11 changed files with 674 additions and 9 deletions
+120 -2
View File
@@ -1,10 +1,10 @@
use anyhow::{Result, anyhow};
use chrono::Local;
use std::fs;
use std::io::Write;
use std::io::{BufRead, IsTerminal, Write};
use std::path::Path;
use crate::command::{AppendArgs, SetArgs};
use crate::command::{AppendArgs, CheckArgs, SetArgs};
use crate::util::*;
pub fn cmd_init(start: &Path) -> Result<()> {
@@ -749,3 +749,121 @@ pub fn cmd_append(args: &AppendArgs, start: &Path) -> Result<()> {
report(&changed, &title, "Appended to");
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
/// error, which is what `resolve_ticket` does for an ambiguous match and for the same
/// reason: the opencode wrapper throws on the exit code and keeps stderr, so a list
/// printed to stdout would be discarded and an agent would learn nothing. Prompting
/// regardless would leave it blocked on a stdin that never closes.
fn ask_which_criterion(criteria: &[Criterion], title: &str) -> Result<usize> {
let listing = criteria_list(criteria);
if !std::io::stdin().is_terminal() {
return Err(anyhow!(
"Which criterion of '{}'?\n{}\n\nRe-run with the number, or a substring of the text.",
title,
listing
));
}
println!("Acceptance criteria of '{}':", color_text(title, "green"));
println!("{}", listing);
// Either form, since find_criteria takes both.
print!("Number or text: ");
std::io::stdout().flush()?;
let mut answer = String::new();
std::io::stdin().lock().read_line(&mut answer)?;
// An empty needle matches every criterion, so it would otherwise be reported as
// ambiguous rather than as nothing having been chosen.
if answer.trim().is_empty() {
return Err(anyhow!("No criterion chosen"));
}
let chosen = find_criteria(criteria, &answer);
match chosen.len() {
1 => Ok(chosen[0]),
0 => Err(anyhow!(
"'{}' matches none of the {} criteria",
answer.trim(),
criteria.len()
)),
_ => Err(anyhow!(
"'{}' matches more than one criterion, use the number",
answer.trim()
)),
}
}
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)?;
let criteria = criteria(&content);
if criteria.is_empty() {
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 criterion = &criteria[chosen];
let verb = if checked { "checked" } else { "unchecked" };
if criterion.checked == checked {
println!(
"Already {}: {}",
verb,
color_text(&criterion.text, "green")
);
return Ok(());
}
let updated = set_criterion(&content, criterion.line, checked);
let uuid = parse_ticket_field(&content, "ID");
save_ticket(&worklane_dir, &status, &uuid, &title, None, &updated)?;
println!(
"{} {}: {}",
if checked { "Checked" } else { "Unchecked" },
chosen + 1,
color_text(&criterion.text, "green")
);
Ok(())
}