(dd36e97) Add install-skill, shipping the agent skill in the binary, and bump to 0.8.0
worklane's agent instructions only existed for someone with the repo checked out. Anyone who installed the binary with cargo install got no document at all, because cargo install places binaries and nothing else. The skill now lives at assets/SKILL.md and is embedded with include_str, so an installed copy can never be a different version from the binary that describes it. `worklane install-skill` writes it, `--print` sends it to stdout so a modified copy can be diffed, and a copy that was edited is reported and left alone unless --force: it may have been changed on purpose, and silently discarding that is worse than stopping. One path serves both agents, ~/.claude/skills/worklane/SKILL.md. That was settled empirically rather than from documentation: opencode 1.15.10 loads ~/.claude/skills as an external skill source alongside its own ~/.config/opencode/skill, and with HOME pointed at a temp directory holding only what install-skill wrote, `opencode debug skill` lists the document under the name worklane. Writing opencode's own path as well would be two copies of one document, free to drift, for no gain. The document is new rather than the one under .opencode, which is the user's and not this repo's to ship. The ticket-workflow prose moved out of AGENTS.md into it, so how to use worklane has one writer, and AGENTS.md points there. The mechanism is in install.rs rather than skill.rs, and install() takes its root as an argument: install-tool is coming, it needs a different root and the same compare-and-refuse logic, and passing the root is what lets the tests install into a temp directory instead of the home of whoever runs the suite. Three tests guard the document itself, which is the part that goes stale quietly: the frontmatter has to parse, every `worklane <x>` it shows has to be a real subcommand, and every subcommand outside NOT_FOR_AGENTS has to appear in it, so a new command cannot ship invisible to an agent. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5
parent
f740e42d1c
commit
6178d7bd3d
@@ -163,6 +163,17 @@ pub enum Command {
|
||||
#[arg(short, long)]
|
||||
owner: Option<String>,
|
||||
},
|
||||
|
||||
/// Install the agent skill that teaches an agent to use worklane
|
||||
InstallSkill {
|
||||
/// Overwrite an existing copy that has been modified
|
||||
#[arg(long)]
|
||||
force: bool,
|
||||
|
||||
/// Write it to stdout instead of installing it
|
||||
#[arg(long)]
|
||||
print: bool,
|
||||
},
|
||||
}
|
||||
|
||||
/// `set` replaces a field outright. Owner is deliberately absent: `chown` owns that
|
||||
|
||||
@@ -5,6 +5,7 @@ use std::io::{BufRead, IsTerminal, Write};
|
||||
use std::path::Path;
|
||||
|
||||
use crate::command::{AppendArgs, CheckArgs, SetArgs};
|
||||
use crate::install;
|
||||
use crate::util::*;
|
||||
|
||||
pub fn cmd_init(start: &Path) -> Result<()> {
|
||||
@@ -868,3 +869,33 @@ pub fn cmd_check(args: &CheckArgs, checked: bool, start: &Path) -> Result<()> {
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Install the agent skill, or print it so a modified copy can be diffed.
|
||||
///
|
||||
/// No board is looked for. The document is what teaches an agent worklane, so needing
|
||||
/// a `.worklane` to install it would put it out of reach exactly when it is wanted.
|
||||
pub fn cmd_install_skill(force: bool, print: bool) -> Result<()> {
|
||||
if print {
|
||||
print!("{}", install::SKILL.content);
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let root = install::skills_root()?;
|
||||
match install::SKILL.install(&root, force)? {
|
||||
install::Outcome::Written(path) => {
|
||||
println!("Installed the worklane {} to: {}", install::SKILL.what, path.display());
|
||||
println!("Claude Code and opencode pick it up on their next session");
|
||||
}
|
||||
install::Outcome::Unchanged(path) => {
|
||||
println!("Already up to date: {}", path.display());
|
||||
}
|
||||
install::Outcome::Refused(path) => {
|
||||
println!("Differs from the version in this binary: {}", path.display());
|
||||
println!(
|
||||
"Compare with `worklane install-skill --print`, or overwrite with --force"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
+282
@@ -0,0 +1,282 @@
|
||||
//! Shipping the agent assets with the binary.
|
||||
//!
|
||||
//! The skill document lives at `assets/SKILL.md` in this repo and is embedded with
|
||||
//! `include_str!` rather than copied by an install script, because `cargo install`
|
||||
//! places binaries and nothing else. Embedding means the document can never be a
|
||||
//! different version from the binary it describes, and there is no second file to
|
||||
//! lose track of.
|
||||
//!
|
||||
//! The machinery is written once for both assets this repo will ship. The tool file
|
||||
//! for opencode is executable code needing Bun, so it gets its own command and its
|
||||
//! own root, but the compare-and-refuse logic is the same and lives here.
|
||||
|
||||
use std::io;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use anyhow::{Result, anyhow};
|
||||
|
||||
/// One thing the binary carries and can write into a user's agent configuration.
|
||||
pub struct Asset {
|
||||
/// What it is called in messages, e.g. `skill`.
|
||||
pub what: &'static str,
|
||||
/// Where it goes under its root, e.g. `worklane/SKILL.md`.
|
||||
pub relative: &'static str,
|
||||
pub content: &'static str,
|
||||
}
|
||||
|
||||
/// The skill document, as of the commit this binary was built from.
|
||||
pub const SKILL: Asset = Asset {
|
||||
what: "skill",
|
||||
relative: "worklane/SKILL.md",
|
||||
content: include_str!("../assets/SKILL.md"),
|
||||
};
|
||||
|
||||
/// Where a skill has to sit to be found, for both agents worklane is used from.
|
||||
///
|
||||
/// One path serves both. Claude Code reads `~/.claude/skills/<name>/SKILL.md`, and
|
||||
/// opencode loads that same directory as an external skill source, alongside its own
|
||||
/// `~/.config/opencode/skill/`. Checked against opencode 1.15.10, whose built-in
|
||||
/// `customize-opencode` skill documents it and whose `opencode debug skill` lists the
|
||||
/// documents found there. Writing both paths would be two copies of one document, free
|
||||
/// to drift apart, for no gain.
|
||||
pub fn skills_root() -> Result<PathBuf> {
|
||||
let home = std::env::var_os("HOME").ok_or_else(|| {
|
||||
anyhow!("cannot tell where your skills live because HOME is not set in the environment")
|
||||
})?;
|
||||
|
||||
Ok(Path::new(&home).join(".claude/skills"))
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub enum Outcome {
|
||||
Written(PathBuf),
|
||||
/// Already byte-identical, so writing it again would be a no-op.
|
||||
Unchanged(PathBuf),
|
||||
/// Present but different, and no `--force`. Refused rather than overwritten: it
|
||||
/// may have been edited on purpose, and silently discarding that is worse than
|
||||
/// stopping.
|
||||
Refused(PathBuf),
|
||||
}
|
||||
|
||||
impl Asset {
|
||||
pub fn path(&self, root: &Path) -> PathBuf {
|
||||
root.join(self.relative)
|
||||
}
|
||||
|
||||
/// Write the asset under `root`, unless what is there is the same or was changed.
|
||||
///
|
||||
/// The root is passed in rather than looked up, so a test can install into a
|
||||
/// temporary directory instead of the home of whoever runs the suite.
|
||||
pub fn install(&self, root: &Path, force: bool) -> io::Result<Outcome> {
|
||||
let path = self.path(root);
|
||||
|
||||
// A read error is not treated as "absent": the write below reports it, with
|
||||
// the real reason, rather than this guessing that the file is missing.
|
||||
match std::fs::read_to_string(&path) {
|
||||
Ok(existing) if existing == self.content => return Ok(Outcome::Unchanged(path)),
|
||||
Ok(_) if !force => return Ok(Outcome::Refused(path)),
|
||||
_ => {}
|
||||
}
|
||||
|
||||
if let Some(parent) = path.parent() {
|
||||
std::fs::create_dir_all(parent)?;
|
||||
}
|
||||
std::fs::write(&path, self.content)?;
|
||||
|
||||
Ok(Outcome::Written(path))
|
||||
}
|
||||
}
|
||||
|
||||
/// The `name:` and `description:` from the YAML frontmatter.
|
||||
///
|
||||
/// Used by the tests that guard the shipping mechanism, which is the only thing that
|
||||
/// needs it: both agents decide whether to load a document from these two fields, and
|
||||
/// a document missing them is ignored in silence.
|
||||
#[cfg_attr(not(test), allow(dead_code))]
|
||||
fn frontmatter_field(text: &str, key: &str) -> Option<String> {
|
||||
let body = text.strip_prefix("---\n")?;
|
||||
let end = body.find("\n---")?;
|
||||
body[..end]
|
||||
.lines()
|
||||
.find_map(|line| line.strip_prefix(&format!("{key}:")))
|
||||
.map(|value| value.trim().to_string())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn root() -> tempfile::TempDir {
|
||||
tempfile::tempdir().unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_skill_installs_into_a_directory_that_does_not_exist_yet() {
|
||||
let root = root();
|
||||
let path = SKILL.path(root.path());
|
||||
|
||||
assert_eq!(
|
||||
SKILL.install(root.path(), false).unwrap(),
|
||||
Outcome::Written(path.clone())
|
||||
);
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), SKILL.content);
|
||||
}
|
||||
|
||||
/// Installing twice is a no-op rather than a rewrite, so the mtime of an
|
||||
/// up-to-date copy does not move.
|
||||
#[test]
|
||||
fn a_second_install_reports_the_copy_unchanged() {
|
||||
let root = root();
|
||||
SKILL.install(root.path(), false).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
SKILL.install(root.path(), false).unwrap(),
|
||||
Outcome::Unchanged(SKILL.path(root.path()))
|
||||
);
|
||||
}
|
||||
|
||||
/// The case worth being careful about: an edited copy is someone's work.
|
||||
#[test]
|
||||
fn a_modified_copy_is_refused_and_left_alone() {
|
||||
let root = root();
|
||||
let path = SKILL.path(root.path());
|
||||
SKILL.install(root.path(), false).unwrap();
|
||||
std::fs::write(&path, "hand written\n").unwrap();
|
||||
|
||||
assert_eq!(
|
||||
SKILL.install(root.path(), false).unwrap(),
|
||||
Outcome::Refused(path.clone())
|
||||
);
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), "hand written\n");
|
||||
|
||||
assert_eq!(
|
||||
SKILL.install(root.path(), true).unwrap(),
|
||||
Outcome::Written(path.clone())
|
||||
);
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), SKILL.content);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_skill_lands_where_both_agents_look_for_it() {
|
||||
let root = skills_root().unwrap();
|
||||
assert!(root.ends_with(".claude/skills"), "{}", root.display());
|
||||
assert!(
|
||||
SKILL.path(&root).ends_with(".claude/skills/worklane/SKILL.md"),
|
||||
"{}",
|
||||
SKILL.path(&root).display()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_embedded_skill_has_usable_frontmatter() {
|
||||
// Guards the whole shipping mechanism: without frontmatter, or under a name
|
||||
// that does not match its directory, both agents ignore the document and
|
||||
// nothing else would notice.
|
||||
assert_eq!(frontmatter_field(SKILL.content, "name").as_deref(), Some("worklane"));
|
||||
|
||||
let description =
|
||||
frontmatter_field(SKILL.content, "description").expect("a description to trigger on");
|
||||
assert!(
|
||||
description.len() > 80,
|
||||
"the description is what decides whether the skill loads at all"
|
||||
);
|
||||
}
|
||||
|
||||
/// Every code span and fenced-block line, which is where commands live.
|
||||
///
|
||||
/// Prose has to be excluded: the document opens by calling worklane a kanban
|
||||
/// board, and treating that sentence as a command makes the check useless.
|
||||
fn code_snippets(text: &str) -> Vec<String> {
|
||||
let mut snippets = Vec::new();
|
||||
let mut fenced = false;
|
||||
for line in text.lines() {
|
||||
if line.trim_start().starts_with("```") {
|
||||
fenced = !fenced;
|
||||
continue;
|
||||
}
|
||||
if fenced {
|
||||
snippets.push(line.to_string());
|
||||
continue;
|
||||
}
|
||||
// Inline spans: the odd-numbered pieces between backticks.
|
||||
for (index, piece) in line.split('`').enumerate() {
|
||||
if index % 2 == 1 {
|
||||
snippets.push(piece.to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
snippets
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_embedded_skill_only_names_commands_that_exist() {
|
||||
// Taken from clap rather than written out here. A hand-maintained list is the
|
||||
// very drift this test exists to catch.
|
||||
use clap::CommandFactory;
|
||||
let mut known: Vec<String> = crate::Cli::command()
|
||||
.get_subcommands()
|
||||
.map(|c| c.get_name().to_string())
|
||||
.collect();
|
||||
known.push("--help".to_string());
|
||||
known.push("--version".to_string());
|
||||
|
||||
let mut checked = 0;
|
||||
for snippet in code_snippets(SKILL.content) {
|
||||
let mut words = snippet.split_whitespace();
|
||||
// Only a snippet that *starts* with worklane is a command being shown.
|
||||
if words.next() != Some("worklane") {
|
||||
continue;
|
||||
}
|
||||
let Some(candidate) = words.next() else { continue };
|
||||
// A flag before the subcommand, as in the `mv -- -leading-title` example.
|
||||
if candidate.starts_with("--") && !known.iter().any(|k| k == candidate) {
|
||||
continue;
|
||||
}
|
||||
checked += 1;
|
||||
assert!(
|
||||
known.iter().any(|k| k == candidate),
|
||||
"the skill shows `worklane {candidate}`, which is not a subcommand"
|
||||
);
|
||||
}
|
||||
assert!(checked > 8, "expected the skill to show commands, checked only {checked}");
|
||||
}
|
||||
|
||||
/// Subcommands the skill has no business teaching: the board is interactive and
|
||||
/// belongs to a person, `install-skill` is how the document arrived, and `help`
|
||||
/// is clap's own.
|
||||
const NOT_FOR_AGENTS: [&str; 3] = ["tui", "install-skill", "help"];
|
||||
|
||||
/// The converse, and the one that goes stale on its own: a *new* subcommand absent
|
||||
/// from the skill is invisible to an agent, and nothing else would notice.
|
||||
#[test]
|
||||
fn every_agent_facing_subcommand_is_documented() {
|
||||
use clap::CommandFactory;
|
||||
for command in crate::Cli::command().get_subcommands() {
|
||||
let name = command.get_name();
|
||||
if NOT_FOR_AGENTS.contains(&name) {
|
||||
continue;
|
||||
}
|
||||
assert!(
|
||||
SKILL.content.contains(&format!("worklane {name}")),
|
||||
"the skill never mentions `worklane {name}`, so an agent will not know it exists"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The facts an agent cannot infer from the help output and would get wrong.
|
||||
#[test]
|
||||
fn the_embedded_skill_documents_what_the_help_does_not() {
|
||||
for required in [
|
||||
"committed",
|
||||
"as you work it",
|
||||
"UUID prefix",
|
||||
"leading hyphen",
|
||||
"Search the backlog before filing",
|
||||
] {
|
||||
assert!(
|
||||
SKILL.content.contains(required),
|
||||
"the skill no longer mentions {required:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3,6 +3,7 @@ use clap::Parser;
|
||||
|
||||
mod command;
|
||||
mod handlers;
|
||||
mod install;
|
||||
mod tui;
|
||||
mod util;
|
||||
|
||||
@@ -82,6 +83,9 @@ fn main() -> Result<()> {
|
||||
body,
|
||||
owner,
|
||||
}) => cmd_comment(&ticket, &body, &owner, &start),
|
||||
// No board is looked for: the point of the skill is to teach an agent worklane
|
||||
// before there is a `.worklane` anywhere.
|
||||
Some(Command::InstallSkill { force, print }) => cmd_install_skill(force, print),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user