use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use anyhow::{Context, Result};
#[derive(Debug, serde::Serialize, PartialEq)]
pub enum Severity {
Blocking,
Suggestion,
Nitpick,
}
#[derive(Debug, serde::Serialize)]
pub struct Finding {
pub skill: String,
pub check: String,
pub message: String,
pub severity: Severity,
}
#[derive(Debug, serde::Serialize)]
pub struct ReviewReport {
pub checks: u32,
pub findings: Vec<Finding>,
pub passed: bool,
}
impl ReviewReport {
fn new() -> Self {
Self {
checks: 0,
findings: vec![],
passed: true,
}
}
fn fail(&mut self, skill: impl Into<String>, check: impl Into<String>, msg: impl Into<String>) {
self.findings.push(Finding {
skill: skill.into(),
check: check.into(),
message: msg.into(),
severity: Severity::Blocking,
});
self.passed = false;
}
fn merge(&mut self, other: ReviewReport) {
self.checks += other.checks;
self.findings.extend(other.findings);
if !other.passed {
self.passed = false;
}
}
}
fn skills_dir(root: &Path) -> PathBuf {
root.join("skills")
}
fn agents_dir(root: &Path) -> PathBuf {
root.join("agents")
}
fn skill_dirs(root: &Path) -> Result<Vec<PathBuf>> {
let dir = skills_dir(root);
if !dir.exists() {
return Ok(vec![]);
}
let mut out = vec![];
for entry in fs::read_dir(&dir)? {
let entry = entry?;
if entry.file_type()?.is_dir() {
let name = entry.file_name();
if name != "_lib" {
out.push(entry.path());
}
}
}
out.sort();
Ok(out)
}
fn agent_files(root: &Path) -> Result<Vec<PathBuf>> {
let dir = agents_dir(root);
if !dir.exists() {
return Ok(vec![]);
}
let mut out = vec![];
for entry in fs::read_dir(&dir)? {
let entry = entry?;
let path = entry.path();
if path.extension().and_then(|e| e.to_str()) == Some("md") {
out.push(path);
}
}
out.sort();
Ok(out)
}
fn extract_fm_name(content: &str) -> Option<String> {
let mut in_fm = false;
let mut past_first = false;
for line in content.lines() {
if line == "---" {
if !past_first {
in_fm = true;
past_first = true;
} else {
break;
}
} else if in_fm && let Some(rest) = line.strip_prefix("name:") {
let val = rest.trim().trim_matches('"').trim().to_string();
if !val.is_empty() {
return Some(val);
}
}
}
None
}
fn extract_fm_field<'a>(content: &'a str, field: &str) -> Option<&'a str> {
let mut in_fm = false;
let mut past_first = false;
for line in content.lines() {
if line == "---" {
if !past_first {
in_fm = true;
past_first = true;
} else {
break;
}
} else if in_fm {
let prefix = format!("{field}:");
if let Some(rest) = line.strip_prefix(&prefix) {
return Some(rest.trim());
}
}
}
None
}
pub fn run_all(root: &Path) -> Result<ReviewReport> {
let mut report = ReviewReport::new();
report.merge(check_skills(root)?);
report.merge(check_agents(root)?);
report.merge(check_agent_naming(root)?);
report.merge(check_plugin_json(root)?);
report.merge(check_lib(root)?);
Ok(report)
}
pub fn check_skills(root: &Path) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let dirs = skill_dirs(root)?;
let index_names = load_skill_index_names(root)?;
let using_path = root.join("skills/using-godmode/SKILL.md");
let using_content = fs::read_to_string(&using_path).unwrap_or_default();
for dir in &dirs {
r.merge(check_skill_frontmatter(
root,
dir,
&index_names,
&using_content,
)?);
r.merge(check_skill_links(root, dir)?);
r.merge(check_skill_subcommands(dir)?);
r.merge(check_skill_consistency(dir)?);
}
r.merge(check_skill_index_entries(&dirs, &index_names));
Ok(r)
}
fn skill_name_of(dir: &Path) -> String {
dir.file_name()
.unwrap_or_default()
.to_string_lossy()
.to_string()
}
fn check_skill_frontmatter(
_root: &Path,
dir: &Path,
index_names: &std::collections::BTreeSet<String>,
using_content: &str,
) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let skill_name = skill_name_of(dir);
let skill_md = dir.join("SKILL.md");
r.checks += 1;
if !skill_md.exists() {
r.fail(
&skill_name,
"missing SKILL.md",
format!("[{skill_name}] missing SKILL.md"),
);
return Ok(r);
}
let content = fs::read_to_string(&skill_md)?;
r.checks += 1;
let fm_name = extract_fm_name(&content);
if fm_name.is_none() {
r.fail(
&skill_name,
"missing frontmatter name",
format!("[{skill_name}] missing or empty frontmatter name:"),
);
}
if let Some(ref full_name) = fm_name {
if skill_name != "using-godmode" {
r.checks += 1;
if !index_names.contains(&skill_name) {
r.fail(
&skill_name,
"not in skill-index.json",
format!("[{skill_name}] name '{full_name}' not found in skill-index.json"),
);
}
r.checks += 1;
if !using_content.contains(full_name.as_str()) {
r.fail(
&skill_name,
"not in using-godmode SKILL.md",
format!(
"[{skill_name}] name '{full_name}' not found in using-godmode/SKILL.md"
),
);
}
}
}
Ok(r)
}
fn load_skill_index_names(root: &Path) -> Result<std::collections::BTreeSet<String>> {
let path = root.join("skills/using-godmode/references/skill-index.json");
let content =
fs::read_to_string(&path).with_context(|| format!("cannot read {}", path.display()))?;
let value: serde_json::Value = serde_json::from_str(&content)
.with_context(|| format!("invalid JSON in {}", path.display()))?;
value
.get("skills")
.and_then(serde_json::Value::as_array)
.context("skill-index.json missing skills array")?
.iter()
.map(|entry| {
entry
.get("name")
.and_then(serde_json::Value::as_str)
.map(str::to_string)
.context("skill-index.json entry missing name")
})
.collect()
}
fn check_skill_index_entries(
dirs: &[PathBuf],
index_names: &std::collections::BTreeSet<String>,
) -> ReviewReport {
let mut report = ReviewReport::new();
for name in index_names {
report.checks += 1;
let exists = dirs
.iter()
.any(|dir| dir.file_name().unwrap_or_default().to_string_lossy() == name.as_str());
if !exists {
report.fail(
"index",
"orphan entry",
format!("[index] orphan entry {name} — no matching skills/{name}/ dir"),
);
}
}
report
}
fn check_skill_links(root: &Path, dir: &Path) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let skill_name = skill_name_of(dir);
let skill_md = dir.join("SKILL.md");
if !skill_md.exists() {
return Ok(r);
}
let content = fs::read_to_string(&skill_md)?;
for line in content.lines() {
if let Some(cap) = extract_backtick_path(line, "references/") {
if cap.ends_with(char::from(47)) {
continue;
}
r.checks += 1;
let resolved = dir.join(&cap);
if !resolved.exists() {
r.fail(
&skill_name,
"broken references link",
format!("[{skill_name}] broken references link: {cap}"),
);
}
}
}
for line in content.lines() {
if let Some(cap) = extract_backtick_path(line, "helpers/") {
if cap.ends_with(char::from(47)) {
continue;
}
r.checks += 1;
let resolved = dir.join(&cap);
if !resolved.exists() {
r.fail(
&skill_name,
"broken helpers link",
format!("[{skill_name}] broken helpers link: {cap}"),
);
}
}
}
for line in content.lines() {
if let Some(cap) = extract_backtick_path(line, "skills/_lib/") {
r.checks += 1;
let resolved = root.join(&cap);
if !resolved.exists() {
r.fail(
&skill_name,
"broken _lib link",
format!("[{skill_name}] broken _lib link: {cap}"),
);
}
}
}
Ok(r)
}
fn check_skill_subcommands(dir: &Path) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let skill_name = skill_name_of(dir);
let skill_md = dir.join("SKILL.md");
if !skill_md.exists() {
return Ok(r);
}
let content = fs::read_to_string(&skill_md)?;
for (lineno, line) in content.lines().enumerate() {
let trimmed = line.trim();
if !trimmed.starts_with("godmode ") {
continue;
}
let parts: Vec<&str> = trimmed
.split_whitespace()
.skip(1)
.filter(|p| !p.is_empty())
.collect();
if parts.is_empty() {
continue;
}
let first = parts[0];
if first.starts_with('-')
|| first.starts_with('<')
|| first.starts_with('$')
|| first.starts_with('#')
{
continue;
}
let two = if parts.len() >= 2 {
let second = parts[1];
if !second.starts_with('-')
&& !second.starts_with('<')
&& !second.starts_with('$')
&& !second.starts_with('[')
{
format!("{first} {second}")
} else {
String::new()
}
} else {
String::new()
};
r.checks += 1;
let matched = if !two.is_empty() {
CANONICAL_SUBCOMMANDS.contains(&two.as_str()) || CANONICAL_SUBCOMMANDS.contains(&first)
} else {
CANONICAL_SUBCOMMANDS.contains(&first)
};
if !matched {
let shown = if !two.is_empty() { &two } else { first };
r.fail(
&skill_name,
"unknown subcommand",
format!(
"[{skill_name}:{}] unknown subcommand: godmode {shown}",
lineno + 1
),
);
}
}
Ok(r)
}
fn check_skill_consistency(dir: &Path) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let skill_name = skill_name_of(dir);
let skill_md = dir.join("SKILL.md");
if !skill_md.exists() {
return Ok(r);
}
let content = fs::read_to_string(&skill_md)?;
r.checks += 1;
if content.contains("git merge") && !content.contains("--no-ff") {
r.fail(
&skill_name,
"merge strategy",
format!(
"[{skill_name}] consistency violation: merge strategy — mentions 'git merge' \
but not '--no-ff'"
),
);
}
r.checks += 1;
if content.contains("git commit") && !content.contains("git branch --show-current") {
r.fail(
&skill_name,
"branch guard",
format!(
"[{skill_name}] consistency violation: branch guard — has 'git commit' but no \
'git branch --show-current' check"
),
);
}
Ok(r)
}
pub fn check_agents(root: &Path) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let files = agent_files(root)?;
for path in &files {
r.merge(check_agent_frontmatter(root, path)?);
r.merge(check_agent_tools(path)?);
r.merge(check_agent_skill_refs(root, path)?);
}
Ok(r)
}
fn check_agent_frontmatter(root: &Path, path: &Path) -> Result<ReviewReport> {
use crate::agent_index;
let mut r = ReviewReport::new();
let agent_name = path
.file_stem()
.unwrap_or_default()
.to_string_lossy()
.to_string();
let content = fs::read_to_string(path)?;
for field in ["name", "model", "tools"] {
r.checks += 1;
match extract_fm_field(&content, field) {
None => {
r.fail(
&agent_name,
format!("missing {field}"),
format!("[{agent_name}] agent missing frontmatter field: {field}"),
);
}
Some("") => {
r.fail(
&agent_name,
format!("empty {field}"),
format!("[{agent_name}] agent frontmatter field empty: {field}"),
);
}
_ => {}
}
}
r.checks += 1;
let desc_raw = extract_fm_field(&content, "description").unwrap_or("");
let desc_text = desc_raw.trim();
let effective_desc = if desc_text.is_empty() {
agent_index::list_agents(root)
.ok()
.and_then(|agents| {
agents.into_iter().find(|a| {
a.path.file_stem().and_then(|s| s.to_str()).unwrap_or("") == agent_name
})
})
.map(|a| a.description)
.unwrap_or_default()
} else {
desc_text.to_string()
};
if effective_desc.is_empty() {
r.fail(
&agent_name,
"description empty",
format!("[{agent_name}] agent description is empty"),
);
} else if effective_desc.len() <= 20 {
r.fail(
&agent_name,
"description too short",
format!(
"[{agent_name}] agent description is too short ({} chars, need > 20)",
effective_desc.len()
),
);
}
Ok(r)
}
fn check_agent_tools(path: &Path) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let agent_name = path
.file_stem()
.unwrap_or_default()
.to_string_lossy()
.to_string();
let content = fs::read_to_string(path)?;
let tools_val = extract_fm_field(&content, "tools").unwrap_or("");
r.checks += 1;
if tools_val.trim().is_empty() || tools_val.trim() == "[]" {
r.fail(
&agent_name,
"tools empty",
format!("[{agent_name}] agent tools field is empty"),
);
}
Ok(r)
}
fn check_agent_skill_refs(root: &Path, path: &Path) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let agent_name = path
.file_stem()
.unwrap_or_default()
.to_string_lossy()
.to_string();
let content = fs::read_to_string(path)?;
let skills_val = extract_fm_field(&content, "skills").unwrap_or("");
if !skills_val.is_empty() {
for skill in skills_val
.split(',')
.map(|s| s.trim())
.filter(|s| !s.is_empty())
{
r.checks += 1;
let skill_dir = root.join("skills").join(skill);
if !skill_dir.exists() {
r.fail(
&agent_name,
"unknown skill reference",
format!(
"[{agent_name}] skill '{skill}' referenced but skills/{skill}/ does \
not exist"
),
);
}
}
}
Ok(r)
}
pub fn check_agent_naming(root: &Path) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let files = agent_files(root)?;
for path in &files {
let content = fs::read_to_string(path)?;
let agent_file = path
.file_stem()
.unwrap_or_default()
.to_string_lossy()
.to_string();
if let Some(name) = extract_fm_name(&content) {
r.checks += 1;
let is_exception =
name == "valerie" || name == "godmode-crate-agent" || name == "gm-crate";
if !name.starts_with("gm-") && !is_exception {
r.findings.push(Finding {
skill: agent_file,
check: "naming convention".into(),
message: format!("[{name}] agent name does not follow gm-* convention"),
severity: Severity::Suggestion,
});
}
}
}
Ok(r)
}
pub fn check_plugin_json(root: &Path) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let plugin_path = root.join(".claude-plugin/plugin.json");
r.checks += 1;
if !plugin_path.exists() {
r.fail(
"plugin.json",
"file not found",
"[plugin.json] file not found at .claude-plugin/plugin.json",
);
return Ok(r);
}
let content = fs::read_to_string(&plugin_path)?;
let json: serde_json::Value = serde_json::from_str(&content)?;
if let Some(obj) = json.as_object() {
r.merge(validate_plugin_fields(obj));
}
Ok(r)
}
fn validate_plugin_fields(obj: &serde_json::Map<String, serde_json::Value>) -> ReviewReport {
let mut r = ReviewReport::new();
let allowed = ["name", "version", "author", "description"];
for key in obj.keys() {
r.checks += 1;
if !allowed.contains(&key.as_str()) {
r.fail(
"plugin.json",
"disallowed field",
format!("[plugin.json] disallowed field: {key}"),
);
}
}
if let Some(author) = obj.get("author").and_then(|a| a.as_object()) {
for key in author.keys() {
r.checks += 1;
if key != "name" {
r.fail(
"plugin.json",
"disallowed author field",
format!("[plugin.json] disallowed author field: {key}"),
);
}
}
}
r
}
pub fn check_lib(root: &Path) -> Result<ReviewReport> {
let mut r = ReviewReport::new();
let lib_dir = root.join("skills/_lib");
if !lib_dir.exists() {
return Ok(r);
}
for entry in fs::read_dir(&lib_dir)? {
let entry = entry?;
let path = entry.path();
if path.extension().and_then(|e| e.to_str()) != Some("nu") {
continue;
}
let lib_name = path
.file_name()
.unwrap_or_default()
.to_string_lossy()
.to_string();
r.checks += 1;
let out = Command::new("nu")
.args(["-c", &format!("use {}", path.display())])
.output();
match out {
Err(_) => {} Ok(o) if !o.status.success() => {
let err = String::from_utf8_lossy(&o.stderr);
let first_line = err.lines().next().unwrap_or("").trim().to_string();
r.fail(
format!("_lib/{lib_name}"),
"parse error",
format!("[_lib/{lib_name}] parse error: {first_line}"),
);
}
_ => {}
}
}
Ok(r)
}
const CANONICAL_SUBCOMMANDS: &[&str] = &[
"handon",
"handoff",
"status",
"context",
"visualize-graph",
"pin",
"unpin",
"init",
"doctor",
"memory-banking",
"task list",
"task next",
"task add",
"task start",
"task done",
"task block",
"task unblock",
"task unblock-all",
"task run",
"task remove",
"task clear",
"task pull",
"task push-done",
"task apply",
"task list-templates",
"plan ingest",
"dispatch",
"agent",
"hook",
"skill",
"pipeline",
"policy",
"insight",
"session",
"workflow",
"scaffold",
"test-check",
"agent list",
"agent index",
"agent dispatch",
"verify",
"wave init",
"wave status",
"wave done",
"wave block",
"wave check",
"worktree add",
"worktree remove",
"ci triage",
"issue list",
"issue close",
"issue sync-todos",
"graph build",
"review self",
"review skills",
"review agents",
"release current",
"release bump",
"release tag",
"release push",
"release validate",
"release changelog",
"session prune",
"agent generate",
"agent migrate",
"skill list",
"skill install",
"skill uninstall",
"hook list",
"hook log",
"hook test",
"hook migrate",
"workflow run",
"workflow list",
"workflow status",
"visualize-graph",
];
fn extract_backtick_path(line: &str, prefix: &str) -> Option<String> {
let mut rest = line;
while let Some(start) = rest.find('`') {
rest = &rest[start + 1..];
if let Some(end) = rest.find('`') {
let inner = &rest[..end];
if inner.starts_with(prefix) {
return inner.split_whitespace().next().map(str::to_string);
}
rest = &rest[end + 1..];
} else {
break;
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use tempfile::TempDir;
fn make_skill(dir: &Path, name: &str, fm_name: &str) {
let skill_dir = dir.join("skills").join(name);
fs::create_dir_all(&skill_dir).unwrap();
fs::write(
skill_dir.join("SKILL.md"),
format!("---\nname: \"{fm_name}\"\n---\n\nContent.\n"),
)
.unwrap();
}
fn make_index(dir: &Path, entries: &[&str]) {
let ref_dir = dir.join("skills/using-godmode/references");
fs::create_dir_all(&ref_dir).unwrap();
let skills: Vec<serde_json::Value> = entries
.iter()
.map(|entry| serde_json::json!({"name": entry.trim_start_matches("godmode:")}))
.collect();
fs::write(
ref_dir.join("skill-index.json"),
serde_json::to_string(&serde_json::json!({"skills": skills})).unwrap(),
)
.unwrap();
}
fn make_using_godmode(dir: &Path, entries: &[&str]) {
let skill_dir = dir.join("skills/using-godmode");
fs::create_dir_all(&skill_dir).unwrap();
let body: String = entries.iter().map(|e| format!("{e}\n")).collect();
fs::write(
skill_dir.join("SKILL.md"),
format!("---\nname: \"godmode:using-godmode\"\n---\n\n{body}"),
)
.unwrap();
}
fn minimal_fixture() -> TempDir {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
make_skill(root, "brainstorm", "godmode:brainstorm");
make_index(root, &["godmode:brainstorm"]);
make_using_godmode(root, &["godmode:brainstorm"]);
tmp
}
#[test]
fn all_checks_pass_on_clean_fixture() {
let tmp = minimal_fixture();
let r = check_skills(tmp.path()).unwrap();
assert!(r.passed, "findings: {:?}", r.findings);
}
#[test]
fn detects_missing_skill_md() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
fs::create_dir_all(root.join("skills/empty-skill")).unwrap();
make_index(root, &[]);
make_using_godmode(root, &[]);
let r = check_skills(root).unwrap();
assert!(!r.passed);
assert!(r.findings.iter().any(|f| f.check == "missing SKILL.md"));
}
#[test]
fn detects_missing_frontmatter_name() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let skill_dir = root.join("skills/no-name");
fs::create_dir_all(&skill_dir).unwrap();
fs::write(skill_dir.join("SKILL.md"), "---\n---\n\nContent.\n").unwrap();
make_index(root, &[]);
make_using_godmode(root, &[]);
let r = check_skills(root).unwrap();
assert!(!r.passed);
assert!(
r.findings
.iter()
.any(|f| f.check == "missing frontmatter name")
);
}
#[test]
fn detects_frontmatter_missing_from_using_godmode_table() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
make_skill(root, "brainstorm", "godmode:brainstorm");
make_index(root, &["godmode:brainstorm"]);
make_using_godmode(root, &[]);
let report = check_skills(root).unwrap();
assert!(
report
.findings
.iter()
.any(|finding| finding.check == "not in using-godmode SKILL.md")
);
}
#[test]
fn detects_orphan_index_entry() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
make_index(root, &["godmode:ghost"]);
make_using_godmode(root, &[]);
let r = check_skills(root).unwrap();
assert!(!r.passed);
assert!(r.findings.iter().any(|f| f.check == "orphan entry"));
}
#[test]
fn detects_broken_references_link() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let skill_dir = root.join("skills/miskill");
fs::create_dir_all(&skill_dir).unwrap();
fs::write(
skill_dir.join("SKILL.md"),
"---\nname: \"godmode:miskill\"\n---\n\nSee `references/missing.md`.\n",
)
.unwrap();
make_index(root, &["godmode:miskill"]);
make_using_godmode(root, &["godmode:miskill"]);
let r = check_skills(root).unwrap();
assert!(!r.passed);
assert!(
r.findings
.iter()
.any(|f| f.check == "broken references link")
);
}
#[test]
fn detects_agent_missing_model_field() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let agents_dir = root.join("agents");
fs::create_dir_all(&agents_dir).unwrap();
fs::write(
agents_dir.join("my-agent.md"),
"---\nname: my-agent\ntools: [Read]\n---\n\nBody.\n",
)
.unwrap();
let r = check_agents(root).unwrap();
assert!(!r.passed);
assert!(r.findings.iter().any(|f| f.check == "missing model"));
}
#[test]
fn extract_fm_name_parses_quoted_and_unquoted() {
assert_eq!(
extract_fm_name("---\nname: \"godmode:foo\"\n---\n"),
Some("godmode:foo".to_string())
);
assert_eq!(
extract_fm_name("---\nname: godmode:bar\n---\n"),
Some("godmode:bar".to_string())
);
assert_eq!(extract_fm_name("---\n---\n"), None);
}
#[test]
fn plugin_json_check_passes_on_valid_file() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
fs::create_dir_all(root.join(".claude-plugin")).unwrap();
fs::write(
root.join(".claude-plugin/plugin.json"),
r#"{"name":"godmode","version":"1.0.0","author":{"name":"Joe"},"description":"x"}"#,
)
.unwrap();
let r = check_plugin_json(root).unwrap();
assert!(r.passed, "findings: {:?}", r.findings);
}
#[test]
fn agent_naming_flags_non_gm_prefix() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let agents_dir = root.join("agents");
fs::create_dir_all(&agents_dir).unwrap();
fs::write(
agents_dir.join("bad-agent.md"),
"---\nname: my-custom-agent\nmodel: sonnet\ntools: [Read]\ndescription: does things and more stuff\n---\n\nBody.\n",
)
.unwrap();
let r = check_agent_naming(root).unwrap();
assert_eq!(r.findings.len(), 1);
assert_eq!(r.findings[0].check, "naming convention");
}
#[test]
fn agent_naming_allows_gm_prefix() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let agents_dir = root.join("agents");
fs::create_dir_all(&agents_dir).unwrap();
fs::write(
agents_dir.join("good-agent.md"),
"---\nname: gm-review\nmodel: sonnet\ntools: [Read]\ndescription: does reviews of code changes\n---\n\nBody.\n",
)
.unwrap();
let r = check_agent_naming(root).unwrap();
assert!(r.findings.is_empty());
}
#[test]
fn agent_naming_allows_exceptions() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let agents_dir = root.join("agents");
fs::create_dir_all(&agents_dir).unwrap();
fs::write(
agents_dir.join("valerie.md"),
"---\nname: valerie\nmodel: sonnet\ntools: [Read]\ndescription: task management specialist agent\n---\n\nBody.\n",
)
.unwrap();
let r = check_agent_naming(root).unwrap();
assert!(r.findings.is_empty());
}
#[test]
fn canonical_subcommands_include_native_issue_sync() {
assert!(CANONICAL_SUBCOMMANDS.contains(&"issue sync-todos"));
}
#[test]
fn plugin_json_check_fails_on_extra_field() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
fs::create_dir_all(root.join(".claude-plugin")).unwrap();
fs::write(
root.join(".claude-plugin/plugin.json"),
r#"{"name":"x","version":"1.0.0","author":{"name":"Joe"},"description":"y","extra":"bad"}"#,
)
.unwrap();
let r = check_plugin_json(root).unwrap();
assert!(!r.passed);
assert!(r.findings.iter().any(|f| f.check == "disallowed field"));
}
}