(ca2a124) Add --actor-from-git beside every --actor, and bump to 0.32.8

This commit is contained in:
Ansho Rei
2026-08-25 17:12:25 +02:00
parent bfce4cf2f4
commit e26e5893f7
11 changed files with 428 additions and 106 deletions
+87 -20
View File
@@ -199,6 +199,13 @@ fn annotation_line(raw: &str) -> Result<String, String> {
/// command reads as five flags.
const ACTOR_HELP: &str = "Who the entry is attributed to, overriding WORKLANE_ACTOR and the git user. Free text, checked against nothing";
/// What `--actor-from-git` says on every command that writes a history entry.
///
/// The counterpart to [`ACTOR_HELP`]: where that one names somebody specific, this one
/// says attribute it to the human whose checkout this is, without knowing how they spell
/// themselves.
const ACTOR_FROM_GIT_HELP: &str = "Attribute the entry to the detected git user instead of WORKLANE_ACTOR, for acting on the person's behalf. Cannot be combined with --actor";
/// Arguments that carry prose, and therefore have to accept a value starting with
/// a hyphen.
///
@@ -229,26 +236,7 @@ pub enum Command {
},
/// Move a ticket to a different status
Mv {
/// Ticket UUID or title
ticket: String,
/// Target status
#[arg(short, long)]
status: Status,
/// Force move (allows backward or non-sequential moves)
#[arg(short, long)]
force: bool,
#[arg(long, help = ACTOR_HELP)]
actor: Option<String>,
/// Why the ticket moved, recorded in the history entry beside the transition
/// it explains. Prose, so it takes a leading hyphen
#[arg(long, allow_hyphen_values = PROSE)]
reason: Option<String>,
},
Mv(MvArgs),
/// Replace fields on an existing ticket
Set(SetArgs),
@@ -298,6 +286,9 @@ pub enum Command {
/// is `chown`'s. It was `--owner`, which said the wrong one of the two.
#[arg(long, help = ACTOR_HELP)]
actor: Option<String>,
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
actor_from_git: bool,
},
/// Group tickets that have to be finished together
@@ -323,6 +314,9 @@ pub enum Command {
#[arg(long, help = ACTOR_HELP)]
actor: Option<String>,
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
actor_from_git: bool,
},
/// The tag vocabulary: what the board carries, and what each tag means
@@ -700,6 +694,33 @@ pub struct AddArgs {
pub priority: Option<u8>,
}
/// `mv` grew past a handful of parameters when `--actor-from-git` arrived, so it is a
/// struct like `set` and `append` rather than an inline variant.
#[derive(clap::Args)]
pub struct MvArgs {
/// Ticket UUID or title
pub ticket: String,
/// Target status
#[arg(short, long)]
pub status: Status,
/// Force move (allows backward or non-sequential moves)
#[arg(short, long)]
pub force: bool,
#[arg(long, help = ACTOR_HELP)]
pub actor: Option<String>,
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
pub actor_from_git: bool,
/// Why the ticket moved, recorded in the history entry beside the transition
/// it explains. Prose, so it takes a leading hyphen
#[arg(long, allow_hyphen_values = PROSE)]
pub reason: Option<String>,
}
/// `set` replaces a field outright. Owner is deliberately absent: `chown` owns that
/// field, and status is `mv`'s, so no field has two writers.
///
@@ -764,6 +785,9 @@ pub struct SetArgs {
/// command's that is logged
#[arg(long, help = ACTOR_HELP)]
pub actor: Option<String>,
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
pub actor_from_git: bool,
}
impl SetArgs {
@@ -814,6 +838,9 @@ pub struct ChownArgs {
/// change. Both are on this command because it writes both.
#[arg(long, help = ACTOR_HELP)]
pub actor: Option<String>,
#[arg(long, conflicts_with = "actor", help = ACTOR_FROM_GIT_HELP)]
pub actor_from_git: bool,
}
impl ChownArgs {
@@ -1015,4 +1042,44 @@ mod tests {
for two minor versions."
);
}
/// `--actor` and `--actor-from-git` are one pair that has to travel together: every
/// command that takes one takes the other, documented by the same string, because
/// the second is the first's spelling for "the human whose checkout this is".
///
/// A walker rather than five named commands, so a sixth entry-writing command fails
/// this on its own `--actor` instead of being forgotten here too.
#[test]
fn every_actor_command_takes_actor_from_git() {
let cli = Cli::command();
let mut seen = 0;
for sub in cli.get_subcommands() {
if sub.get_name() == "help" {
continue;
}
if !sub.get_arguments().any(|arg| arg.get_id().as_str() == "actor") {
continue;
}
seen += 1;
let from_git = sub
.get_arguments()
.find(|arg| arg.get_id().as_str() == "actor_from_git")
.unwrap_or_else(|| {
panic!("`{}` takes --actor but not --actor-from-git", sub.get_name())
});
assert_eq!(
from_git.get_help().map(|help| help.to_string()),
Some(ACTOR_FROM_GIT_HELP.to_string()),
"`{}` documents --actor-from-git differently",
sub.get_name()
);
}
// A guard on the walker itself: if it stopped finding commands, every assertion
// above would pass by never running.
assert_eq!(seen, 5, "expected comment, mv, chown, set and assign to carry --actor");
}
}
+20 -17
View File
@@ -8,7 +8,7 @@ use std::path::Path;
use crate::campaign::*;
use crate::command::{
AddArgs, AppendArgs, CampaignAddArgs, CampaignAppendArgs, CampaignSetArgs, CheckArgs,
ChownArgs, LsArgs, RelateArgs, SetArgs, TagAddArgs, TagSetArgs,
ChownArgs, LsArgs, MvArgs, RelateArgs, SetArgs, TagAddArgs, TagSetArgs,
};
use crate::history::{Kind, change, format_history, read_history, write_entry};
use crate::install;
@@ -598,14 +598,15 @@ fn check_dependents(worklane_dir: &Path, uuid: &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,
actor: &Option<String>,
reason: &Option<String>,
start: &Path,
) -> Result<()> {
pub fn cmd_mv(args: &MvArgs, start: &Path) -> Result<()> {
let MvArgs {
ticket: ticket_id,
status: target,
force,
actor,
actor_from_git,
reason,
} = args;
let target_status = target.as_str();
// A reason is one fact on one line, which is how the renderer draws it, so a
@@ -624,13 +625,13 @@ pub fn cmd_mv(
.iter()
.position(|status| status.as_str() == current_status)
.unwrap();
let target_idx = Status::ALL.iter().position(|status| *status == target).unwrap();
let target_idx = Status::ALL.iter().position(|status| *status == *target).unwrap();
// Discarding is not a stage of work, so the walk rules below do not apply to
// entering it: a ticket is abandoned from wherever it stands. They do apply to
// leaving it, which with discarded last in `Status::ALL` is always a backward move,
// so un-discarding needs `-f` with no rule of its own.
let discarding = target == Status::Discarded;
let discarding = *target == Status::Discarded;
if !force && !discarding && target_idx < current_idx {
return Err(anyhow!(
@@ -717,7 +718,7 @@ pub fn cmd_mv(
// crash-safe write the Status field does.
let content = set_status_stamp(
&content,
target,
*target,
&Local::now().format(TIMESTAMP_FORMAT).to_string(),
&title,
)?;
@@ -742,7 +743,7 @@ pub fn cmd_mv(
&parse_ticket_field(&resolved, "ID"),
Kind::Status,
&change(&current_status, target_status),
&resolve_actor(actor.as_deref()),
&resolve_actor(actor.as_deref(), *actor_from_git),
&reason,
)?;
@@ -760,6 +761,7 @@ pub fn cmd_comment(
ticket_id: &str,
body: &str,
actor: &Option<String>,
actor_from_git: bool,
start: &Path,
) -> Result<()> {
if body.is_empty() {
@@ -779,7 +781,7 @@ pub fn cmd_comment(
&ticket_uuid,
Kind::Comment,
body,
&resolve_actor(actor.as_deref()),
&resolve_actor(actor.as_deref(), actor_from_git),
"",
)?;
@@ -1028,7 +1030,7 @@ pub fn cmd_set(args: &SetArgs, start: &Path) -> Result<()> {
&parse_ticket_field(&original, "Tags"),
&parse_ticket_field(&content, "Tags"),
),
&resolve_actor(args.actor.as_deref()),
&resolve_actor(args.actor.as_deref(), args.actor_from_git),
"",
)?;
}
@@ -1087,7 +1089,7 @@ pub fn cmd_chown(args: &ChownArgs, start: &Path) -> Result<()> {
&parse_ticket_field(&original, "Owner"),
&parse_ticket_field(&content, "Owner"),
),
&resolve_actor(args.actor.as_deref()),
&resolve_actor(args.actor.as_deref(), args.actor_from_git),
"",
)?;
@@ -1772,6 +1774,7 @@ pub fn cmd_assign(
campaign_search: &str,
ticket_id: &str,
actor: &Option<String>,
actor_from_git: bool,
start: &Path,
) -> Result<()> {
let worklane_dir = find_worklane_dir(start)?;
@@ -1810,7 +1813,7 @@ pub fn cmd_assign(
&uuid,
Kind::Campaign,
&change(&before, campaign.name()),
&resolve_actor(actor.as_deref()),
&resolve_actor(actor.as_deref(), actor_from_git),
"",
)?;
+13 -13
View File
@@ -57,22 +57,19 @@ fn main() -> Result<()> {
let worklane_dir = find_worklane_dir(&start)?;
cmd_show(&id, &worklane_dir)
}
Some(Command::Mv {
ticket,
status,
force,
actor,
reason,
}) => cmd_mv(&ticket, status, force, &actor, &reason, &start),
Some(Command::Mv(args)) => cmd_mv(&args, &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(args)) => cmd_chown(&args, &start),
Some(Command::Check(args)) => cmd_check(&args, true, &start),
Some(Command::Uncheck(args)) => cmd_check(&args, false, &start),
Some(Command::Comment { ticket, body, actor }) => {
cmd_comment(&ticket, &body, &actor, &start)
}
Some(Command::Comment {
ticket,
body,
actor,
actor_from_git,
}) => cmd_comment(&ticket, &body, &actor, actor_from_git, &start),
Some(Command::Campaign { command }) => match command {
CampaignCommand::Add(args) => cmd_campaign_add(&args, &start),
CampaignCommand::Ls { ids } => {
@@ -86,9 +83,12 @@ fn main() -> Result<()> {
cmd_campaign_show(&campaign, &worklane_dir)
}
},
Some(Command::Assign { campaign, ticket, actor }) => {
cmd_assign(&campaign, &ticket, &actor, &start)
}
Some(Command::Assign {
campaign,
ticket,
actor,
actor_from_git,
}) => cmd_assign(&campaign, &ticket, &actor, actor_from_git, &start),
// The bare form and `ls` are one arm: `worklane tags` was the listing before the
// group existed and the fish completion still calls it that way, so the two
// spellings cannot be allowed to drift into two behaviours.
+123 -46
View File
@@ -449,52 +449,78 @@ pub const ACTOR_ENV: &str = "WORKLANE_ACTOR";
/// The author written when nothing names one.
pub const UNKNOWN_ACTOR: &str = "unknown";
/// The actor for the whole run: the variable, then the git user.
/// The actor for the whole run, from the variable alone.
///
/// Split out from the caching wrapper for the reason `colors_wanted` is: a threaded test
/// binary cannot mutate the process environment to reach one branch at a time.
///
/// An empty `WORKLANE_ACTOR` counts as unset, the convention `colors_wanted` follows for
/// `NO_COLOR`, so a wrapper script can clear an inherited one. `git_user` is a closure
/// rather than a value because the fallback costs a subprocess and the variable usually
/// answers first.
fn session_actor(env: Option<&str>, git_user: impl FnOnce() -> Option<String>) -> Option<String> {
match env.map(str::trim).filter(|value| !value.is_empty()) {
Some(value) => Some(value.to_string()),
None => git_user(),
}
/// `NO_COLOR`, so a wrapper script can clear an inherited one. This is the half the
/// [`resolve_actor`] cache holds; the git user lives in a cache of its own, because with
/// `--actor-from-git` it has to be fetched even though the variable answered.
fn session_actor(env: Option<&str>) -> Option<String> {
env.map(str::trim)
.filter(|value| !value.is_empty())
.map(str::to_string)
}
/// The actor for one entry: the flag wins, otherwise the session's, otherwise unknown.
/// The actor for one entry, from what named one.
///
/// Free text, validated against nothing, the way the `chown` user is: there is no
/// registry of actors to check a name against.
fn entry_actor(flag: Option<&str>, session: Option<&str>) -> String {
[flag, session]
.into_iter()
.flatten()
.map(str::trim)
.find(|value| !value.is_empty())
.unwrap_or(UNKNOWN_ACTOR)
.to_string()
///
/// The chain depends on the flag. An explicit `--actor` wins outright either way. With
/// `from_git`, the git user is lifted above the session rather than added beneath it:
/// the flag says attribute this to the human, and a machine with no git user configured
/// has nobody to name, which reads [`UNKNOWN_ACTOR`] rather than quietly attributing
/// back to the agent. Without it, today's chain: the variable, then the git user.
///
/// `git_user` is a closure in both branches so the subprocess it costs is not run when
/// something ahead of it already answered.
fn entry_actor(
flag: Option<&str>,
from_git: bool,
session: Option<&str>,
git_user: impl FnOnce() -> Option<String>,
) -> String {
if let Some(name) = flag.map(str::trim).filter(|value| !value.is_empty()) {
return name.to_string();
}
if from_git {
return git_user().unwrap_or_else(|| UNKNOWN_ACTOR.to_string());
}
if let Some(name) = session.map(str::trim).filter(|value| !value.is_empty()) {
return name.to_string();
}
git_user().unwrap_or_else(|| UNKNOWN_ACTOR.to_string())
}
/// Who to attribute an entry to, from the flag the call carried.
/// Who to attribute an entry to, from the flags the call carried.
///
/// Precedence: flag, then `WORKLANE_ACTOR`, then the git user, then `unknown`. Every
/// entry the CLI writes goes through here, so a board several agents write to says which
/// of them wrote what instead of attributing all of it to one human.
pub fn resolve_actor(flag: Option<&str>) -> String {
// The session half is decided once, the way should_use_colors is: neither input can
// change mid-run, and the git user costs a subprocess.
static SESSION: OnceLock<Option<String>> = OnceLock::new();
/// Precedence: flag, then — unless `from_git` lifted it — `WORKLANE_ACTOR`, then the git
/// user, then `unknown`. Every entry the CLI writes goes through here, so a board
/// several agents write to says which of them wrote what instead of attributing all of
/// it to one human.
pub fn resolve_actor(flag: Option<&str>, from_git: bool) -> String {
// Each half is decided once, the way should_use_colors is: neither input can change
// mid-run, and the git user costs a subprocess. They are two caches rather than one,
// because baking the git user into the session's answer would leave `--actor-from-git`
// reading whatever the run's *first* call produced — with the variable set, that call
// never fetched git at all.
static VARIABLE: OnceLock<Option<String>> = OnceLock::new();
static GIT_USER: OnceLock<Option<String>> = OnceLock::new();
let session = SESSION.get_or_init(|| {
let session = VARIABLE.get_or_init(|| {
let env = std::env::var(ACTOR_ENV).ok();
session_actor(env.as_deref(), get_git_user)
session_actor(env.as_deref())
});
entry_actor(flag, session.as_deref())
entry_actor(flag, from_git, session.as_deref(), || {
GIT_USER.get_or_init(get_git_user).clone()
})
}
/// One file a search matched, and where it was found.
pub struct Found {
@@ -3678,48 +3704,99 @@ mod tests {
/// closure returns a name that must not appear.
#[test]
fn the_variable_names_the_actor() {
let session = session_actor(Some("claude"), || Some("Ansho Rei".to_string()));
assert_eq!(entry_actor(None, session.as_deref()), "claude");
let session = session_actor(Some("claude"));
let git_user = || Some("Ansho Rei".to_string());
assert_eq!(entry_actor(None, false, session.as_deref(), git_user), "claude");
}
#[test]
fn the_flag_overrides_the_variable() {
let session = session_actor(Some("claude"), || None);
assert_eq!(entry_actor(Some("opencode"), session.as_deref()), "opencode");
let session = session_actor(Some("claude"));
assert_eq!(
entry_actor(Some("opencode"), false, session.as_deref(), || None),
"opencode"
);
}
/// With neither supplied the author is still the git user.
#[test]
fn the_git_user_is_the_fallback() {
let session = session_actor(None, || Some("Ansho Rei".to_string()));
assert_eq!(entry_actor(None, session.as_deref()), "Ansho Rei");
let git_user = || Some("Ansho Rei".to_string());
assert_eq!(
entry_actor(None, false, session_actor(None).as_deref(), git_user),
"Ansho Rei"
);
}
/// An empty variable counts as unset, the way `NO_COLOR` does, so a wrapper script
/// can clear an inherited one and get the git user back.
/// can clear an inherited one and get the git user back. Whitespace is the same
/// case: a shell that quotes a missing value writes one.
#[test]
fn an_empty_variable_reads_as_unset() {
let session = session_actor(Some(""), || Some("Ansho Rei".to_string()));
assert_eq!(entry_actor(None, session.as_deref()), "Ansho Rei");
// Whitespace is the same case: a shell that quotes a missing value writes one
let session = session_actor(Some(" "), || Some("Ansho Rei".to_string()));
assert_eq!(entry_actor(None, session.as_deref()), "Ansho Rei");
let git_user = || Some("Ansho Rei".to_string());
for raw in ["", " "] {
let session = session_actor(Some(raw));
assert_eq!(entry_actor(None, false, session.as_deref(), git_user), "Ansho Rei");
}
}
/// And with nothing at all, including a git that has no user configured.
#[test]
fn nothing_at_all_is_unknown() {
let session = session_actor(None, || None);
assert_eq!(entry_actor(None, session.as_deref()), UNKNOWN_ACTOR);
let session = session_actor(None);
assert_eq!(entry_actor(None, false, session.as_deref(), || None), UNKNOWN_ACTOR);
// An empty flag falls through rather than writing a blank author
assert_eq!(entry_actor(Some(""), None), UNKNOWN_ACTOR);
assert_eq!(entry_actor(Some(""), false, None, || None), UNKNOWN_ACTOR);
}
/// Free text, validated against nothing, the way the `chown` user is.
#[test]
fn an_actor_is_free_text() {
let session = session_actor(Some("claude-code, session 3 (opus)"), || None);
assert_eq!(entry_actor(None, session.as_deref()), "claude-code, session 3 (opus)");
let session = session_actor(Some("claude-code, session 3 (opus)"));
assert_eq!(
entry_actor(None, false, session.as_deref(), || None),
"claude-code, session 3 (opus)"
);
}
/// The flag is the caller acting for the person whose checkout this is: the git user
/// is lifted above the variable rather than added beneath it.
#[test]
fn from_git_lifts_the_git_user_over_the_variable() {
let session = session_actor(Some("claude"));
let git_user = || Some("Ansho Rei".to_string());
assert_eq!(entry_actor(None, true, session.as_deref(), git_user), "Ansho Rei");
}
/// An explicit `--actor` still wins outright beside the lift: it names somebody
/// specific, which is the stronger statement of the two.
#[test]
fn the_flag_wins_over_from_git_too() {
let session = session_actor(Some("claude"));
let git_user = || Some("Ansho Rei".to_string());
assert_eq!(
entry_actor(Some("opencode"), true, session.as_deref(), git_user),
"opencode"
);
}
/// The lift is not a fallback: asked to name the human and finding none configured,
/// the entry reads unknown instead of quietly attributing back to the agent.
#[test]
fn from_git_with_no_git_user_is_unknown_not_the_variable() {
let session = session_actor(Some("claude"));
assert_eq!(entry_actor(None, true, session.as_deref(), || None), UNKNOWN_ACTOR);
}
/// An empty variable still counts as unset with the lift on, which here means the
/// git user answers as usual.
#[test]
fn from_git_leaves_the_empty_variable_unset() {
let git_user = || Some("Ansho Rei".to_string());
assert_eq!(
entry_actor(None, true, session_actor(Some("")).as_deref(), git_user),
"Ansho Rei"
);
}
#[test]