`.opencode/tools/worklane.ts` was the second agent asset and the only one that existed nowhere but a checkout. `cargo install` places binaries and nothing else, so anyone who installed worklane got the skills and never the tools, and the copy that did exist was reachable only from this repo. It is now `assets/TOOL.ts`, embedded with `include_str!` like every other asset, and `install-tool` writes it where opencode looks. Its own command rather than a flag on `install-skill`, because the two artifacts are not alike. A skill is inert markdown and one path serves both agents. The tool is executable TypeScript and serves one: Claude Code has no directory it scans for a tool definition, `claude mcp add` is the only way a tool enters its list, and its plugin system adopts agents, hooks, monitors, workflows, output-styles and themes and nothing named tools. Reaching it would mean an MCP server, which is a different artifact and not this file. So somebody on Claude Code takes the documents and never the wrapper, which is the choice this command exists to give them. The path was measured rather than guessed, as the ticket asked. 1.15.10 loads `~/.config/opencode/tool/` and `~/.config/opencode/tools/` both: each was served in turn from a directory outside any project and `/experimental/tool/ids` came back with all eleven worklane tools. Singular is the target, the spelling opencode's own documentation puts first the way it writes `agent(s)` and `skill(s)`. `tools_root()` follows `XDG_CONFIG_HOME` where `skills_root()` does not, because opencode's config root is an XDG path and `~/.claude` is not; `opencode debug paths` reports `$XDG_CONFIG_HOME/opencode` with it set. An empty value counts as unset, the convention `colors_wanted` already follows. `opencode_tool_dir` takes both variables as arguments for the reason `colors_wanted` does: a threaded test binary cannot mutate the process environment to reach one branch at a time. The file name is load bearing and now pinned by a test. opencode builds each tool id as the file name then the export, so `worklane.ts` plus eleven `export const` lines is what makes them `worklane_add` through `worklane_uncheck`. Renaming the file renames every tool and every permission rule naming one. The closing line is not the skills' "on their next session". opencode reads its config once at startup and never reloads it, so a running one keeps the tools it began with and the honest instruction is to restart it. Nothing else has to be installed, which is worth saying because the file is executable and reads as though it wants a toolchain. Criterion 6 asked the command to name the plugin package and Bun as runtime requirements and both are wrong: a copy in a project with no `node_modules` above it registered all eleven tools on a machine with no `bun` on `PATH`. opencode is a Bun binary and the import resolves inside it. The message says the opposite, and the reasoning is on the ticket. `install_each` is the outcome loop both commands now share, with the compare-and-refuse invocation passed in: that line is the only part of an outcome that has to name the command it came from. What each command says after the loop stays with the command. `every_tool_the_wrapper_exports_is_a_real_subcommand` guards the direction that breaks at call time, a tool wrapping a command that has been renamed or dropped. Deliberately not the reverse: the wrapper has no tool for `relate`, `campaign`, `assign` or `tags`, so an agent holding the tools cannot reach campaigns or relations at all, and a test asserting that gap would fail on a decision nobody has taken rather than on a mistake. Its own ticket. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
150 lines
5.6 KiB
Rust
150 lines
5.6 KiB
Rust
use assert_cmd::Command;
|
|
use assert_fs::TempDir;
|
|
|
|
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
|
|
|
/// The tool as this test's binary carries it, so the print path is pinned to the file in
|
|
/// the repo rather than to a description of it.
|
|
const TOOL: &str = include_str!("../assets/TOOL.ts");
|
|
|
|
/// `XDG_CONFIG_HOME` is redirected, and `HOME` with it, so the suite never writes into
|
|
/// the config of whoever runs it. Both, because the fallback reads `HOME` and a machine
|
|
/// that has neither set is not the case under test here.
|
|
fn run(config: &TempDir, args: &[&str]) -> std::process::Output {
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.env("XDG_CONFIG_HOME", config.path())
|
|
.env("HOME", config.path())
|
|
.args(args);
|
|
cmd.assert().get_output().clone()
|
|
}
|
|
|
|
fn installed(config: &TempDir) -> std::path::PathBuf {
|
|
config.path().join("opencode/tool/worklane.ts")
|
|
}
|
|
|
|
fn stdout(output: &std::process::Output) -> String {
|
|
String::from_utf8(output.stdout.clone()).unwrap()
|
|
}
|
|
|
|
/// Nothing about the tool needs a board, and it is wanted before there is one.
|
|
///
|
|
/// The file name is asserted, not just the directory: opencode names each tool as the
|
|
/// file then the export, so `worklane.ts` is what makes them `worklane_add` and
|
|
/// `worklane_mv`.
|
|
#[test]
|
|
fn the_tool_installs_outside_a_worklane_directory() {
|
|
let config = TempDir::new().unwrap();
|
|
let output = run(&config, &["install-tool"]);
|
|
|
|
assert!(output.status.success());
|
|
assert_eq!(std::fs::read_to_string(installed(&config)).unwrap(), TOOL);
|
|
assert!(
|
|
stdout(&output).contains("Installed the worklane tool"),
|
|
"{}",
|
|
stdout(&output)
|
|
);
|
|
}
|
|
|
|
/// What the message has to carry, and it is not the skills' "next session": opencode
|
|
/// reads its config once at startup and never reloads it, so a running one keeps the
|
|
/// tools it began with. The second half is there because the file is executable and
|
|
/// looks like it needs a toolchain, which it does not.
|
|
#[test]
|
|
fn the_tool_says_to_restart_opencode_and_that_nothing_else_is_needed() {
|
|
let config = TempDir::new().unwrap();
|
|
let out = stdout(&run(&config, &["install-tool"]));
|
|
|
|
assert!(out.contains("Restart it"), "{out}");
|
|
assert!(out.contains("never reloaded"), "{out}");
|
|
assert!(out.contains("Nothing else to install"), "{out}");
|
|
assert!(out.contains("Bun"), "{out}");
|
|
}
|
|
|
|
/// Installing twice is a no-op rather than a rewrite, exactly as `install-skill` is.
|
|
#[test]
|
|
fn a_second_install_reports_the_copy_unchanged() {
|
|
let config = TempDir::new().unwrap();
|
|
run(&config, &["install-tool"]);
|
|
let out = stdout(&run(&config, &["install-tool"]));
|
|
|
|
assert!(out.contains("Already up to date"), "{out}");
|
|
assert!(!out.contains("Installed the"), "{out}");
|
|
}
|
|
|
|
/// An edited copy is somebody's work, and the refusal names the invocation that shows
|
|
/// what it would be replaced with. `--print` there and not a skill name: there is one
|
|
/// tool file, so nothing has to say which.
|
|
#[test]
|
|
fn a_modified_copy_is_refused_until_force() {
|
|
let config = TempDir::new().unwrap();
|
|
run(&config, &["install-tool"]);
|
|
std::fs::write(installed(&config), "// hand written\n").unwrap();
|
|
|
|
let refused = stdout(&run(&config, &["install-tool"]));
|
|
assert!(refused.contains("Differs from the version in this binary"), "{refused}");
|
|
assert!(refused.contains("worklane install-tool --print"), "{refused}");
|
|
assert_eq!(std::fs::read_to_string(installed(&config)).unwrap(), "// hand written\n");
|
|
|
|
let forced = stdout(&run(&config, &["install-tool", "--force"]));
|
|
assert!(forced.contains("Installed the worklane tool"), "{forced}");
|
|
assert_eq!(std::fs::read_to_string(installed(&config)).unwrap(), TOOL);
|
|
}
|
|
|
|
/// `--print` is for diffing against an installed copy, so it writes nothing.
|
|
#[test]
|
|
fn print_writes_the_tool_to_stdout_and_installs_nothing() {
|
|
let config = TempDir::new().unwrap();
|
|
let output = run(&config, &["install-tool", "--print"]);
|
|
|
|
assert_eq!(stdout(&output), TOOL);
|
|
assert!(!installed(&config).exists());
|
|
}
|
|
|
|
/// With no `XDG_CONFIG_HOME` the tool lands under `HOME`, which is the same answer
|
|
/// opencode gives: its config root is `$XDG_CONFIG_HOME/opencode` when that is set and
|
|
/// `~/.config/opencode` when it is not.
|
|
#[test]
|
|
fn the_tool_falls_back_to_the_home_directory_without_xdg_config_home() {
|
|
let home = TempDir::new().unwrap();
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
let output = cmd
|
|
.env_remove("XDG_CONFIG_HOME")
|
|
.env("HOME", home.path())
|
|
.arg("install-tool")
|
|
.assert()
|
|
.success()
|
|
.get_output()
|
|
.clone();
|
|
|
|
let path = home.path().join(".config/opencode/tool/worklane.ts");
|
|
assert_eq!(std::fs::read_to_string(&path).unwrap(), TOOL);
|
|
assert!(
|
|
stdout(&output).contains(&path.display().to_string()),
|
|
"{}",
|
|
stdout(&output)
|
|
);
|
|
}
|
|
|
|
/// The two commands are independent, which is the whole point of them being two: a
|
|
/// person on Claude Code takes the skills and never the tool, and one who wants the
|
|
/// tools is not made to take a second copy of the documents to get them.
|
|
#[test]
|
|
fn each_install_command_leaves_the_other_target_alone() {
|
|
let config = TempDir::new().unwrap();
|
|
run(&config, &["install-tool"]);
|
|
|
|
assert!(installed(&config).exists());
|
|
assert!(!config.path().join(".claude/skills").exists());
|
|
|
|
let skills_only = TempDir::new().unwrap();
|
|
run(&skills_only, &["install-skill"]);
|
|
|
|
assert!(
|
|
skills_only
|
|
.path()
|
|
.join(".claude/skills/worklane/SKILL.md")
|
|
.exists()
|
|
);
|
|
assert!(!installed(&skills_only).exists());
|
|
}
|