(d4ce964) Record status, owner and tag changes in a history log, and bump to 0.29.0

The comments directory was already an append-only log with one event
kind. It is now .worklane/history/<uuid>/, with the kind in the entry
and in the filename after the stamp, so a ticket says how it got where
it is and not only what was said about it.

mv, chown and set --tags each write an entry after their own save and
behind their own no-change return, so a refused or no-op edit records
nothing. --actor is on all four writers now. An old comments directory
is adopted on first access and a file with no marker reads as the
comment it is, so nothing is migrated or rewritten.

The log moves to src/history.rs, out of util.rs and handlers.rs, and
the card's counter counts comments only: a ticket that has moved three
times has not been talked about.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-24 13:19:09 +02:00
co-authored by Claude Opus 5
parent a1bdb5df49
commit f454d212a4
18 changed files with 1249 additions and 306 deletions
+20 -4
View File
@@ -180,6 +180,12 @@ fn annotation_line(raw: &str) -> Result<String, String> {
}
}
/// What `--actor` says on every command that writes a history entry.
///
/// One string, so the four spell it the same: a flag documented differently on each
/// command reads as four flags.
const ACTOR_HELP: &str = "Who the entry is attributed to, overriding WORKLANE_ACTOR and the git user. Free text, checked against nothing";
/// Arguments that carry prose, and therefore have to accept a value starting with
/// a hyphen.
///
@@ -221,6 +227,9 @@ pub enum Command {
/// Force move (allows backward or non-sequential moves)
#[arg(short, long)]
force: bool,
#[arg(long, help = ACTOR_HELP)]
actor: Option<String>,
},
/// Replace fields on an existing ticket
@@ -267,12 +276,9 @@ pub enum Command {
#[arg(allow_hyphen_values = PROSE)]
body: String,
/// Who the comment is attributed to, overriding `WORKLANE_ACTOR` and the git
/// user. Free text, checked against nothing
///
/// Named after the writer of the entry, not after the ticket's assignee, which
/// is `chown`'s. It was `--owner`, which said the wrong one of the two.
#[arg(long)]
#[arg(long, help = ACTOR_HELP)]
actor: Option<String>,
},
@@ -732,6 +738,11 @@ pub struct SetArgs {
/// is `chown --clear`'s. The reasoning for each is on `util::Clearable`.
#[arg(long, value_name = "FIELD")]
pub clear: Vec<Clearable>,
/// Only reaches the entry `--tags` writes, since that is the one field of this
/// command's that is logged
#[arg(long, help = ACTOR_HELP)]
pub actor: Option<String>,
}
impl SetArgs {
@@ -777,6 +788,11 @@ pub struct ChownArgs {
/// user to name
#[arg(long, value_name = "TICKET", value_parser = non_empty)]
pub clear: Option<String>,
/// Not the same as `user`, which is the ticket's new assignee: this is who made the
/// change. Both are on this command because it writes both.
#[arg(long, help = ACTOR_HELP)]
pub actor: Option<String>,
}
impl ChownArgs {
+57 -140
View File
@@ -10,6 +10,7 @@ use crate::command::{
AddArgs, AppendArgs, CampaignAddArgs, CampaignAppendArgs, CampaignSetArgs, CheckArgs,
ChownArgs, LsArgs, RelateArgs, SetArgs, TagAddArgs, TagSetArgs,
};
use crate::history::{Kind, change, format_history, read_history, write_entry};
use crate::install;
use crate::tag::{TAGS_FILE, TagIndex, tags_path};
use crate::util::*;
@@ -351,93 +352,6 @@ pub fn cmd_add(args: &AddArgs, start: &Path) -> Result<()> {
Ok(())
}
/// Public for the TUI's detail view, which shows the same comments `show` does.
pub fn read_comments(comments_dir: &Path) -> Result<Vec<(String, String, String, String)>> {
if !comments_dir.exists() {
return Ok(vec![]);
}
let mut comments: Vec<(String, String, String, String)> = Vec::new();
for entry in fs::read_dir(comments_dir)? {
let entry = entry?;
let path = entry.path();
if path.extension().is_some_and(|e| e == "md") {
let content = fs::read_to_string(&path)?;
let filename = path
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_default();
let author = content
.lines()
.find(|l| l.starts_with("**Author**"))
.and_then(|l| l.split_once("**Author**:"))
.map(|(_, value)| value)
.map(|s| s.trim().to_string())
.unwrap_or_else(|| "unknown".to_string());
let time = content
.lines()
.find(|l| l.starts_with("**Time**"))
.and_then(|l| l.split_once("**Time**:"))
.map(|(_, value)| value)
.map(|s| s.trim().to_string())
.unwrap_or_else(|| "unknown".to_string());
let body = if let Some(after_comment) = content.strip_prefix("**Comment**\n") {
if let Some(end) = after_comment.find("\n\n**Author**") {
after_comment[..end].trim()
} else {
after_comment.trim()
}
} else {
""
};
comments.push((filename, author, time, body.to_string()));
}
}
comments.sort_by(|a, b| a.0.cmp(&b.0));
Ok(comments)
}
/// Write a comment under the first free name derived from `stem`.
///
/// `create_new` rather than `fs::write`: a name that already exists means another
/// comment landed in the same microsecond, and truncating it is exactly the data
/// loss this guards against. The suffix is zero padded so the names keep sorting
/// in the order they were written.
fn write_new_comment(comments_dir: &Path, stem: &str, content: &str) -> Result<String> {
for attempt in 0..100 {
let filename = match attempt {
0 => format!("{}.md", stem),
n => format!("{}_{:02}.md", stem, n),
};
match fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(comments_dir.join(&filename))
{
Ok(mut file) => {
file.write_all(content.as_bytes())?;
return Ok(filename);
}
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,
Err(e) => return Err(e.into()),
}
}
Err(anyhow!(
"No free comment filename for '{}' in {}",
stem,
comments_dir.display()
))
}
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");
@@ -453,9 +367,8 @@ pub fn cmd_show(search: &str, worklane_dir: &Path) -> Result<()> {
println!("\n{}", content_trim_colored(&content, &resolved));
if ticket_uuid != "_Not set_" {
let comments_dir = comments_dir(worklane_dir, &ticket_uuid);
let comments = read_comments(&comments_dir)?;
let formatted = format_comments(&comments);
let entries = read_history(worklane_dir, &ticket_uuid)?;
let formatted = format_history(&entries);
println!("{}", formatted);
}
@@ -642,7 +555,13 @@ fn check_blockers(worklane_dir: &Path, content: &str, title: &str) -> Result<()>
/// A status is a [`Status`] rather than a string, so an unknown one is clap's to refuse
/// and nothing here has to check. What is left is the order of the flow, which is
/// `Status::ALL`.
pub fn cmd_mv(ticket_id: &str, target: Status, force: bool, start: &Path) -> Result<()> {
pub fn cmd_mv(
ticket_id: &str,
target: Status,
force: bool,
actor: &Option<String>,
start: &Path,
) -> Result<()> {
let target_status = target.as_str();
let worklane_dir = find_worklane_dir(start)?;
@@ -712,6 +631,17 @@ pub fn cmd_mv(ticket_id: &str, target: Status, force: bool, start: &Path) -> Res
&title,
)?;
// After the move, never before: an entry for a move that was refused would be a log
// of things that did not happen. The no-op above returns without one for the same
// reason.
write_entry(
&worklane_dir,
&parse_ticket_field(&resolved, "ID"),
Kind::Status,
&change(&current_status, target_status),
&resolve_actor(actor.as_deref()),
)?;
println!(
"Moved ticket '{}' from {} to {}",
color_text(&title, Color::Green),
@@ -740,26 +670,13 @@ pub fn cmd_comment(
return Err(anyhow!("Could not determine ticket ID."));
}
let comments_dir = comments_dir(&worklane_dir, &ticket_uuid);
fs::create_dir_all(&comments_dir)?;
let stem = Local::now().format(COMMENT_FILE_FORMAT).to_string();
let author = resolve_actor(actor.as_deref());
let comment_content = format!(
"**Comment**\n\
{}\n\
\n\
**Author**: {}\n\
**Time**: {}\n\
",
let filename = write_entry(
&worklane_dir,
&ticket_uuid,
Kind::Comment,
body,
author,
Local::now().format(TIMESTAMP_FORMAT)
);
let filename = write_new_comment(&comments_dir, &stem, &comment_content)?;
&resolve_actor(actor.as_deref()),
)?;
println!("Comment added to '{}' ({})", title, filename);
Ok(())
@@ -993,6 +910,23 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
let renamed = changed.contains(&"title").then_some(()).and(args.title.as_ref());
save_ticket(&worklane_dir, &status, &uuid, &title, renamed, &content)?;
// Tags alone, of everything `set` writes. The other fields change often enough that a
// log of them is noise, and `apply` is what decides this: a field it did not record as
// changed was already what the call asked for. Emptying the field counts, since
// `--clear tags` is the same field going somewhere.
if changed.contains(&"tags") || cleared.contains(&"tags") {
write_entry(
&worklane_dir,
&uuid,
Kind::Tags,
&change(
&parse_ticket_field(&original, "Tags"),
&parse_ticket_field(&content, "Tags"),
),
&resolve_actor(args.actor.as_deref()),
)?;
}
let shown = args.title.clone().unwrap_or(title);
if !changed.is_empty() {
report(&changed, &shown, "Updated");
@@ -1037,6 +971,19 @@ pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
save_ticket(&worklane_dir, &status, &uuid, &title, None, &content)?;
// Behind the no-change return above, so a chown to the owner a ticket already has
// records nothing, and after the save, so a failed write logs nothing.
write_entry(
&worklane_dir,
&uuid,
Kind::Owner,
&change(
&parse_ticket_field(&original, "Owner"),
&parse_ticket_field(&content, "Owner"),
),
&resolve_actor(args.actor.as_deref()),
)?;
let verb = match user {
Some(_) => "Updated",
None => "Cleared",
@@ -1854,33 +1801,3 @@ pub fn cmd_install_tool(force: bool, print: bool) -> Result<()> {
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
/// The collision path cannot be provoked from the CLI, since two processes
/// will not share a microsecond, but it is the whole point of the guard.
#[test]
fn a_colliding_stem_takes_the_next_name_and_keeps_the_first() {
let dir = Fixture::new("worklane-test");
let first = write_new_comment(&dir, "20260820_143012_123456", "first").unwrap();
let second = write_new_comment(&dir, "20260820_143012_123456", "second").unwrap();
let third = write_new_comment(&dir, "20260820_143012_123456", "third").unwrap();
assert_eq!(first, "20260820_143012_123456.md");
assert_eq!(second, "20260820_143012_123456_01.md");
assert_eq!(third, "20260820_143012_123456_02.md");
// Nothing was truncated on the way through
assert_eq!(fs::read_to_string(dir.join(&first)).unwrap(), "first");
assert_eq!(fs::read_to_string(dir.join(&second)).unwrap(), "second");
assert_eq!(fs::read_to_string(dir.join(&third)).unwrap(), "third");
// read_comments sorts on the stem, so the names must sort in write order
let mut names = vec![second.clone(), third.clone(), first.clone()];
names.sort();
assert_eq!(names, vec![first, second, third]);
}
}
+614
View File
@@ -0,0 +1,614 @@
//! What happened to a ticket, one file per entry.
//!
//! The comments directory was already an append-only log with exactly one event kind:
//! one file per entry under a directory named by the ticket's uuid, stamped to the
//! microsecond and written with `create_new` so two writers cannot clobber each other.
//! This is that log with the kind named in it, so a status change, an owner change and a
//! tag change are recorded beside what somebody said about them.
//!
//! What is deliberately not logged: ticking or unticking a criterion, and edits to the
//! title, description, plan, priority or due. Those change often and a log of them is
//! noise. When one of them matters, whoever made it adds a comment saying why, which is
//! the record actually worth keeping.
//!
//! Every entry names its author, from [`resolve_actor`], so a board several agents write
//! to says which of them did what.
//!
//! [`resolve_actor`]: crate::util::resolve_actor
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};
use anyhow::{Result, anyhow};
use chrono::Local;
use crate::util::{Color, TIMESTAMP_FORMAT, paint, should_use_colors};
/// Where a ticket's history lives, under the board.
///
/// Beside the status directories rather than among them, the way `campaigns_dir` is: an
/// entry has no status of its own. Spelled once here, so the writer, the reader and the
/// card's counter cannot disagree about the path.
pub const HISTORY_DIR: &str = "history";
/// The name the same directory had while a comment was the only entry it could hold.
///
/// Kept so a board written by an older version is adopted rather than migrated by hand.
/// See [`adopt_comments`].
pub const COMMENTS_DIR: &str = "comments";
/// How an entry filename is stamped.
///
/// Microseconds, not seconds: at second resolution two entries in the same second
/// produced the same name and the second silently truncated the first. Fixed width and
/// first in the name, so the lexicographic sort in [`read_history`] stays chronological
/// whatever kind follows it.
pub const ENTRY_FILE_FORMAT: &str = "%Y%m%d_%H%M%S_%6f";
/// The history root of a board.
pub fn history_root(board: &Path) -> PathBuf {
board.join(HISTORY_DIR)
}
/// The history directory for one ticket, named by its full uuid.
pub fn history_dir(board: &Path, uuid: &str) -> PathBuf {
history_root(board).join(uuid)
}
/// What an entry records.
///
/// An enum rather than a string, so a kind the reader does not know is a compile error
/// instead of a word that renders as itself. The variants are the four things worth
/// keeping: what somebody said, and the three fields whose history answers a question.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Kind {
Comment,
Status,
Owner,
Tags,
}
impl Kind {
/// Every kind, which is what the reader matches a marker against and what the
/// counter matches a filename against.
pub const ALL: [Kind; 4] = [Kind::Comment, Kind::Status, Kind::Owner, Kind::Tags];
/// The width the mechanical labels are padded to, `status` being the longest of the
/// three. `comment` is longer and is not padded to: a comment renders as a header
/// and a body, not as a row.
const LABEL_WIDTH: usize = 6;
/// The word in the filename, and the label a mechanical entry renders under.
pub fn slug(self) -> &'static str {
match self {
Kind::Comment => "comment",
Kind::Status => "status",
Kind::Owner => "owner",
Kind::Tags => "tags",
}
}
/// The marker the file opens with, which is what the reader keys the kind off.
///
/// The file is the record and the filename is an index into it: a name can be
/// changed by anything that touches the directory, so the kind is read from the
/// content and only counted from the name.
fn marker(self) -> &'static str {
match self {
Kind::Comment => "**Comment**",
Kind::Status => "**Status**",
Kind::Owner => "**Owner**",
Kind::Tags => "**Tags**",
}
}
}
/// One entry: what happened, who wrote it and when.
#[derive(Debug)]
pub struct Entry {
/// The file stem, which is what the entries are sorted by.
pub filename: String,
pub kind: Kind,
pub author: String,
pub time: String,
/// A comment's text, or the before and after of the field a mechanical entry names.
pub body: String,
}
/// Rename an old `comments` directory to `history`, before anything reads or writes it.
///
/// One rename rather than a migration command: the entries themselves need no rewriting,
/// since [`parse_entry`] reads a file with no marker as the comment it is. Called by the
/// reader, the writer and the counter, so no caller has to remember it and a board can
/// never be reached through a path that skips it.
///
/// Both directories at once is refused rather than merged. Only the CLI writes there, so
/// it cannot arrive at that state on its own, and choosing which of two entries with the
/// same name survives is not a decision to make silently.
pub fn adopt_comments(board: &Path) -> Result<()> {
let old = board.join(COMMENTS_DIR);
if !old.exists() {
return Ok(());
}
let new = history_root(board);
if new.exists() {
return Err(anyhow!(
"Board holds both {} and {}. Only worklane writes there, so this needs a \
person: move the entries under {} into the matching directories in {}, \
then remove it.",
old.display(),
new.display(),
COMMENTS_DIR,
HISTORY_DIR,
));
}
fs::rename(&old, &new)
.map_err(|e| anyhow!("Could not rename {} to {}: {}", old.display(), new.display(), e))
}
/// One entry, from its filename and its content.
///
/// Split out from the directory walk so the parse can be tested without a fixture, and
/// because it is where the compatibility lives: a file with no marker is a comment,
/// which is what every entry written before the kinds existed is.
fn parse_entry(filename: &str, content: &str) -> Entry {
let field = |name: &str| {
let marker = format!("**{}**:", name);
content
.lines()
.find(|line| line.starts_with(&marker))
.and_then(|line| line.split_once(&marker))
.map(|(_, value)| value.trim().to_string())
.unwrap_or_else(|| "unknown".to_string())
};
let kind = Kind::ALL
.into_iter()
.find(|kind| content.starts_with(&format!("{}\n", kind.marker())))
.unwrap_or(Kind::Comment);
let body = content
.strip_prefix(&format!("{}\n", kind.marker()))
.map(|rest| match rest.find("\n\n**Author**") {
Some(end) => rest[..end].trim(),
None => rest.trim(),
})
.unwrap_or("");
Entry {
filename: filename.to_string(),
kind,
author: field("Author"),
time: field("Time"),
body: body.to_string(),
}
}
/// Every entry on a ticket, oldest first.
///
/// Public for the TUI's detail view, which shows the same sequence `show` does.
pub fn read_history(board: &Path, uuid: &str) -> Result<Vec<Entry>> {
adopt_comments(board)?;
let dir = history_dir(board, uuid);
if !dir.exists() {
return Ok(vec![]);
}
let mut entries: Vec<Entry> = Vec::new();
for entry in fs::read_dir(&dir)? {
let path = entry?.path();
if path.extension().is_some_and(|ext| ext == "md") {
let content = fs::read_to_string(&path)?;
let filename = path
.file_stem()
.map(|stem| stem.to_string_lossy().to_string())
.unwrap_or_default();
entries.push(parse_entry(&filename, &content));
}
}
// The stamp is fixed width and leads the name, so this is chronological.
entries.sort_by(|a, b| a.filename.cmp(&b.filename));
Ok(entries)
}
/// The kind a filename names, which is what the count reads instead of the file.
///
/// A stem with no kind in it is a comment, the same compatibility [`parse_entry`] has.
/// The collision suffix is a number and matches no slug, so it is skipped.
fn kind_from_stem(stem: &str) -> Kind {
stem.split('_')
.find_map(|part| Kind::ALL.into_iter().find(|kind| kind.slug() == part))
.unwrap_or(Kind::Comment)
}
/// How many comments a ticket carries, counted off the directory rather than read.
///
/// Comments only, so the card's counter still says how many things somebody said: a
/// ticket that has moved three times has not been talked about. `.md` only, the filter
/// [`read_history`] applies, so a stray file dropped in there is not counted. A missing
/// directory is none, which is what a ticket nothing has happened to has.
pub fn count_comments(board: &Path, uuid: &str) -> usize {
// Swallowed, unlike the reader's: a count is drawn on every card and a board that
// cannot be adopted has to draw as the zero it looks like rather than take the TUI
// down. The next write reports the real reason.
let _ = adopt_comments(board);
let Ok(entries) = fs::read_dir(history_dir(board, uuid)) else {
return 0;
};
entries
.filter_map(|entry| entry.ok())
.filter(|entry| entry.path().extension().is_some_and(|ext| ext == "md"))
.filter(|entry| {
let stem = entry.path().file_stem().map(|s| s.to_string_lossy().to_string());
stem.is_some_and(|stem| kind_from_stem(&stem) == Kind::Comment)
})
.count()
}
/// The file an entry is written as.
///
/// A comment's file is byte for byte what `comment` wrote before the kinds existed, so
/// nothing has to be rewritten and a board can be read by either version.
fn entry_content(kind: Kind, body: &str, author: &str, time: &str) -> String {
format!(
"{}\n\
{}\n\
\n\
**Author**: {}\n\
**Time**: {}\n\
",
kind.marker(),
body,
author,
time
)
}
/// Write an entry under the first free name derived from the stamp.
///
/// `create_new` rather than `fs::write`: a name that already exists means another entry
/// landed in the same microsecond, and truncating it is exactly the data loss this
/// guards against. The suffix is zero padded so the names keep sorting in the order they
/// were written.
fn write_new(dir: &Path, stem: &str, content: &str) -> Result<String> {
for attempt in 0..100 {
let filename = match attempt {
0 => format!("{}.md", stem),
n => format!("{}_{:02}.md", stem, n),
};
match fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(dir.join(&filename))
{
Ok(mut file) => {
file.write_all(content.as_bytes())?;
return Ok(filename);
}
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,
Err(e) => return Err(e.into()),
}
}
Err(anyhow!("No free entry filename for '{}' in {}", stem, dir.display()))
}
/// Record one entry on a ticket, returning the filename it landed under.
///
/// Called after the edit it describes has been written, never before: an entry for a
/// move that was refused would be a log of things that did not happen. The cost of that
/// order is that a failed write here leaves the edit in place and reports the failure,
/// which is the right way round — the ticket is the record and this is the story of it.
pub fn write_entry(
board: &Path,
uuid: &str,
kind: Kind,
body: &str,
author: &str,
) -> Result<String> {
adopt_comments(board)?;
let dir = history_dir(board, uuid);
fs::create_dir_all(&dir)?;
let now = Local::now();
let stem = format!("{}_{}", now.format(ENTRY_FILE_FORMAT), kind.slug());
let content = entry_content(kind, body, author, &now.format(TIMESTAMP_FORMAT).to_string());
write_new(&dir, &stem, &content)
}
/// What a mechanical entry records: the field before the edit and after it.
///
/// The values as the ticket holds them, sentinels included, so `_Not set_` reads the way
/// the field it came from does rather than being translated into a word this module
/// invented.
pub fn change(before: &str, after: &str) -> String {
format!("{} → {}", before, after)
}
pub fn format_history(entries: &[Entry]) -> String {
format_history_with(entries, should_use_colors())
}
/// As above, with the colour decision passed in for the TUI.
pub fn format_history_with(entries: &[Entry], colored: bool) -> String {
if entries.is_empty() {
return paint("No history yet.", Color::Grey, colored);
}
let mut result = String::new();
result.push('\n');
result.push_str(&paint("HISTORY", Color::Orange, colored));
result.push_str(&format!("\n{}\n", "─".repeat(20)));
for entry in entries {
result.push('\n');
let stamp = paint(&format!("{} ({})", entry.author, entry.time), Color::Cyan, colored);
match entry.kind {
// As it has always read: a header naming who said it, then the text.
Kind::Comment => {
result.push_str(&paint(
&format!("From {} ({})", entry.author, entry.time),
Color::Cyan,
colored,
));
result.push('\n');
if !entry.body.is_empty() {
result.push_str(" ");
result.push_str(&entry.body);
}
result.push('\n');
}
// One line: a field change is one fact and a paragraph for it would bury the
// comments it sits between.
_ => {
let label = paint(entry.kind.slug(), Color::Orange, colored);
let padding = Kind::LABEL_WIDTH.saturating_sub(entry.kind.slug().chars().count());
result.push_str(&format!(
"{}{} {} {}\n",
label,
" ".repeat(padding),
entry.body,
stamp
));
}
}
}
result
}
#[cfg(test)]
mod tests {
use super::*;
use crate::util::Fixture;
fn board() -> Fixture {
Fixture::new("worklane-history")
}
#[test]
fn an_entry_names_its_kind_in_the_file_and_in_the_filename() {
let board = board();
let filename =
write_entry(&board, "uuid", Kind::Status, "committed → reviewing", "claude").unwrap();
assert!(filename.ends_with("_status.md"), "was {filename}");
let entries = read_history(&board, "uuid").unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].kind, Kind::Status);
assert_eq!(entries[0].body, "committed → reviewing");
assert_eq!(entries[0].author, "claude");
}
/// The stamp leads the name and is fixed width, so the kind that follows it cannot
/// reorder the log.
#[test]
fn the_kind_in_the_name_does_not_disturb_the_order() {
let mut names = [
"20260824_120000_000000_status",
"20260824_115959_999999_tags",
"20260824_120000_000001_comment",
];
names.sort();
assert_eq!(
names,
[
"20260824_115959_999999_tags",
"20260824_120000_000000_status",
"20260824_120000_000001_comment",
]
);
}
/// A file written before the kinds existed: no marker, so it is the comment it was,
/// and nothing rewrites it.
#[test]
fn an_entry_with_no_marker_is_a_comment() {
let legacy = parse_entry(
"20260820_143012_123456",
"**Comment**\nSomething said\n\n**Author**: Ansho Rei\n**Time**: 2026-08-20 14:30:12\n",
);
assert_eq!(legacy.kind, Kind::Comment);
assert_eq!(legacy.body, "Something said");
assert_eq!(legacy.author, "Ansho Rei");
// And one with no marker at all, which is what `read_comments` read as empty.
let bare = parse_entry("20260820_143012_123457", "notes\n");
assert_eq!(bare.kind, Kind::Comment);
assert_eq!(bare.body, "");
}
/// The comment file is byte for byte what `comment` wrote before this module, which
/// is what lets an old board be read without a migration.
#[test]
fn a_comment_file_is_shaped_as_it_always_was() {
let content = entry_content(Kind::Comment, "A body", "claude", "2026-08-24 12:00:00");
assert_eq!(
content,
"**Comment**\nA body\n\n**Author**: claude\n**Time**: 2026-08-24 12:00:00\n"
);
}
/// Same microsecond, three entries: the guard is `create_new`, and the suffix keeps
/// them in the order they were written.
#[test]
fn entries_in_one_microsecond_get_names_of_their_own() {
let board = board();
let dir = history_dir(&board, "uuid");
fs::create_dir_all(&dir).unwrap();
let first = write_new(&dir, "20260820_143012_123456_comment", "first").unwrap();
let second = write_new(&dir, "20260820_143012_123456_comment", "second").unwrap();
let third = write_new(&dir, "20260820_143012_123456_comment", "third").unwrap();
assert_eq!(first, "20260820_143012_123456_comment.md");
assert_eq!(second, "20260820_143012_123456_comment_01.md");
assert_eq!(third, "20260820_143012_123456_comment_02.md");
// Nothing was truncated on the way through
assert_eq!(fs::read_to_string(dir.join(&first)).unwrap(), "first");
assert_eq!(fs::read_to_string(dir.join(&second)).unwrap(), "second");
assert_eq!(fs::read_to_string(dir.join(&third)).unwrap(), "third");
// read_history sorts on the stem, so the names must sort in write order
assert!(first < second && second < third, "the names lost their order");
}
#[test]
fn an_old_comments_directory_is_adopted_on_access() {
let board = board();
let comments = board.join(COMMENTS_DIR).join("uuid");
fs::create_dir_all(&comments).unwrap();
fs::write(
comments.join("20260820_143012_123456.md"),
"**Comment**\nOld news\n\n**Author**: Ansho Rei\n**Time**: 2026-08-20 14:30:12\n",
)
.unwrap();
let entries = read_history(&board, "uuid").unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].body, "Old news");
assert!(!board.join(COMMENTS_DIR).exists(), "the old directory survived");
assert!(history_dir(&board, "uuid").exists(), "the entries did not arrive");
}
/// Refused rather than merged: only the CLI writes there, so this is a board somebody
/// has been in by hand, and picking a survivor per name is not a silent decision.
#[test]
fn a_board_holding_both_directories_is_refused() {
let board = board();
fs::create_dir_all(board.join(COMMENTS_DIR).join("uuid")).unwrap();
fs::create_dir_all(history_dir(&board, "uuid")).unwrap();
let refused = read_history(&board, "uuid");
let message = refused.unwrap_err().to_string();
assert!(
message.contains(COMMENTS_DIR) && message.contains(HISTORY_DIR),
"{message}"
);
}
/// The count is the card's, and a card counts what somebody said.
#[test]
fn only_comments_are_counted() {
let board = board();
write_entry(&board, "uuid", Kind::Comment, "said", "claude").unwrap();
write_entry(&board, "uuid", Kind::Status, "backlog → committed", "claude").unwrap();
write_entry(&board, "uuid", Kind::Owner, "_Not set_ → alice", "claude").unwrap();
write_entry(&board, "uuid", Kind::Tags, "bug → bug, cli", "claude").unwrap();
assert_eq!(read_history(&board, "uuid").unwrap().len(), 4);
assert_eq!(count_comments(&board, "uuid"), 1);
}
/// A stem written before the kinds existed counts as the comment it is.
#[test]
fn a_legacy_name_counts_as_a_comment() {
assert_eq!(kind_from_stem("20260820_143012_123456"), Kind::Comment);
assert_eq!(kind_from_stem("20260820_143012_123456_01"), Kind::Comment);
assert_eq!(kind_from_stem("20260820_143012_123456_status"), Kind::Status);
assert_eq!(kind_from_stem("20260820_143012_123456_status_01"), Kind::Status);
}
#[test]
fn a_mechanical_entry_renders_as_one_line_and_a_comment_as_it_did() {
let entries = vec![
parse_entry(
"20260824_120000_000000_status",
"**Status**\ncommitted → reviewing\n\n**Author**: claude\n**Time**: 2026-08-24 12:00:00\n",
),
parse_entry(
"20260824_120001_000000_comment",
"**Comment**\nThe offset was never passed\n\n**Author**: Ansho Rei\n**Time**: 2026-08-24 12:00:01\n",
),
];
let rendered = format_history_with(&entries, false);
assert!(rendered.contains("HISTORY"), "{rendered}");
assert!(
rendered.contains("status committed → reviewing claude (2026-08-24 12:00:00)\n"),
"{rendered}"
);
assert!(
rendered
.contains("From Ansho Rei (2026-08-24 12:00:01)\n The offset was never passed"),
"{rendered}"
);
assert!(!rendered.contains('\x1b'), "colour off still painted: {rendered:?}");
}
/// Padded to the longest of the three, so every body starts in the same column
/// however short the label above it is.
#[test]
fn the_mechanical_labels_are_aligned() {
let bodies = [
("status", "backlog → committed"),
("owner", "_Not set_ → alice"),
("tags", "bug → bug, cli"),
];
let entries: Vec<Entry> = bodies
.into_iter()
.map(|(kind, body)| {
let marker = format!("**{}{}**", kind[..1].to_uppercase(), &kind[1..]);
parse_entry(
&format!("20260824_120000_000000_{kind}"),
&format!(
"{marker}\n{body}\n\n**Author**: claude\n**Time**: 2026-08-24 12:00:00\n"
),
)
})
.collect();
let rendered = format_history_with(&entries, false);
let columns: Vec<usize> = bodies
.into_iter()
.map(|(_, body)| rendered.find(body).expect("body missing"))
.map(|at| {
let line_start = rendered[..at].rfind('\n').map_or(0, |nl| nl + 1);
at - line_start
})
.collect();
assert_eq!(columns.len(), 3);
assert!(columns.windows(2).all(|pair| pair[0] == pair[1]), "{rendered}");
}
#[test]
fn nothing_recorded_says_so() {
assert_eq!(format_history_with(&[], false), "No history yet.");
}
}
+4 -1
View File
@@ -6,6 +6,7 @@ mod clipboard;
mod command;
mod completions;
mod handlers;
mod history;
mod install;
mod tag;
mod tui;
@@ -56,7 +57,9 @@ fn main() -> Result<()> {
let worklane_dir = find_worklane_dir(&start)?;
cmd_show(&id, &worklane_dir)
}
Some(Command::Mv { ticket, status, force }) => cmd_mv(&ticket, status, force, &start),
Some(Command::Mv { ticket, status, force, actor }) => {
cmd_mv(&ticket, status, force, &actor, &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),
+61 -30
View File
@@ -21,7 +21,7 @@ use ratatui::text::{Line, Span, Text};
use ratatui::widgets::{Block, Borders, Clear, Paragraph, Tabs, Wrap};
use crate::campaign::{CAMPAIGNS_DIR, CampaignIndex, Standing};
use crate::handlers::read_comments;
use crate::history::{format_history_with, history_root, read_history};
use crate::tag::{NO_ANNOTATION, TAGS_FILE, TagIndex};
use crate::util::*;
@@ -1904,22 +1904,20 @@ fn detail_of(card: &Card) -> Detail {
let resolved = worklane_dir
.and_then(|dir| crate::campaign::resolved_for(&content, dir).ok())
.unwrap_or_default();
let comments = match worklane_dir {
Some(worklane_dir) => {
read_comments(&worklane_dir.join("comments").join(&uuid)).unwrap_or_default()
}
let history = match worklane_dir {
Some(worklane_dir) => read_history(worklane_dir, &uuid).unwrap_or_default(),
None => Vec::new(),
};
// Colour on, and nothing here is painted: the body arrives as cells and the
// relations as rows, and `detail_body` turns both into styled spans. An escape
// sequence never enters, which is what a ratatui paragraph would draw as literal
// bytes. The comments are still flat, being a string the board appends rather than
// part of the rendered body.
// bytes. The history block is still flat, being a string the board appends rather
// than part of the rendered body.
let mut parts = content_parts(&content, true, &resolved);
parts.push(BodyPart::Cells(vec![Cell::plain(format!(
"\n{}",
format_comments_with(&comments, false)
format_history_with(&history, false)
))]));
Detail {
@@ -2393,9 +2391,8 @@ pub fn digest(worklane_dir: &Path) -> u64 {
// the picker, and a codename edited by hand has to reach every card that names it.
visit(worklane_dir.join(CAMPAIGNS_DIR));
// Comments live one level deeper, a directory per ticket.
let comments = worklane_dir.join("comments");
if let Ok(read) = std::fs::read_dir(&comments) {
// History entries live one level deeper, a directory per ticket.
if let Ok(read) = std::fs::read_dir(history_root(worklane_dir)) {
for entry in read.filter_map(|e| e.ok()) {
visit(entry.path());
}
@@ -4152,20 +4149,20 @@ mod tests {
/// The ticket `write_card`, `write_tagged_card` and `write_member_card` all write.
///
/// A const rather than a literal in each, now that a test has to name it from outside
/// them: the comments of a ticket live in a directory named by its uuid, so a fixture
/// them: the history of a ticket lives in a directory named by its uuid, so a fixture
/// that wrote a different one would silently count nothing.
const FIXTURE_UUID: &str = "11111111-0000-4000-8000-000000000000";
/// Comments where `comment` puts them: under the board, in a directory named by the
/// ticket's uuid, one `.md` per comment. The fixture uuid, since that is what
/// ticket's uuid, one `.md` per entry. The fixture uuid, since that is what
/// `write_card` writes into the ID field the counter reads.
fn write_comments(dir: &Path, count: usize) {
let comments = comments_dir(dir, FIXTURE_UUID);
std::fs::create_dir_all(&comments).unwrap();
let history = crate::history::history_dir(dir, FIXTURE_UUID);
std::fs::create_dir_all(&history).unwrap();
for n in 0..count {
std::fs::write(
comments.join(format!("20260823_1200{n:02}_000000.md")),
history.join(format!("20260823_1200{n:02}_000000_comment.md")),
format!("**Comment**\n\n**Author**: alice\n**Time**: 2026-08-23 12:00:{n:02}\n\nSaid {n}.\n"),
)
.unwrap();
@@ -4520,7 +4517,7 @@ mod tests {
write_comments(&dir, 2);
let board = one_board(&dir);
std::fs::remove_dir_all(comments_dir(&dir, FIXTURE_UUID)).unwrap();
std::fs::remove_dir_all(crate::history::history_dir(&dir, FIXTURE_UUID)).unwrap();
let card = board.selected().expect("no card");
let rows: Vec<String> = card_lines(card, false, 40)
@@ -4669,10 +4666,10 @@ mod tests {
write_ticket(&dir, "backlog", uuid, "First one", "");
let before = digest(&dir);
let comments = comments_dir(&dir, uuid);
std::fs::create_dir_all(&comments).unwrap();
let history = crate::history::history_dir(&dir, uuid);
std::fs::create_dir_all(&history).unwrap();
std::fs::write(
comments.join("20260821_120000_000000.md"),
history.join("20260821_120000_000000_comment.md"),
"**Comment**\nA note from elsewhere.\n\n**Author**: bob\n**Time**: 2026-08-21 12:00:00\n",
)
.unwrap();
@@ -4907,10 +4904,10 @@ mod tests {
let uuid = "11111111-0000-4000-8000-000000000000";
write_ticket(&dir, "backlog", uuid, "First one", "");
let comments = dir.join("comments").join(uuid);
let comments = crate::history::history_dir(&dir, uuid);
std::fs::create_dir_all(&comments).unwrap();
std::fs::write(
comments.join("20260821_120000_000000.md"),
comments.join("20260821_120000_000000_comment.md"),
"**Comment**\nA note from elsewhere.\n\n**Author**: bob\n**Time**: 2026-08-21 12:00:00\n",
)
.unwrap();
@@ -4937,6 +4934,40 @@ mod tests {
assert!(board.detail.is_none());
}
/// The detail view shows the sequence `show` does, mechanical entries included, so a
/// reader on the board sees how a ticket got where it is and not only what was said
/// about it.
#[test]
fn the_detail_view_shows_a_field_change_beside_a_comment() {
let dir = board_dir();
let uuid = "11111111-0000-4000-8000-000000000000";
write_ticket(&dir, "backlog", uuid, "First one", "");
let history = crate::history::history_dir(&dir, uuid);
std::fs::create_dir_all(&history).unwrap();
std::fs::write(
history.join("20260821_120000_000000_status.md"),
"**Status**\nbacklog → committed\n\n**Author**: claude\n**Time**: 2026-08-21 12:00:00\n",
)
.unwrap();
std::fs::write(
history.join("20260821_120001_000000_comment.md"),
"**Comment**\nAnd why.\n\n**Author**: bob\n**Time**: 2026-08-21 12:00:01\n",
)
.unwrap();
let mut board = one_board(&dir);
board.toggle_detail();
let plain = board.detail.as_ref().expect("no detail").plain();
assert!(plain.contains("HISTORY"), "{plain}");
assert!(plain.contains("status backlog → committed claude ("), "{plain}");
let moved = plain.find("backlog → committed").expect("the move is missing");
let said = plain.find("And why.").expect("the comment is missing");
assert!(moved < said, "the board reordered the log:\n{plain}");
assert!(!plain.contains('\x1b'), "escapes reached the detail view: {plain:?}");
}
/// The reported bug: the modal showed a description, criteria and a metadata
/// table belonging to a ticket it never named.
#[test]
@@ -5026,10 +5057,10 @@ mod tests {
board.toggle_detail();
assert!(!board.detail.as_ref().unwrap().plain().contains("A late note."));
let comments = dir.join("comments").join(uuid);
let comments = crate::history::history_dir(&dir, uuid);
std::fs::create_dir_all(&comments).unwrap();
std::fs::write(
comments.join("20260821_120000_000000.md"),
comments.join("20260821_120000_000000_comment.md"),
"**Comment**\nA late note.\n\n**Author**: bob\n**Time**: 2026-08-21 12:00:00\n",
)
.unwrap();
@@ -5059,10 +5090,10 @@ mod tests {
let uuid = "11111111-0000-4000-8000-000000000000";
write_ticket(&dir, "backlog", uuid, "First one", &long_section(60));
let comments = dir.join("comments").join(uuid);
let comments = crate::history::history_dir(&dir, uuid);
std::fs::create_dir_all(&comments).unwrap();
std::fs::write(
comments.join("20260821_120000_000000.md"),
comments.join("20260821_120000_000000_comment.md"),
"**Comment**\nThe last word.\n\n**Author**: bob\n**Time**: 2026-08-21 12:00:00\n",
)
.unwrap();
@@ -5230,10 +5261,10 @@ mod tests {
board.scroll_detail(1, SCREEN);
let offset = board.offset;
let comments = dir.join("comments").join(uuid);
let comments = crate::history::history_dir(&dir, uuid);
std::fs::create_dir_all(&comments).unwrap();
std::fs::write(
comments.join("20260821_120000_000000.md"),
comments.join("20260821_120000_000000_comment.md"),
"**Comment**\nA late note.\n\n**Author**: bob\n**Time**: 2026-08-21 12:00:00\n",
)
.unwrap();
@@ -6608,7 +6639,7 @@ mod tests {
}
assert_eq!(board.offset, last, "the clamp and the body disagree");
// The relations sit at the end of this fixture, so the last row and the comments
// The relations sit at the end of this fixture, so the last row and the history
// line are what the last screenful has to hold.
let screen = render(&board, SCREEN.width, SCREEN.height).join("\n");
assert!(
@@ -6616,7 +6647,7 @@ mod tests {
"the last relation is not on screen:\n{screen}"
);
assert!(
screen.contains("No comments yet."),
screen.contains("No history yet."),
"the body ends past the last screenful:\n{screen}"
);
}
+24 -81
View File
@@ -5,29 +5,10 @@ use std::io::IsTerminal;
use std::path::Path;
use std::sync::OnceLock;
/// How timestamps are written into tickets and comments, and therefore how they
/// are read back. Shared so the writer and the reader cannot drift apart.
/// How timestamps are written into tickets and history entries, and therefore how
/// they are read back. Shared so the writer and the reader cannot drift apart.
pub const TIMESTAMP_FORMAT: &str = "%Y-%m-%d %H:%M:%S";
/// How a comment filename is stamped.
///
/// Microseconds, not seconds: at second resolution two comments in the same
/// second produced the same name and the second silently truncated the first.
/// Fixed width, so the lexicographic sort in `read_comments` stays chronological.
pub const COMMENT_FILE_FORMAT: &str = "%Y%m%d_%H%M%S_%6f";
/// Where a ticket's comments live, under the board.
///
/// Beside the status directories rather than among them, the way `campaigns_dir` is: a
/// comment has no status of its own. Spelled once here, so the writer, the reader and the
/// card's counter cannot disagree about the path.
pub const COMMENTS_DIR: &str = "comments";
/// The comments directory for one ticket, named by its full uuid.
pub fn comments_dir(board: &Path, uuid: &str) -> std::path::PathBuf {
board.join(COMMENTS_DIR).join(uuid)
}
/// The mark a card puts after its comment count.
///
/// A closing quotation ornament, so `2\u{275e}` reads as two things somebody said rather
@@ -663,37 +644,6 @@ pub fn resolve_ticket(search: &str, worklane_dir: &Path) -> Result<(String, Stri
let found = matches.remove(0);
Ok((found.dir, found.title, found.content))
}
pub fn format_comments(comments: &[(String, String, String, String)]) -> String {
format_comments_with(comments, should_use_colors())
}
/// As above, with the colour decision passed in for the TUI.
pub fn format_comments_with(
comments: &[(String, String, String, String)],
colored: bool,
) -> String {
if comments.is_empty() {
return paint("No comments yet.", Color::Grey, colored);
}
let mut result = String::new();
result.push('\n');
result.push_str(&paint("COMMENTS", Color::Orange, colored));
result.push_str(&format!("\n{}\n", "─".repeat(20)));
for (_filename, author, time, body) in comments {
result.push('\n');
result.push_str(&paint(&format!("From {} ({})", author, time), Color::Cyan, colored));
result.push('\n');
if !body.is_empty() {
result.push_str(" ");
result.push_str(body);
}
result.push('\n');
}
result
}
/// The parts of a ticket's body that cannot be rendered from the file alone.
///
/// Both are resolved against the rest of the board. The Relations section stores one
@@ -3055,22 +3005,6 @@ pub fn display_ticket_items(items: &[TicketItem]) {
}
}
/// How many comments a ticket has, counted off the directory rather than read.
///
/// `.md` only, the filter `read_comments` applies, so a stray file dropped in there is
/// not counted as something somebody wrote. A missing directory is none, which is what a
/// ticket nobody has commented on has: no directory is created until the first comment.
fn count_comments(board: &Path, uuid: &str) -> usize {
let Ok(entries) = fs::read_dir(comments_dir(board, uuid)) else {
return 0;
};
entries
.filter_map(|entry| entry.ok())
.filter(|entry| entry.path().extension().is_some_and(|ext| ext == "md"))
.count()
}
pub fn collect_ticket_items(status_path: impl AsRef<Path>) -> Result<Vec<TicketItem>> {
let status_path = status_path.as_ref();
// The comments sit beside the status directories, so the board is this one's parent.
@@ -3120,10 +3054,10 @@ pub fn collect_ticket_items(status_path: impl AsRef<Path>) -> Result<Vec<TicketI
}),
};
// The ticket's own ID field, not the filename stem: a comment directory is
// named by the uuid the file records, which is what `comment` wrote it under.
// The ticket's own ID field, not the filename stem: a history directory is
// named by the uuid the file records, which is what wrote the entries under it.
let uuid = parse_ticket_field(&content, "ID");
let comments = board.map_or(0, |board| count_comments(board, &uuid));
let comments = board.map_or(0, |board| crate::history::count_comments(board, &uuid));
Some(TicketItem {
title,
@@ -3853,12 +3787,13 @@ mod tests {
);
}
/// The count is a directory listing rather than a read: nothing here parses a comment,
/// The count is a directory listing rather than a read: nothing here parses an entry,
/// and the bodies are the detail view's business.
///
/// `.md` only, the filter `read_comments` applies, so a stray file dropped in there is
/// not counted as something somebody wrote. A ticket with no directory at all has
/// none, which is every ticket until the first comment creates one.
/// `.md` only, the filter `read_history` applies, so a stray file dropped in there is
/// not counted as something somebody wrote, and a mechanical entry is not counted
/// either: the card says how many things were said about the ticket. A ticket with no
/// directory at all has none, which is every ticket until the first entry creates one.
#[test]
fn collect_ticket_items_counts_the_comments_under_the_board() {
let board = tempfile::tempdir().unwrap();
@@ -3877,12 +3812,20 @@ mod tests {
write(talked_about);
write(quiet);
let comments = comments_dir(board.path(), talked_about);
fs::create_dir_all(&comments).unwrap();
fs::write(comments.join("20260823_120000_000000.md"), "**Comment**\n").unwrap();
fs::write(comments.join("20260823_120001_000000.md"), "**Comment**\n").unwrap();
// Not a comment, and not counted as one.
fs::write(comments.join("notes.txt"), "scratch\n").unwrap();
let history = crate::history::history_dir(board.path(), talked_about);
fs::create_dir_all(&history).unwrap();
fs::write(history.join("20260823_120000_000000_comment.md"), "**Comment**\n").unwrap();
// No kind in the name, as everything written before the kinds existed: a comment.
fs::write(history.join("20260823_120001_000000.md"), "**Comment**\n").unwrap();
// A field change is history but not something somebody said, so the card's
// counter leaves it out.
fs::write(
history.join("20260823_120002_000000_status.md"),
"**Status**\nbacklog → committed\n",
)
.unwrap();
// Not an entry at all, and not counted as one.
fs::write(history.join("notes.txt"), "scratch\n").unwrap();
let items = collect_ticket_items(&backlog).unwrap();
let counted = |uuid: &str| {