(8a2abf1) Give the wrapper tools for relate, campaign, assign and tags, and bump to 0.32.10

This commit is contained in:
Ansho Rei
2026-08-26 12:32:15 +02:00
parent d0a8f9a284
commit 668263605c
6 changed files with 504 additions and 28 deletions
+124 -21
View File
@@ -162,7 +162,8 @@ pub fn skills_root() -> Result<PathBuf> {
/// `NO_COLOR`. Checked against opencode 1.15.10.
///
/// Singular `tool`, though 1.15.10 loads `tools` as well: each was served in turn from a
/// directory outside any project and registered all eleven worklane tools. The singular
/// directory outside any project and registered every worklane tool the file carried,
/// eleven at the time and twenty-one at the recheck. The singular
/// is the spelling opencode's own documentation puts first, the way it writes `agent(s)`
/// and `skill(s)`.
///
@@ -569,7 +570,7 @@ mod tests {
}
/// The file name is the tool id prefix, not decoration: opencode names each tool as
/// the file then the export, so a renamed file renames all eleven tools and every
/// the file then the export, so a renamed file renames all twenty-one tools and every
/// permission rule that mentions one.
#[test]
fn the_tool_lands_flat_in_the_root_under_the_name_that_prefixes_its_ids() {
@@ -579,31 +580,18 @@ mod tests {
assert_eq!(TOOL.relative, "worklane.ts");
}
/// Every tool the file exports names a real subcommand.
/// Every tool the file exports names a real subcommand path.
///
/// The guard the fish completion lists already have, pointed the other way: this
/// catches a tool wrapping a command that has been renamed or dropped, which would
/// fail only when an agent finally called it. It cannot catch the reverse, a
/// subcommand the wrapper never grew a tool for, and the wrapper is behind by
/// several: `relate`, `campaign`, `assign` and `tags` have no tool. That is its own
/// ticket, and asserting it here would fail on a gap nobody has decided to close.
/// fail only when an agent finally called it. The converse, a subcommand the wrapper
/// never grew a tool for, is [`every_subcommand_outside_the_exceptions_has_a_tool`].
#[test]
fn every_tool_the_wrapper_exports_is_a_real_subcommand() {
use clap::CommandFactory;
let commands: Vec<String> = subcommand_paths();
let exported = exported_tools();
let commands: Vec<String> = crate::Cli::command()
.get_subcommands()
.map(|command| command.get_name().to_string())
.collect();
let exported: Vec<&str> = TOOL
.content
.lines()
.filter_map(|line| line.strip_prefix("export const "))
.filter_map(|rest| rest.split_whitespace().next())
.collect();
assert_eq!(exported.len(), 11, "{exported:?}");
assert_eq!(exported.len(), 21, "{exported:?}");
for name in exported {
assert!(
commands.iter().any(|command| command == name),
@@ -611,4 +599,119 @@ mod tests {
);
}
}
/// The export names in the tool file: one per `export const`, which is what makes
/// them tool ids once opencode prefixes its file name.
fn exported_tools() -> Vec<&'static str> {
TOOL.content
.lines()
.filter_map(|line| line.strip_prefix("export const "))
.filter_map(|rest| rest.split_whitespace().next())
.collect()
}
/// Every subcommand as the wrapper spells it: the CLI path joined with `_`, since
/// that is how an export name has to be spelled to be an identifier. So
/// `campaign set` is `campaign_set`, and the hyphen in `install-skill` becomes one.
///
/// Walked off clap rather than written out, the way every other guard here is:
/// a hand-maintained list is the very drift this exists to catch.
fn subcommand_paths() -> Vec<String> {
use clap::CommandFactory;
fn walk(command: &clap::Command, prefix: Option<&str>, paths: &mut Vec<String>) {
for sub in command.get_subcommands() {
let name = sub.get_name();
if name == "help" {
continue;
}
let path = match prefix {
Some(prefix) => format!("{prefix}_{name}"),
None => name.to_string(),
};
let path = path.replace('-', "_");
walk(sub, Some(&path), paths);
paths.push(path);
}
}
let mut paths = Vec::new();
walk(&crate::Cli::command(), None, &mut paths);
paths
}
/// Subcommands the wrapper deliberately does not carry, each with why it is left out.
///
/// Spelled the way [`subcommand_paths`] spells a path, so a renamed command leaves a
/// stale entry behind rather than silently exempting nothing.
const NO_TOOL: [(&str, &str); 6] = [
(
"campaign",
"a bare `worklane campaign` is refused by the CLI, its subcommand is required: the five campaign_* tools are the command",
),
(
"tui",
"the board view is for a person: it takes over the terminal and returns only when quit",
),
(
"completions",
"writes a person's shell configuration, which is not an agent's call to make",
),
(
"install_skill",
"installs the skill documents themselves, so an agent running it would rewrite its own instructions mid-session",
),
(
"install_tool",
"installs this very wrapper, which opencode reads once at startup, so reinstalling from inside changes nothing until restart",
),
(
"tags_ls",
"prints exactly what the bare `worklane tags` listing prints, and the tags tool runs that",
),
];
/// The direction that went unguarded until now: every subcommand outside the
/// exception list has a tool.
///
/// This is the gap e6e3a1b taught the README about and the completion lists have
/// never had: a new subcommand reached clap, the completions and the skill, and
/// stopped there, so an agent holding the tools could not call it at all and its
/// only way to the command was to shell out, which is the thing the wrapper exists
/// to avoid. Nothing else walks the wrapper against clap, so without this test the
/// next command lands in the same silence.
#[test]
fn every_subcommand_outside_the_exceptions_has_a_tool() {
let paths = subcommand_paths();
let exported = exported_tools();
// Guard on the walker itself: if it stopped finding subcommands, both filters
// below would pass on nothing.
assert_eq!(paths.len(), 27, "{paths:?}");
assert_eq!(exported.len(), 21, "{exported:?}");
let missing: Vec<&String> = paths
.iter()
.filter(|path| !NO_TOOL.iter().any(|(name, _)| name == path))
.filter(|path| !exported.iter().any(|tool| tool == path))
.collect();
assert!(
missing.is_empty(),
"no tool for {missing:?}. A new subcommand reaches the CLI, the completions \
and the skill, and stops there: give it a tool in assets/TOOL.ts, or name \
it in NO_TOOL with why it should not have one."
);
// An exception naming a subcommand that has gone, or carrying no reason, is
// drift of exactly the kind this test is for.
for (name, reason) in NO_TOOL {
assert!(
paths.iter().any(|path| path == name),
"the exception {name:?} names no subcommand clap has"
);
assert!(!reason.trim().is_empty(), "the exception for {name} carries no reason");
}
}
}