@cristobalme/skill-test 0.1.0

package/dist/bin/skill-test.js

@@ -0,0 +1,1290 @@
+#!/usr/bin/env node
+
+// bin/skill-test.ts
+import { Command } from "commander";
+
+// package.json
+var package_default = {
+  name: "@cristobalme/skill-test",
+  version: "0.1.0",
+  description: "Test agent Skills (SKILL.md): static lint, activation triggering, and behavioral grading. Zero-config, offline-capable, CI-first.",
+  license: "MIT",
+  author: "Cristobal Medina Meza",
+  type: "module",
+  bin: {
+    "skill-test": "dist/bin/skill-test.js",
+    "skill-test-comment": "dist/action/comment.js"
+  },
+  main: "dist/index.js",
+  module: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    }
+  },
+  files: [
+    "dist/index.*",
+    "dist/bin",
+    "dist/action",
+    "action/action.yml",
+    "examples",
+    "README.md",
+    "LICENSE"
+  ],
+  engines: {
+    node: ">=18"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  keywords: [
+    "skill",
+    "skills",
+    "agent",
+    "agent-skills",
+    "SKILL.md",
+    "lint",
+    "test",
+    "ci",
+    "claude",
+    "anthropic"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest run",
+    "test:watch": "vitest",
+    typecheck: "tsc --noEmit",
+    lint: "eslint .",
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    "audit:skills": "node dist/scripts/audit.js",
+    prepublishOnly: "npm run build"
+  },
+  dependencies: {
+    "@anthropic-ai/sdk": "^0.32.1",
+    commander: "^12.1.0",
+    yaml: "^2.6.1"
+  },
+  devDependencies: {
+    "@eslint/js": "^9.17.0",
+    "@types/node": "^22.10.0",
+    "@typescript-eslint/eslint-plugin": "^8.18.0",
+    "@typescript-eslint/parser": "^8.18.0",
+    eslint: "^9.17.0",
+    prettier: "^3.4.2",
+    tsup: "^8.3.5",
+    typescript: "^5.7.2",
+    vitest: "^2.1.8"
+  }
+};
+
+// src/cli/commands.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+
+// src/types.ts
+var EXIT = {
+  OK: 0,
+  FAILURES: 1,
+  USAGE: 2
+};
+
+// src/cli/discover.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { basename, join, resolve } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".skill-test-cache"]);
+function discoverSkills(paths) {
+  const found = /* @__PURE__ */ new Set();
+  for (const p of paths) {
+    const abs = resolve(p);
+    if (!existsSync(abs)) continue;
+    const st = statSync(abs);
+    if (st.isFile()) {
+      if (basename(abs) === "SKILL.md") found.add(abs);
+      continue;
+    }
+    if (st.isDirectory()) {
+      const direct = join(abs, "SKILL.md");
+      if (existsSync(direct)) {
+        found.add(direct);
+      } else {
+        for (const f of walk(abs)) found.add(f);
+      }
+    }
+  }
+  return [...found].sort();
+}
+function* walk(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      yield* walk(join(dir, entry.name));
+    } else if (entry.isFile() && entry.name === "SKILL.md") {
+      yield join(dir, entry.name);
+    }
+  }
+}
+
+// src/parser/parse.ts
+import { readFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { parse as parseYaml } from "yaml";
+
+// src/parser/tokens.ts
+function estimateTokens(text) {
+  if (!text) return 0;
+  const chars = text.length;
+  const words = text.trim().split(/\s+/).filter(Boolean).length;
+  const byChars = chars / 4;
+  const byWords = words * 1.3;
+  return Math.ceil(Math.max(byChars, byWords));
+}
+
+// src/parser/parse.ts
+var FRONTMATTER_DELIM = /^---\s*$/;
+function parseSkillFile(path) {
+  const abs = resolve2(path);
+  let raw;
+  try {
+    raw = readFileSync(abs, "utf8");
+  } catch (err2) {
+    return emptyParsed(abs, `could not read file: ${err2.message}`);
+  }
+  return parseSkillContent(raw, abs);
+}
+function parseSkillContent(raw, path) {
+  const abs = resolve2(path);
+  const dir = dirname(abs);
+  const normalized = raw.replace(/\r\n/g, "\n");
+  const lines = normalized.split("\n");
+  const first = stripBom(lines[0] ?? "");
+  if (!FRONTMATTER_DELIM.test(first)) {
+    return {
+      path: abs,
+      dir,
+      frontmatter: {},
+      body: normalized,
+      bodyStartLine: 1,
+      bodyTokens: estimateTokens(normalized),
+      bodyLines: countBodyLines(normalized),
+      hasFrontmatter: false
+    };
+  }
+  let closeIdx = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (FRONTMATTER_DELIM.test(lines[i] ?? "")) {
+      closeIdx = i;
+      break;
+    }
+  }
+  if (closeIdx === -1) {
+    return {
+      path: abs,
+      dir,
+      frontmatter: {},
+      body: normalized,
+      bodyStartLine: 1,
+      bodyTokens: estimateTokens(normalized),
+      bodyLines: countBodyLines(normalized),
+      hasFrontmatter: false,
+      parseError: "frontmatter opening '---' has no matching closing '---'"
+    };
+  }
+  const yamlText = lines.slice(1, closeIdx).join("\n");
+  const bodyLinesArr = lines.slice(closeIdx + 1);
+  const body = bodyLinesArr.join("\n");
+  const bodyStartLine = closeIdx + 2;
+  let frontmatter = {};
+  let parseError;
+  try {
+    const parsed = parseYaml(yamlText);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      frontmatter = parsed;
+    } else if (parsed != null) {
+      parseError = "frontmatter is not a YAML mapping";
+    }
+  } catch (err2) {
+    parseError = `invalid YAML frontmatter: ${err2.message}`;
+  }
+  return {
+    path: abs,
+    dir,
+    frontmatter,
+    body,
+    bodyStartLine,
+    bodyTokens: estimateTokens(body),
+    bodyLines: countBodyLines(body),
+    hasFrontmatter: parseError === void 0,
+    parseError
+  };
+}
+var BOM = String.fromCharCode(65279);
+function stripBom(s) {
+  return s.startsWith(BOM) ? s.slice(1) : s;
+}
+function countBodyLines(body) {
+  const trimmed = body.replace(/\n+$/, "");
+  if (trimmed === "") return 0;
+  return trimmed.split("\n").length;
+}
+function emptyParsed(abs, parseError) {
+  return {
+    path: abs,
+    dir: dirname(abs),
+    frontmatter: {},
+    body: "",
+    bodyStartLine: 1,
+    bodyTokens: 0,
+    bodyLines: 0,
+    hasFrontmatter: false,
+    parseError
+  };
+}
+
+// src/lint/rules.ts
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { basename as basename2, resolve as resolve3 } from "path";
+
+// src/spec.ts
+var NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var NAME_MAX_LENGTH = 64;
+var DESCRIPTION_MAX_LENGTH = 1024;
+var COMPATIBILITY_MAX_LENGTH = 500;
+var BODY_RECOMMENDED_MAX_TOKENS = 5e3;
+var BODY_WARN_TOKENS = Math.floor(BODY_RECOMMENDED_MAX_TOKENS * 0.9);
+var BODY_RECOMMENDED_MAX_LINES = 500;
+var KNOWN_FRONTMATTER_FIELDS = [
+  "name",
+  "description",
+  "license",
+  "compatibility",
+  "metadata",
+  "allowed-tools"
+];
+
+// src/lint/locate.ts
+function lineOf(skill, needle) {
+  if (!needle) return void 0;
+  const idx = skill.body.indexOf(needle);
+  if (idx === -1) return void 0;
+  const before = skill.body.slice(0, idx);
+  const newlines = before.split("\n").length - 1;
+  return skill.bodyStartLine + newlines;
+}
+
+// src/lint/security.ts
+var PATTERNS = [
+  {
+    ruleId: "security/rm-rf",
+    severity: "warn",
+    regex: /\brm\s+-[a-z]*r[a-z]*f|\brm\s+-[a-z]*f[a-z]*r/i,
+    message: "instruction uses `rm -rf`; destructive deletes should be scoped and confirmed"
+  },
+  {
+    ruleId: "security/curl-pipe-sh",
+    severity: "warn",
+    regex: /\b(curl|wget)\b[^\n|]*\|\s*(sudo\s+)?(ba|z|d)?sh\b/i,
+    message: "instruction pipes a download straight into a shell (`curl \u2026 | sh`)"
+  },
+  {
+    ruleId: "security/read-credentials",
+    severity: "warn",
+    regex: /(\.env\b|id_rsa\b|id_ed25519\b|\.ssh\/|\.aws\/credentials|\.npmrc\b|private[_ -]?key)/i,
+    message: "instruction references credentials or secret material (.env, SSH/AWS keys, etc.)"
+  },
+  {
+    ruleId: "security/exfiltration",
+    severity: "info",
+    regex: /\b(curl|wget|fetch)\b[^\n]*(-d|--data|-X\s*POST|--upload-file)[^\n]*https?:\/\//i,
+    message: "instruction sends data to an external URL; verify this is not exfiltration"
+  }
+];
+function securityRule(skill) {
+  if (!skill.body) return [];
+  const findings = [];
+  for (const p of PATTERNS) {
+    const m = skill.body.match(p.regex);
+    if (m) {
+      findings.push({
+        ruleId: p.ruleId,
+        severity: p.severity,
+        message: p.message,
+        file: skill.path,
+        line: lineOf(skill, m[0])
+      });
+    }
+  }
+  return findings;
+}
+
+// src/lint/rules.ts
+var charLen = (s) => [...s].length;
+function at(skill, partial) {
+  return { file: skill.path, ...partial };
+}
+var frontmatterRule = (skill) => {
+  if (skill.parseError && !skill.hasFrontmatter) {
+    return [
+      at(skill, { ruleId: "frontmatter", severity: "error", message: skill.parseError, line: 1 })
+    ];
+  }
+  if (!skill.hasFrontmatter) {
+    return [
+      at(skill, {
+        ruleId: "frontmatter",
+        severity: "error",
+        message: "missing YAML frontmatter (a SKILL.md must begin with a '---' block)",
+        line: 1
+      })
+    ];
+  }
+  return [];
+};
+var nameRule = (skill) => {
+  if (!skill.hasFrontmatter) return [];
+  const findings = [];
+  const name = skill.frontmatter.name;
+  if (name === void 0 || name === null || name === "") {
+    return [
+      at(skill, {
+        ruleId: "name-required",
+        severity: "error",
+        message: "frontmatter is missing the required `name` field",
+        line: 1
+      })
+    ];
+  }
+  if (typeof name !== "string") {
+    return [
+      at(skill, {
+        ruleId: "name-type",
+        severity: "error",
+        message: `\`name\` must be a string, got ${typeof name}`,
+        line: 1
+      })
+    ];
+  }
+  if (charLen(name) > NAME_MAX_LENGTH) {
+    findings.push(
+      at(skill, {
+        ruleId: "name-length",
+        severity: "error",
+        message: `\`name\` is ${charLen(name)} chars; max is ${NAME_MAX_LENGTH}`,
+        line: 1
+      })
+    );
+  }
+  if (!NAME_PATTERN.test(name)) {
+    findings.push(
+      at(skill, {
+        ruleId: "name-pattern",
+        severity: "error",
+        message: `\`name\` "${name}" must be lowercase a-z, 0-9 and single hyphens, not starting/ending with a hyphen`,
+        line: 1
+      })
+    );
+  }
+  return findings;
+};
+var nameDirMatchRule = (skill) => {
+  if (!skill.hasFrontmatter) return [];
+  const name = skill.frontmatter.name;
+  if (typeof name !== "string" || name === "") return [];
+  const dirName = basename2(skill.dir);
+  if (name !== dirName) {
+    return [
+      at(skill, {
+        ruleId: "name-dir-match",
+        severity: "error",
+        message: `\`name\` "${name}" must match the parent directory name "${dirName}"`,
+        line: 1
+      })
+    ];
+  }
+  return [];
+};
+var descriptionRule = (skill) => {
+  if (!skill.hasFrontmatter) return [];
+  const desc = skill.frontmatter.description;
+  if (desc === void 0 || desc === null || desc === "") {
+    return [
+      at(skill, {
+        ruleId: "description-required",
+        severity: "error",
+        message: "frontmatter is missing the required, non-empty `description` field",
+        line: 1
+      })
+    ];
+  }
+  if (typeof desc !== "string") {
+    return [
+      at(skill, {
+        ruleId: "description-type",
+        severity: "error",
+        message: `\`description\` must be a string, got ${typeof desc}`,
+        line: 1
+      })
+    ];
+  }
+  if (desc.trim() === "") {
+    return [
+      at(skill, {
+        ruleId: "description-required",
+        severity: "error",
+        message: "`description` must not be blank",
+        line: 1
+      })
+    ];
+  }
+  if (charLen(desc) > DESCRIPTION_MAX_LENGTH) {
+    return [
+      at(skill, {
+        ruleId: "description-length",
+        severity: "error",
+        message: `\`description\` is ${charLen(desc)} chars; max is ${DESCRIPTION_MAX_LENGTH}`,
+        line: 1
+      })
+    ];
+  }
+  return [];
+};
+var compatibilityRule = (skill) => {
+  if (!skill.hasFrontmatter) return [];
+  const c = skill.frontmatter.compatibility;
+  if (c === void 0 || c === null) return [];
+  if (typeof c !== "string") {
+    return [
+      at(skill, {
+        ruleId: "compatibility-type",
+        severity: "error",
+        message: `\`compatibility\` must be a string, got ${typeof c}`,
+        line: 1
+      })
+    ];
+  }
+  if (charLen(c) > COMPATIBILITY_MAX_LENGTH) {
+    return [
+      at(skill, {
+        ruleId: "compatibility-length",
+        severity: "error",
+        message: `\`compatibility\` is ${charLen(c)} chars; max is ${COMPATIBILITY_MAX_LENGTH}`,
+        line: 1
+      })
+    ];
+  }
+  return [];
+};
+var metadataRule = (skill) => {
+  if (!skill.hasFrontmatter) return [];
+  const m = skill.frontmatter.metadata;
+  if (m === void 0 || m === null) return [];
+  if (typeof m !== "object" || Array.isArray(m)) {
+    return [
+      at(skill, {
+        ruleId: "metadata-type",
+        severity: "error",
+        message: "`metadata` must be a mapping of string keys to string values",
+        line: 1
+      })
+    ];
+  }
+  const findings = [];
+  for (const [k, v] of Object.entries(m)) {
+    if (typeof v !== "string") {
+      findings.push(
+        at(skill, {
+          ruleId: "metadata-value-type",
+          severity: "warn",
+          message: `\`metadata.${k}\` should be a string (the spec defines metadata as string\u2192string)`,
+          line: 1
+        })
+      );
+    }
+  }
+  return findings;
+};
+var allowedToolsRule = (skill) => {
+  if (!skill.hasFrontmatter) return [];
+  const a = skill.frontmatter["allowed-tools"];
+  if (a === void 0 || a === null) return [];
+  if (typeof a !== "string") {
+    return [
+      at(skill, {
+        ruleId: "allowed-tools-type",
+        severity: "warn",
+        message: "`allowed-tools` should be a space-separated string",
+        line: 1
+      })
+    ];
+  }
+  return [];
+};
+var unknownFieldsRule = (skill) => {
+  if (!skill.hasFrontmatter) return [];
+  const known = new Set(KNOWN_FRONTMATTER_FIELDS);
+  const findings = [];
+  for (const key of Object.keys(skill.frontmatter)) {
+    if (!known.has(key)) {
+      findings.push(
+        at(skill, {
+          ruleId: "unknown-field",
+          severity: "info",
+          message: `frontmatter field \`${key}\` is not defined by the Agent Skills spec`,
+          line: 1
+        })
+      );
+    }
+  }
+  return findings;
+};
+var bodyRule = (skill) => {
+  const findings = [];
+  if (skill.body.trim() === "") {
+    findings.push(
+      at(skill, {
+        ruleId: "body-empty",
+        severity: "warn",
+        message: "SKILL.md body is empty; add instructions for the agent",
+        line: skill.bodyStartLine
+      })
+    );
+    return findings;
+  }
+  if (skill.bodyTokens > BODY_RECOMMENDED_MAX_TOKENS) {
+    findings.push(
+      at(skill, {
+        ruleId: "body-size",
+        severity: "warn",
+        message: `body is ~${skill.bodyTokens} tokens; spec recommends under ${BODY_RECOMMENDED_MAX_TOKENS}. Move detail into referenced files.`,
+        line: skill.bodyStartLine
+      })
+    );
+  } else if (skill.bodyTokens >= BODY_WARN_TOKENS) {
+    findings.push(
+      at(skill, {
+        ruleId: "body-size",
+        severity: "info",
+        message: `body is ~${skill.bodyTokens} tokens, approaching the ${BODY_RECOMMENDED_MAX_TOKENS}-token recommendation`,
+        line: skill.bodyStartLine
+      })
+    );
+  }
+  if (skill.bodyLines > BODY_RECOMMENDED_MAX_LINES) {
+    findings.push(
+      at(skill, {
+        ruleId: "body-lines",
+        severity: "warn",
+        message: `SKILL.md body is ${skill.bodyLines} lines; spec recommends keeping it under ${BODY_RECOMMENDED_MAX_LINES}`,
+        line: skill.bodyStartLine
+      })
+    );
+  }
+  return findings;
+};
+var URLISH = /^(https?:|mailto:|tel:|#|\/\/)/i;
+function extractReferences(body) {
+  const candidates = /* @__PURE__ */ new Set();
+  const linkRe = /\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+  for (const m of body.matchAll(linkRe)) {
+    if (m[1]) candidates.add(m[1].trim());
+  }
+  const bareRe = /(?:^|[\s`("'])((?:scripts|references|assets)\/[\w./-]+)/g;
+  for (const m of body.matchAll(bareRe)) {
+    if (m[1]) candidates.add(m[1].trim());
+  }
+  return [...candidates].filter(isLocalFileRef);
+}
+function isLocalFileRef(p) {
+  if (!p) return false;
+  if (URLISH.test(p)) return false;
+  if (p.startsWith("/")) return false;
+  return p.includes("/") || /\.[a-z0-9]+$/i.test(p);
+}
+var referencesRule = (skill) => {
+  const findings = [];
+  for (const ref of extractReferences(skill.body)) {
+    const cleaned = ref.replace(/^\.\//, "");
+    const abs = resolve3(skill.dir, cleaned);
+    const exists = existsSync2(abs);
+    if (!exists) {
+      findings.push(
+        at(skill, {
+          ruleId: "missing-reference",
+          severity: "error",
+          message: `references a file that does not exist on disk: ${ref}`,
+          line: lineOf(skill, ref)
+        })
+      );
+      continue;
+    }
+    const segments = cleaned.split("/").filter(Boolean);
+    if (segments.length > 2 && statSync2(abs).isFile()) {
+      findings.push(
+        at(skill, {
+          ruleId: "reference-depth",
+          severity: "info",
+          message: `referenced file "${ref}" is more than one level deep; the spec recommends shallow references`,
+          line: lineOf(skill, ref)
+        })
+      );
+    }
+  }
+  return findings;
+};
+var rules = [
+  frontmatterRule,
+  nameRule,
+  nameDirMatchRule,
+  descriptionRule,
+  compatibilityRule,
+  metadataRule,
+  allowedToolsRule,
+  unknownFieldsRule,
+  bodyRule,
+  referencesRule,
+  securityRule
+];
+
+// src/lint/lint.ts
+function lintSkill(skillPath) {
+  const skill = parseSkillFile(skillPath);
+  const findings = [];
+  for (const rule of rules) {
+    findings.push(...rule(skill));
+  }
+  findings.sort(byLineThenSeverity);
+  return {
+    layer: "lint",
+    skillPath: skill.path,
+    findings,
+    ok: !findings.some((f) => f.severity === "error")
+  };
+}
+var SEVERITY_ORDER = { error: 0, warn: 1, info: 2 };
+function byLineThenSeverity(a, b) {
+  const la = a.line ?? 0;
+  const lb = b.line ?? 0;
+  if (la !== lb) return la - lb;
+  return SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];
+}
+
+// src/trigger/run-trigger.ts
+import { join as join3 } from "path";
+
+// src/trigger/classify.ts
+var DEFAULT_MODEL = "claude-haiku-4-5-20251001";
+async function classifyPrompts(meta, prompts, backend, cache) {
+  const results = [];
+  for (const prompt of prompts) {
+    const key = cache?.key(backend.model, meta.name, meta.description, prompt);
+    const hit = key ? cache?.get(key) : void 0;
+    if (hit) {
+      results.push({ prompt, activated: hit.activated, reason: hit.reason, cached: true });
+      continue;
+    }
+    const res = await backend.classify({
+      name: meta.name,
+      description: meta.description,
+      prompt,
+      model: backend.model
+    });
+    if (key && cache) cache.set(key, { activated: res.activated, reason: res.reason });
+    results.push({ prompt, activated: res.activated, reason: res.reason, cached: false });
+  }
+  return results;
+}
+
+// src/trigger/cache.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+var TriggerCache = class {
+  constructor(file, enabled2 = true) {
+    this.file = file;
+    this.enabled = enabled2;
+    if (this.enabled && existsSync3(file)) {
+      try {
+        this.store = JSON.parse(readFileSync2(file, "utf8"));
+      } catch {
+        this.store = {};
+      }
+    }
+  }
+  file;
+  enabled;
+  store = {};
+  dirty = false;
+  key(model, name, description, prompt) {
+    return createHash("sha256").update([model, name, description, prompt].join("\0")).digest("hex");
+  }
+  get(key) {
+    if (!this.enabled) return void 0;
+    return this.store[key];
+  }
+  set(key, value) {
+    if (!this.enabled) return;
+    this.store[key] = value;
+    this.dirty = true;
+  }
+  /** Persist to disk if anything changed. */
+  flush() {
+    if (!this.enabled || !this.dirty) return;
+    mkdirSync(dirname2(this.file), { recursive: true });
+    writeFileSync(this.file, JSON.stringify(this.store, null, 2), "utf8");
+    this.dirty = false;
+  }
+};
+
+// src/trigger/score.ts
+function ratio(numerator, denominator) {
+  return denominator === 0 ? 1 : numerator / denominator;
+}
+function computeTriggerResult(skillPath, spec, classifications) {
+  const decision = /* @__PURE__ */ new Map();
+  for (const c of classifications) decision.set(c.prompt, c.activated);
+  let tp = 0;
+  let fn = 0;
+  const falseNegatives = [];
+  for (const prompt of spec.shouldActivate) {
+    if (decision.get(prompt)) tp++;
+    else {
+      fn++;
+      falseNegatives.push(prompt);
+    }
+  }
+  let fp = 0;
+  let tn = 0;
+  const falsePositives = [];
+  for (const prompt of spec.shouldNotActivate) {
+    if (decision.get(prompt)) {
+      fp++;
+      falsePositives.push(prompt);
+    } else tn++;
+  }
+  const precision = ratio(tp, tp + fp);
+  const recall = ratio(tp, tp + fn);
+  const f1 = precision + recall === 0 ? 0 : 2 * precision * recall / (precision + recall);
+  const score = {
+    truePositives: tp,
+    falsePositives: fp,
+    trueNegatives: tn,
+    falseNegatives: fn,
+    precision,
+    recall,
+    f1
+  };
+  return {
+    layer: "trigger",
+    skillPath,
+    score,
+    classifications,
+    falseNegatives,
+    falsePositives,
+    // A skill passes triggering when it activates exactly when it should.
+    ok: fp === 0 && fn === 0
+  };
+}
+
+// src/trigger/spec.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, join as join2 } from "path";
+import { parse as parseYaml2 } from "yaml";
+var SpecValidationError = class extends Error {
+};
+function findSpec(skillPath) {
+  const candidate = join2(dirname3(skillPath), "SKILL.test.yaml");
+  return existsSync4(candidate) ? candidate : void 0;
+}
+function asStringArray(value, field) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new SpecValidationError(`\`${field}\` must be a list of strings`);
+  }
+  for (const item of value) {
+    if (typeof item !== "string") {
+      throw new SpecValidationError(`\`${field}\` must contain only strings`);
+    }
+  }
+  return value;
+}
+function loadSpec(specPath) {
+  let raw;
+  try {
+    raw = readFileSync3(specPath, "utf8");
+  } catch (err2) {
+    throw new SpecValidationError(`could not read spec: ${err2.message}`);
+  }
+  let doc;
+  try {
+    doc = parseYaml2(raw);
+  } catch (err2) {
+    throw new SpecValidationError(`invalid YAML: ${err2.message}`);
+  }
+  if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+    throw new SpecValidationError("spec must be a YAML mapping");
+  }
+  const obj = doc;
+  const triggering = obj.triggering ?? {};
+  if (typeof triggering !== "object" || Array.isArray(triggering)) {
+    throw new SpecValidationError("`triggering` must be a mapping");
+  }
+  const shouldActivate = asStringArray(triggering.should_activate, "triggering.should_activate");
+  const shouldNotActivate = asStringArray(
+    triggering.should_not_activate,
+    "triggering.should_not_activate"
+  );
+  if (shouldActivate.length === 0 && shouldNotActivate.length === 0) {
+    throw new SpecValidationError(
+      "spec has no triggering prompts (add triggering.should_activate / should_not_activate)"
+    );
+  }
+  const tasks = obj.tasks === void 0 ? [] : obj.tasks;
+  if (!Array.isArray(tasks)) {
+    throw new SpecValidationError("`tasks` must be a list");
+  }
+  return {
+    specPath,
+    skillRef: typeof obj.skill === "string" ? obj.skill : void 0,
+    shouldActivate,
+    shouldNotActivate,
+    tasks
+  };
+}
+
+// src/trigger/run-trigger.ts
+var DEFAULT_CACHE_DIR = ".skill-test-cache";
+async function triggerSkill(skillPath, opts = {}) {
+  const specPath = findSpec(skillPath);
+  if (!specPath) {
+    return { layer: "trigger", skipped: true, reason: "no SKILL.test.yaml beside SKILL.md" };
+  }
+  const skill = parseSkillFile(skillPath);
+  const name = skill.frontmatter.name;
+  const description = skill.frontmatter.description;
+  if (typeof name !== "string" || typeof description !== "string" || !name || !description) {
+    return {
+      layer: "trigger",
+      skipped: true,
+      reason: "skill metadata (name/description) missing or invalid \u2014 fix lint errors first"
+    };
+  }
+  if (!opts.backend) {
+    return { layer: "trigger", skipped: true, reason: "no ANTHROPIC_API_KEY set" };
+  }
+  const spec = loadSpec(specPath);
+  const prompts = [...spec.shouldActivate, ...spec.shouldNotActivate];
+  const cache = opts.cache ?? new TriggerCache(join3(opts.cacheDir ?? DEFAULT_CACHE_DIR, "trigger.json"), !opts.noCache);
+  const classifications = await classifyPrompts(
+    { name, description },
+    prompts,
+    opts.backend,
+    cache
+  );
+  cache.flush();
+  return computeTriggerResult(skillPath, spec, classifications);
+}
+
+// src/backend/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var SYSTEM = `You simulate how an AI coding agent decides whether to activate a Skill.
+
+At startup the agent sees only each skill's name and description \u2014 never its full instructions. When the user sends a message, the agent activates a skill if and only if that skill's description indicates it is relevant to the request.
+
+You are given ONE skill's metadata and ONE user message. Decide whether the agent would activate this skill for that message. A good, specific description should activate for on-topic requests and stay silent for unrelated ones.
+
+Respond with ONLY a JSON object, no prose:
+{"activate": <true|false>, "reason": "<one short sentence>"}`;
+function buildUserMessage(req) {
+  return `Skill name: ${req.name}
+Skill description: ${req.description}
+
+User message: ${req.prompt}`;
+}
+function parseDecision(text) {
+  const match = text.match(/\{[\s\S]*\}/);
+  if (!match) {
+    return { activated: false, reason: `could not parse model response: ${text.slice(0, 80)}` };
+  }
+  try {
+    const obj = JSON.parse(match[0]);
+    return {
+      activated: obj.activate === true,
+      reason: typeof obj.reason === "string" ? obj.reason : ""
+    };
+  } catch {
+    return { activated: false, reason: `invalid JSON in model response: ${text.slice(0, 80)}` };
+  }
+}
+function createAnthropicBackend(opts = {}) {
+  const apiKey = opts.apiKey ?? process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error("ANTHROPIC_API_KEY is not set");
+  }
+  const model = opts.model ?? process.env.SKILL_TEST_MODEL ?? DEFAULT_MODEL;
+  const client = new Anthropic({ apiKey });
+  return {
+    model,
+    async classify(req) {
+      const msg = await client.messages.create({
+        model: req.model,
+        max_tokens: 200,
+        temperature: 0,
+        system: SYSTEM,
+        messages: [{ role: "user", content: buildUserMessage(req) }]
+      });
+      const text = msg.content.map((b) => b.type === "text" ? b.text : "").join("").trim();
+      return parseDecision(text);
+    }
+  };
+}
+function hasApiKey() {
+  return Boolean(process.env.ANTHROPIC_API_KEY);
+}
+
+// src/report/colors.ts
+var enabled = true;
+function setColorEnabled(on) {
+  enabled = on;
+}
+var ESC = String.fromCharCode(27);
+function wrap(code, close) {
+  return (s) => enabled ? `${ESC}[${code}m${s}${ESC}[${close}m` : s;
+}
+var color = {
+  red: wrap(31, 39),
+  green: wrap(32, 39),
+  yellow: wrap(33, 39),
+  blue: wrap(34, 39),
+  gray: wrap(90, 39),
+  bold: wrap(1, 22),
+  dim: wrap(2, 22)
+};
+
+// src/report/terminal.ts
+import { relative } from "path";
+function severityLabel(severity) {
+  switch (severity) {
+    case "error":
+      return color.red("error");
+    case "warn":
+      return color.yellow("warn ");
+    case "info":
+      return color.blue("info ");
+  }
+}
+function rel(p) {
+  const r = relative(process.cwd(), p);
+  return r === "" || r.startsWith("..") ? p : r;
+}
+function renderFinding(f) {
+  const loc = f.line ? `:${f.line}` : "";
+  const where = color.dim(`${rel(f.file)}${loc}`);
+  const id = color.gray(f.ruleId);
+  return `  ${severityLabel(f.severity)} ${f.message} ${id}
+         ${where}`;
+}
+function counts(findings) {
+  return {
+    errors: findings.filter((f) => f.severity === "error").length,
+    warns: findings.filter((f) => f.severity === "warn").length,
+    infos: findings.filter((f) => f.severity === "info").length
+  };
+}
+function renderTrigger(t) {
+  const s = t.score;
+  const pct = (n) => `${(n * 100).toFixed(0)}%`;
+  const head = `  trigger  precision ${pct(s.precision)} \xB7 recall ${pct(s.recall)} \xB7 F1 ${pct(s.f1)}`;
+  const lines = [t.ok ? color.green(head) : color.yellow(head)];
+  for (const fn of t.falseNegatives) {
+    lines.push(color.yellow(`    \u2717 should activate but didn't: "${fn}"`));
+  }
+  for (const fp of t.falsePositives) {
+    lines.push(color.yellow(`    \u2717 should NOT activate but did: "${fp}"`));
+  }
+  return lines.join("\n");
+}
+function renderReport(report, opts = {}) {
+  const lines = [];
+  let errors = 0;
+  let warns = 0;
+  for (const sr of report.results) {
+    if (sr.lint) {
+      const c = counts(sr.lint.findings);
+      errors += c.errors;
+      warns += c.warns;
+    }
+    lines.push(renderSkillReport(sr, opts));
+  }
+  lines.push("");
+  const failed = report.results.filter((r) => !r.ok).length;
+  const summary = `${report.results.length} skill(s) \xB7 ${failed} failing \xB7 ${errors} error(s) \xB7 ${warns} warning(s)`;
+  lines.push(report.ok ? color.green(summary) : color.red(summary));
+  return lines.join("\n");
+}
+function renderSkillReport(sr, opts) {
+  const status = sr.ok ? color.green("\u2713") : color.red("\u2717");
+  const lines = [`${status} ${color.bold(rel(sr.skillPath))}`];
+  if (sr.lint) {
+    if (!opts.quiet || !sr.lint.ok) {
+      for (const f of sr.lint.findings) lines.push(renderFinding(f));
+    }
+  }
+  if (sr.trigger) {
+    if ("skipped" in sr.trigger) {
+      lines.push(color.dim(`  trigger  skipped \u2014 ${sr.trigger.reason}`));
+    } else {
+      lines.push(renderTrigger(sr.trigger));
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/report/json.ts
+function reportToJson(report) {
+  return {
+    tool: "skill-test",
+    ok: report.ok,
+    skills: report.results.map((sr) => ({
+      skill: sr.skillPath,
+      ok: sr.ok,
+      lint: sr.lint ? { ok: sr.lint.ok, findings: sr.lint.findings } : void 0,
+      trigger: sr.trigger ? "skipped" in sr.trigger ? { skipped: true, reason: sr.trigger.reason } : {
+        ok: sr.trigger.ok,
+        score: sr.trigger.score,
+        falseNegatives: sr.trigger.falseNegatives,
+        falsePositives: sr.trigger.falsePositives
+      } : void 0
+    }))
+  };
+}
+
+// src/report/junit.ts
+import { basename as basename3, dirname as dirname4 } from "path";
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function skillName(skillPath) {
+  return basename3(dirname4(skillPath)) || skillPath;
+}
+function findingLine(f) {
+  const loc = f.line ? `:${f.line}` : "";
+  return `[${f.severity}] ${f.ruleId} \u2014 ${f.message}${loc}`;
+}
+function renderCase(classname, c) {
+  const open = `    <testcase classname="${esc(classname)}" name="${esc(c.name)}">`;
+  if (c.skipped !== void 0) {
+    return `${open}
+      <skipped message="${esc(c.skipped)}"/>
+    </testcase>`;
+  }
+  if (c.failure !== void 0) {
+    return `${open}
+      <failure message="${esc(firstLine(c.failure))}">${esc(c.failure)}</failure>
+    </testcase>`;
+  }
+  return `    <testcase classname="${esc(classname)}" name="${esc(c.name)}"/>`;
+}
+function firstLine(s) {
+  return s.split("\n")[0] ?? s;
+}
+function casesForSkill(sr) {
+  const cases = [];
+  if (sr.lint) {
+    const errs = sr.lint.findings.filter((f) => f.severity === "error");
+    cases.push({
+      name: "lint",
+      failure: errs.length ? errs.map(findingLine).join("\n") : void 0
+    });
+  }
+  if (sr.trigger) {
+    if ("skipped" in sr.trigger) {
+      cases.push({ name: "trigger", skipped: sr.trigger.reason });
+    } else {
+      const t = sr.trigger;
+      const fail = t.ok === false ? [
+        `precision ${t.score.precision.toFixed(2)} recall ${t.score.recall.toFixed(2)} F1 ${t.score.f1.toFixed(2)}`,
+        ...t.falseNegatives.map((p) => `false negative (should activate): ${p}`),
+        ...t.falsePositives.map((p) => `false positive (should not activate): ${p}`)
+      ].join("\n") : void 0;
+      cases.push({ name: "trigger", failure: fail });
+    }
+  }
+  return cases;
+}
+function reportToJUnit(report) {
+  const suites = [];
+  let totalTests = 0;
+  let totalFailures = 0;
+  let totalSkipped = 0;
+  for (const sr of report.results) {
+    const cases = casesForSkill(sr);
+    const failures = cases.filter((c) => c.failure !== void 0).length;
+    const skipped = cases.filter((c) => c.skipped !== void 0).length;
+    totalTests += cases.length;
+    totalFailures += failures;
+    totalSkipped += skipped;
+    const name = skillName(sr.skillPath);
+    const body = cases.map((c) => renderCase(name, c)).join("\n");
+    suites.push(
+      `  <testsuite name="${esc(name)}" tests="${cases.length}" failures="${failures}" skipped="${skipped}">
+${body}
+  </testsuite>`
+    );
+  }
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<testsuites name="skill-test" tests="${totalTests}" failures="${totalFailures}" errors="0" skipped="${totalSkipped}">`,
+    ...suites,
+    "</testsuites>",
+    ""
+  ].join("\n");
+}
+
+// src/cli/commands.ts
+function reportPasses(report, failOn) {
+  for (const sr of report.results) {
+    if (sr.lint) {
+      if (!sr.lint.ok) return false;
+      if (failOn === "warn" && sr.lint.findings.some((f) => f.severity === "warn")) return false;
+    }
+    if (sr.trigger && !("skipped" in sr.trigger) && !sr.trigger.ok) return false;
+  }
+  return true;
+}
+function applyColor(opts) {
+  const disabled = opts.color === false || process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
+  setColorEnabled(!disabled);
+}
+function out(s) {
+  process.stdout.write(s.endsWith("\n") ? s : s + "\n");
+}
+function err(s) {
+  process.stderr.write(s.endsWith("\n") ? s : s + "\n");
+}
+function noSkills(paths) {
+  err(`skill-test: no SKILL.md found at: ${paths.join(", ")}`);
+  return EXIT.USAGE;
+}
+function runLint(paths, opts) {
+  applyColor(opts);
+  const files = discoverSkills(paths);
+  if (files.length === 0) return noSkills(paths);
+  const results = files.map((file) => {
+    const lint = lintSkill(file);
+    return { skillPath: file, lint, ok: lint.ok };
+  });
+  const report = { results, ok: results.every((r) => r.ok) };
+  emitReport(report, opts);
+  return reportPasses(report, opts.failOn) ? EXIT.OK : EXIT.FAILURES;
+}
+async function runTrigger(paths, opts) {
+  applyColor(opts);
+  const files = discoverSkills(paths);
+  if (files.length === 0) return noSkills(paths);
+  if (!hasApiKey()) {
+    err(
+      "skill-test: `trigger` needs ANTHROPIC_API_KEY (it asks the model to make the same\nload/skip decision the host agent makes). Set the key, or run `lint` for offline checks."
+    );
+    return EXIT.USAGE;
+  }
+  const backend = createAnthropicBackend({ model: opts.model });
+  const results = [];
+  for (const file of files) {
+    const { trigger, ok } = await triggerWithErrorHandling(file, backend);
+    results.push({ skillPath: file, trigger, ok });
+  }
+  const report = { results, ok: results.every((r) => r.ok) };
+  emitReport(report, opts);
+  return reportPasses(report, opts.failOn) ? EXIT.OK : EXIT.FAILURES;
+}
+async function runRun(paths, opts) {
+  applyColor(opts);
+  void paths;
+  err("skill-test: the `run` layer is implemented in Phase 5 (stretch).");
+  return EXIT.USAGE;
+}
+async function runCheck(paths, opts) {
+  applyColor(opts);
+  const files = discoverSkills(paths);
+  if (files.length === 0) return noSkills(paths);
+  const backend = hasApiKey() ? createAnthropicBackend({ model: opts.model }) : void 0;
+  if (!backend) {
+    err("skill-test: no ANTHROPIC_API_KEY \u2014 running the static layer only (trigger skipped).");
+  }
+  const results = [];
+  for (const file of files) {
+    const lint = lintSkill(file);
+    const { trigger, ok: triggerOk } = await triggerWithErrorHandling(file, backend);
+    results.push({ skillPath: file, lint, trigger, ok: lint.ok && triggerOk });
+  }
+  const report = { results, ok: results.every((r) => r.ok) };
+  emitReport(report, opts);
+  return reportPasses(report, opts.failOn) ? EXIT.OK : EXIT.FAILURES;
+}
+async function triggerWithErrorHandling(file, backend) {
+  try {
+    const trigger = await triggerSkill(file, { backend });
+    return { trigger, ok: "skipped" in trigger ? true : trigger.ok };
+  } catch (e) {
+    if (e instanceof SpecValidationError) {
+      err(`skill-test: ${file}: invalid SKILL.test.yaml: ${e.message}`);
+      return {
+        trigger: {
+          layer: "trigger",
+          skipped: true,
+          reason: `invalid SKILL.test.yaml: ${e.message}`
+        },
+        ok: false
+      };
+    }
+    throw e;
+  }
+}
+function emitReport(report, opts) {
+  if (opts.junit) {
+    writeFileSync2(opts.junit, reportToJUnit(report), "utf8");
+  }
+  if (opts.json) {
+    out(JSON.stringify(reportToJson(report), null, 2));
+  } else {
+    out(renderReport(report, { quiet: opts.quiet }));
+  }
+}
+
+// bin/skill-test.ts
+var program = new Command();
+program.name("skill-test").description(
+  "Test agent Skills (SKILL.md): static lint, activation triggering, and behavioral grading."
+).version(package_default.version, "-v, --version", "print version").option("--json", "emit machine-readable JSON").option("--junit <file>", "write JUnit XML to <file>").option("--cheap", "skip the behavioral (run) layer").option("--fail-on <level>", "fail on 'error' (default) or 'warn'", "error").option("--model <id>", "classifier model for the trigger layer").option("--quiet", "only print failures").option("--no-color", "disable colored output");
+program.command("lint").description("Layer 1 \u2014 static, offline checks against the SKILL.md spec").argument("<path...>", "SKILL.md file(s), skill dir(s), or a dir of skills").action((paths, _opts, cmd) => {
+  process.exitCode = runLint(paths, cmd.optsWithGlobals());
+});
+program.command("trigger").description("Layer 2 \u2014 activation precision/recall (needs API key + SKILL.test.yaml)").argument("<path...>", "SKILL.md file(s), skill dir(s), or a dir of skills").action(async (paths, _opts, cmd) => {
+  process.exitCode = await runTrigger(paths, cmd.optsWithGlobals());
+});
+program.command("run").description("Layer 3 \u2014 behavioral task grading (later phase)").argument("<path...>", "SKILL.md file(s), skill dir(s), or a dir of skills").action(async (paths, _opts, cmd) => {
+  process.exitCode = await runRun(paths, cmd.optsWithGlobals());
+});
+program.command("check").description("Run every layer available given config and keys").argument("<path...>", "SKILL.md file(s), skill dir(s), or a dir of skills").action(async (paths, _opts, cmd) => {
+  process.exitCode = await runCheck(paths, cmd.optsWithGlobals());
+});
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err2) {
+    process.stderr.write(`skill-test: ${err2.message}
+`);
+    process.exitCode = EXIT.USAGE;
+  }
+}
+void main();
+//# sourceMappingURL=skill-test.js.map