@studiomeyer-io/skilldoctor 0.1.0

package/dist/index.js

@@ -0,0 +1,1540 @@
+import { readFileSync, existsSync, statSync, readdirSync } from 'fs';
+import { basename, resolve, join, sep, posix, relative, dirname } from 'path';
+import { parse, YAMLParseError } from 'yaml';
+import { createHash } from 'crypto';
+
+// src/types.ts
+var SEVERITY_RANK = {
+  info: 1,
+  warning: 2,
+  error: 3
+};
+var OPENING_FENCE = /^---[ \t]*\r?\n/;
+function extractFrontmatter(raw) {
+  if (!OPENING_FENCE.test(raw)) {
+    return {
+      frontmatter: {
+        present: false,
+        raw: "",
+        data: void 0,
+        error: void 0,
+        startLine: 0,
+        endLine: 0
+      },
+      body: raw,
+      bodyStartLine: 1
+    };
+  }
+  const lines = raw.split(/\r?\n/);
+  let closingIndex = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (/^---[ \t]*$/.test(lines[i] ?? "")) {
+      closingIndex = i;
+      break;
+    }
+  }
+  if (closingIndex === -1) {
+    const fmLines2 = lines.slice(1);
+    const fmRaw2 = fmLines2.join("\n");
+    return {
+      frontmatter: {
+        present: true,
+        raw: fmRaw2,
+        data: void 0,
+        error: "Unterminated frontmatter: opening '---' has no closing '---'.",
+        startLine: 2,
+        endLine: lines.length
+      },
+      body: "",
+      bodyStartLine: lines.length + 1
+    };
+  }
+  const fmLines = lines.slice(1, closingIndex);
+  const fmRaw = fmLines.join("\n");
+  const bodyLines = lines.slice(closingIndex + 1);
+  const body = bodyLines.join("\n");
+  const bodyStartLine = closingIndex + 2;
+  let data;
+  let error;
+  try {
+    const parsed = parse(fmRaw, {
+      // Defensive: keep parsing strict-ish but lenient on duplicate keys so we
+      // can detect duplicates ourselves rather than throwing.
+      uniqueKeys: false,
+      strict: false
+    });
+    if (parsed === null || parsed === void 0) {
+      data = {};
+    } else if (typeof parsed === "object" && !Array.isArray(parsed)) {
+      data = parsed;
+    } else {
+      error = "Frontmatter must be a YAML mapping (key: value pairs).";
+    }
+  } catch (e) {
+    if (e instanceof YAMLParseError) {
+      error = e.message.split("\n")[0] ?? e.message;
+    } else if (e instanceof Error) {
+      error = e.message;
+    } else {
+      error = "Unknown YAML parse error.";
+    }
+  }
+  return {
+    frontmatter: {
+      present: true,
+      raw: fmRaw,
+      data,
+      error,
+      startLine: 2,
+      endLine: closingIndex + 1
+      // 1-based line of the closing fence
+    },
+    body,
+    bodyStartLine
+  };
+}
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/").toLowerCase();
+}
+function detectKind(filePath, frontmatter) {
+  const norm = normalizePath(filePath);
+  const base = basename(norm);
+  if (base === "agents.md") return "agents-md";
+  if (base === "skill.md") return "skill";
+  const inAgentsDir = /(^|\/)agents\/[^/]+\.md$/.test(norm);
+  const data = frontmatter.data;
+  const hasName = !!data && typeof data["name"] === "string";
+  const hasDescription = !!data && typeof data["description"] === "string";
+  if (inAgentsDir && frontmatter.present && (hasName || hasDescription)) {
+    return "subagent";
+  }
+  if (frontmatter.present && hasName && hasDescription) {
+    return "skill";
+  }
+  return "unknown";
+}
+function parseFile(filePath, raw, forceKind) {
+  if (raw.charCodeAt(0) === 65279) raw = raw.slice(1);
+  const { frontmatter, body, bodyStartLine } = extractFrontmatter(raw);
+  const kind = forceKind ?? detectKind(filePath, frontmatter);
+  return { filePath, kind, frontmatter, body, bodyStartLine, raw };
+}
+
+// src/registry.ts
+var RULES = [
+  // ---- Lint rules (frontmatter / structure) ---------------------------------
+  {
+    ruleId: "skill/missing-name",
+    title: "Missing name",
+    category: "lint",
+    defaultSeverity: "error",
+    description: "A skill or subagent frontmatter must declare a non-empty `name`. The Agent Skills spec requires it; Claude Code falls back to the directory name but a missing name is fragile.",
+    fixable: false
+  },
+  {
+    ruleId: "skill/invalid-name",
+    title: "Invalid name format",
+    category: "lint",
+    defaultSeverity: "error",
+    description: "`name` must be 1-64 lowercase characters using only a-z, 0-9 and hyphens, with no leading/trailing/consecutive hyphens (Agent Skills spec).",
+    fixable: false
+  },
+  {
+    ruleId: "skill/name-dir-mismatch",
+    title: "Name does not match directory",
+    category: "lint",
+    defaultSeverity: "warning",
+    description: "The Agent Skills spec says a skill's `name` must match its parent directory name. A mismatch breaks invocation in some clients.",
+    fixable: false
+  },
+  {
+    ruleId: "skill/missing-description",
+    title: "Missing description",
+    category: "lint",
+    defaultSeverity: "error",
+    description: "`description` is required and is what an agent uses to decide when to load the skill. Without it the skill is effectively invisible.",
+    fixable: true
+  },
+  {
+    ruleId: "skill/empty-description",
+    title: "Empty description",
+    category: "lint",
+    defaultSeverity: "error",
+    description: "`description` is present but blank. It must be non-empty.",
+    fixable: true
+  },
+  {
+    ruleId: "skill/description-too-short",
+    title: "Description too short",
+    category: "lint",
+    defaultSeverity: "warning",
+    description: "A very short description gives the agent almost no signal about when to use the skill. Describe both what it does and when to use it.",
+    fixable: false
+  },
+  {
+    ruleId: "skill/description-too-long",
+    title: "Description too long",
+    category: "lint",
+    defaultSeverity: "warning",
+    description: "`description` exceeds the 1024-character spec limit (Claude Code truncates the combined description+when_to_use at 1,536 chars in the skill listing).",
+    fixable: false
+  },
+  {
+    ruleId: "skill/vague-description",
+    title: "Vague description",
+    category: "lint",
+    defaultSeverity: "info",
+    description: "The description is generic (e.g. 'helps with things') and lacks trigger keywords. Agents match descriptions to tasks, so specificity matters.",
+    fixable: false
+  },
+  {
+    ruleId: "skill/empty-body",
+    title: "Empty body",
+    category: "lint",
+    defaultSeverity: "warning",
+    description: "The markdown body (the actual instructions) is empty or whitespace-only. A skill with no instructions does nothing.",
+    fixable: false
+  },
+  {
+    ruleId: "skill/frontmatter-schema",
+    title: "Frontmatter schema error",
+    category: "lint",
+    defaultSeverity: "error",
+    description: "The YAML frontmatter could not be parsed, is not a mapping, or a known field has the wrong type.",
+    fixable: false
+  },
+  {
+    ruleId: "skill/unknown-field",
+    title: "Unknown frontmatter field",
+    category: "lint",
+    defaultSeverity: "info",
+    description: "A frontmatter field is not part of the Agent Skills spec or the known Claude Code extensions. Handled leniently (info) since clients may add their own fields.",
+    fixable: false
+  },
+  {
+    ruleId: "skill/duplicate-key",
+    title: "Duplicate frontmatter key",
+    category: "lint",
+    defaultSeverity: "warning",
+    description: "A frontmatter key appears more than once. YAML keeps the last value, silently dropping the earlier one.",
+    fixable: false
+  },
+  {
+    ruleId: "skill/trailing-whitespace",
+    title: "Trailing whitespace in frontmatter",
+    category: "lint",
+    defaultSeverity: "info",
+    description: "A frontmatter line has trailing whitespace. Cosmetic, but mechanically fixable.",
+    fixable: true
+  },
+  {
+    ruleId: "skill/duplicate-name",
+    title: "Duplicate skill name in set",
+    category: "lint",
+    defaultSeverity: "error",
+    description: "Two files in the analyzed set declare the same `name`. Clients keep one and silently discard the other.",
+    fixable: false
+  },
+  // ---- Least-privilege / tool-grant rules -----------------------------------
+  {
+    ruleId: "tools/wildcard-grant",
+    title: "Wildcard tool grant",
+    category: "lint",
+    defaultSeverity: "warning",
+    description: "The tool grant includes a bare `*` / `all` wildcard. Least-privilege: grant only the specific tools the skill needs.",
+    fixable: false
+  },
+  {
+    ruleId: "tools/over-broad-for-readonly",
+    title: "Over-broad tools for a read-only skill",
+    category: "lint",
+    defaultSeverity: "warning",
+    description: "The description implies a read-only/docs task but the skill grants write/exec/network tools (e.g. Bash, Write, Edit, WebFetch). Least-privilege violation.",
+    fixable: false
+  },
+  {
+    ruleId: "tools/duplicate-tool",
+    title: "Duplicate tool in grant",
+    category: "lint",
+    defaultSeverity: "info",
+    description: "The same tool is listed more than once in the tool grant.",
+    fixable: true
+  },
+  // ---- Security scan rules --------------------------------------------------
+  {
+    ruleId: "sec/prompt-injection",
+    title: "Prompt-injection phrasing",
+    category: "security",
+    defaultSeverity: "error",
+    description: "The content contains prompt-injection-style instructions (e.g. 'ignore previous instructions', 'disregard your system prompt'). Skill content is untrusted input.",
+    fixable: false
+  },
+  {
+    ruleId: "sec/disable-safety",
+    title: "Instruction to disable safety/guardrails",
+    category: "security",
+    defaultSeverity: "error",
+    description: "The content instructs the agent to disable safety checks, hooks, guardrails, or approval gates.",
+    fixable: false
+  },
+  {
+    ruleId: "sec/data-exfiltration",
+    title: "Possible data-exfiltration pattern",
+    category: "security",
+    defaultSeverity: "error",
+    description: "The content combines an outbound network call (curl/POST/fetch to an external URL) with secrets/credentials/environment variables \u2014 a classic exfiltration shape.",
+    fixable: false
+  },
+  {
+    ruleId: "sec/env-base64",
+    title: "Encoding of secrets/env",
+    category: "security",
+    defaultSeverity: "warning",
+    description: "The content base64-encodes (or otherwise obfuscates) environment variables or secrets, often a precursor to covert exfiltration.",
+    fixable: false
+  },
+  {
+    ruleId: "sec/secret-access",
+    title: "Reads sensitive files/secrets",
+    category: "security",
+    defaultSeverity: "warning",
+    description: "The content references reading sensitive locations (~/.ssh, .env, credentials, cloud token files). Flagged for review; may be legitimate.",
+    fixable: false
+  },
+  {
+    ruleId: "sec/suspicious-tool-combo",
+    title: "Suspicious tool + content combination",
+    category: "security",
+    defaultSeverity: "warning",
+    description: "A skill described as read-only/docs grants Bash plus a network/exec capability \u2014 a combination that enables exfiltration from otherwise-innocent content.",
+    fixable: false
+  },
+  {
+    ruleId: "sec/destructive-command",
+    title: "Destructive shell command in content",
+    category: "security",
+    defaultSeverity: "warning",
+    description: "The content embeds a destructive command (e.g. `rm -rf /`, `curl | sh`, `git push --force`). Review before installing.",
+    fixable: false
+  },
+  {
+    ruleId: "sec/hidden-unicode",
+    title: "Hidden / bidi / zero-width Unicode",
+    category: "security",
+    defaultSeverity: "warning",
+    description: "The content contains zero-width or bidirectional control characters that can hide instructions from a human reviewer (Trojan-Source style).",
+    fixable: false
+  }
+];
+var RULE_MAP = new Map(
+  RULES.map((r) => [r.ruleId, r])
+);
+function getRule(ruleId) {
+  const r = RULE_MAP.get(ruleId);
+  if (!r) {
+    throw new Error(
+      `Internal error: rule '${ruleId}' is not registered in registry.ts`
+    );
+  }
+  return r;
+}
+function allRuleIds() {
+  return RULES.map((r) => r.ruleId);
+}
+
+// src/locate.ts
+function offsetToLineCol(text, offset) {
+  const clamped = Math.max(0, Math.min(offset, text.length));
+  let line = 1;
+  let lastNewline = -1;
+  for (let i = 0; i < clamped; i++) {
+    if (text.charCodeAt(i) === 10) {
+      line++;
+      lastNewline = i;
+    }
+  }
+  const column = clamped - lastNewline;
+  return { line, column };
+}
+function findKeyLine(frontmatterRaw, key, frontmatterStartLine) {
+  const lines = frontmatterRaw.split(/\r?\n/);
+  const re = new RegExp(`^\\s*${escapeRegExp(key)}\\s*:`);
+  for (let i = 0; i < lines.length; i++) {
+    if (re.test(lines[i] ?? "")) {
+      return frontmatterStartLine + i;
+    }
+  }
+  return frontmatterStartLine;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function makeEvidence(snippet, max = 120) {
+  const oneLine = snippet.replace(/\s+/g, " ").trim();
+  if (oneLine.length <= max) return oneLine;
+  return oneLine.slice(0, max - 1) + "\u2026";
+}
+
+// src/spec.ts
+var SKILL_NAME_MAX = 64;
+var SKILL_DESCRIPTION_MAX = 1024;
+var SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SPEC_SKILL_FIELDS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "license",
+  "compatibility",
+  "metadata",
+  "allowed-tools"
+]);
+var CLAUDE_CODE_SKILL_FIELDS = /* @__PURE__ */ new Set([
+  "when_to_use",
+  "argument-hint",
+  "arguments",
+  "disable-model-invocation",
+  "user-invocable",
+  "disallowed-tools",
+  "model",
+  "effort",
+  "context",
+  "agent",
+  "hooks",
+  "paths",
+  "shell"
+]);
+var SUBAGENT_FIELDS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "tools",
+  "disallowedTools",
+  "model",
+  "permissionMode",
+  "mcpServers",
+  "hooks",
+  "maxTurns",
+  "skills",
+  "initialPrompt",
+  "memory",
+  "effort",
+  "background",
+  "isolation",
+  "color"
+]);
+var SENSITIVE_TOOLS = /* @__PURE__ */ new Set([
+  "bash",
+  "shell",
+  "execute",
+  "exec",
+  "write",
+  "edit",
+  "multiedit",
+  "notebookedit",
+  "webfetch",
+  "websearch",
+  "fetch",
+  "applypatch",
+  "patch"
+]);
+var NETWORK_TOOLS = /* @__PURE__ */ new Set([
+  "webfetch",
+  "websearch",
+  "fetch"
+]);
+var EXEC_TOOLS = /* @__PURE__ */ new Set(["bash", "shell", "execute", "exec"]);
+var READONLY_HINT_RE = /\b(read[- ]?only|look[- ]?up|lookup|summari[sz]e|explains?|describes?)\b/i;
+function normalizeToolName(token) {
+  return token.trim().replace(/\(.*\)\s*$/, "").toLowerCase();
+}
+function parseToolList(value) {
+  if (Array.isArray(value)) {
+    return value.filter((v) => typeof v === "string");
+  }
+  if (typeof value === "string") {
+    return value.split(/[,\s]+/).map((t) => t.trim()).filter((t) => t.length > 0);
+  }
+  return [];
+}
+function isWildcardTool(token) {
+  const t = token.trim().toLowerCase();
+  return t === "*" || t === "all" || t === "any" || t === "everything";
+}
+
+// src/rules/lint.ts
+function finding(ruleId, message, line, opts = {}) {
+  const rule = getRule(ruleId);
+  const f = {
+    ruleId: rule.ruleId,
+    title: rule.title,
+    category: rule.category,
+    severity: rule.defaultSeverity,
+    message,
+    line: Math.max(1, line),
+    column: Math.max(1, opts.column ?? 1),
+    fixable: rule.fixable
+  };
+  if (opts.evidence !== void 0) f.evidence = opts.evidence;
+  return f;
+}
+var VAGUE_RE = /^(helps?( you)?( with)?|does (stuff|things)|a skill( for)?|utility|tool|assistant|various|misc(ellaneous)?)\b/i;
+function lintFile(file) {
+  const findings = [];
+  const { frontmatter, kind } = file;
+  if (kind === "agents-md") {
+    if (file.raw.trim().length === 0) {
+      findings.push(
+        finding(
+          "skill/empty-body",
+          "AGENTS.md is empty. It should contain project instructions for agents.",
+          1
+        )
+      );
+    }
+    return findings;
+  }
+  if (kind === "unknown") {
+    return findings;
+  }
+  const fmStart = frontmatter.startLine || 1;
+  if (frontmatter.present && frontmatter.error) {
+    findings.push(
+      finding(
+        "skill/frontmatter-schema",
+        `Frontmatter could not be parsed: ${frontmatter.error}`,
+        fmStart
+      )
+    );
+    if (!frontmatter.data) return findings;
+  }
+  if (!frontmatter.present || !frontmatter.data) {
+    findings.push(
+      finding(
+        "skill/missing-name",
+        "No frontmatter found; a skill/subagent requires `name` and `description`.",
+        1
+      )
+    );
+    findings.push(
+      finding(
+        "skill/missing-description",
+        "No frontmatter found; `description` is required.",
+        1
+      )
+    );
+    return findings;
+  }
+  const data = frontmatter.data;
+  lintName(file, data, findings);
+  lintDescription(file, data, findings);
+  lintBody(file, findings);
+  lintTools(file, data, findings);
+  lintUnknownFields(file, data, findings);
+  lintTrailingWhitespace(file, findings);
+  lintDuplicateKeys(file, findings);
+  return findings;
+}
+function lintName(file, data, findings) {
+  const fmStart = file.frontmatter.startLine || 1;
+  const nameRaw = data["name"];
+  const nameLine = findKeyLine(file.frontmatter.raw, "name", fmStart);
+  if (nameRaw === void 0 || nameRaw === null) {
+    findings.push(
+      finding("skill/missing-name", "Missing required `name` field.", fmStart)
+    );
+    return;
+  }
+  if (typeof nameRaw !== "string") {
+    findings.push(
+      finding(
+        "skill/frontmatter-schema",
+        `\`name\` must be a string, got ${typeof nameRaw}.`,
+        nameLine
+      )
+    );
+    return;
+  }
+  const name = nameRaw.trim();
+  if (name.length === 0) {
+    findings.push(
+      finding("skill/missing-name", "`name` is empty.", nameLine)
+    );
+    return;
+  }
+  if (name.length > SKILL_NAME_MAX || !SKILL_NAME_RE.test(name)) {
+    findings.push(
+      finding(
+        "skill/invalid-name",
+        `\`name\` "${name}" is invalid. Use 1-${SKILL_NAME_MAX} lowercase chars (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens.`,
+        nameLine,
+        { evidence: makeEvidence(name) }
+      )
+    );
+    return;
+  }
+  if (basename(file.filePath).toLowerCase() === "skill.md") {
+    const dir = basename(dirname(file.filePath));
+    if (dir && dir !== "." && dir !== "" && dir.toLowerCase() !== name) {
+      findings.push(
+        finding(
+          "skill/name-dir-mismatch",
+          `\`name\` "${name}" does not match the parent directory "${dir}". The Agent Skills spec requires them to match.`,
+          nameLine
+        )
+      );
+    }
+  }
+}
+function lintDescription(file, data, findings) {
+  const fmStart = file.frontmatter.startLine || 1;
+  const descRaw = data["description"];
+  const descLine = findKeyLine(file.frontmatter.raw, "description", fmStart);
+  if (descRaw === void 0 || descRaw === null) {
+    findings.push(
+      finding(
+        "skill/missing-description",
+        "Missing required `description` field. Agents use it to decide when to load the skill.",
+        fmStart
+      )
+    );
+    return;
+  }
+  if (typeof descRaw !== "string") {
+    findings.push(
+      finding(
+        "skill/frontmatter-schema",
+        `\`description\` must be a string, got ${typeof descRaw}.`,
+        descLine
+      )
+    );
+    return;
+  }
+  const desc = descRaw.trim();
+  if (desc.length === 0) {
+    findings.push(
+      finding("skill/empty-description", "`description` is empty.", descLine)
+    );
+    return;
+  }
+  if (desc.length < 20) {
+    findings.push(
+      finding(
+        "skill/description-too-short",
+        `\`description\` is only ${desc.length} characters. Describe what the skill does AND when to use it (include trigger keywords).`,
+        descLine,
+        { evidence: makeEvidence(desc) }
+      )
+    );
+  }
+  if (desc.length > SKILL_DESCRIPTION_MAX) {
+    findings.push(
+      finding(
+        "skill/description-too-long",
+        `\`description\` is ${desc.length} characters, over the ${SKILL_DESCRIPTION_MAX}-char spec limit.`,
+        descLine
+      )
+    );
+  }
+  if (VAGUE_RE.test(desc)) {
+    findings.push(
+      finding(
+        "skill/vague-description",
+        "`description` reads as generic. Add concrete capabilities and trigger phrases so agents match it to real tasks.",
+        descLine,
+        { evidence: makeEvidence(desc) }
+      )
+    );
+  }
+}
+function lintBody(file, findings) {
+  if (file.body.trim().length === 0) {
+    findings.push(
+      finding(
+        "skill/empty-body",
+        "The instruction body is empty. Add the steps/instructions the agent should follow.",
+        file.bodyStartLine
+      )
+    );
+  }
+}
+function lintTools(file, data, findings) {
+  const fmStart = file.frontmatter.startLine || 1;
+  const keys = ["allowed-tools", "tools"];
+  for (const key of keys) {
+    if (!(key in data)) continue;
+    const value = data[key];
+    const line = findKeyLine(file.frontmatter.raw, key, fmStart);
+    if (value !== void 0 && value !== null && typeof value !== "string" && !Array.isArray(value)) {
+      findings.push(
+        finding(
+          "skill/frontmatter-schema",
+          `\`${key}\` must be a space/comma-separated string or a YAML list.`,
+          line
+        )
+      );
+      continue;
+    }
+    const tokens = parseToolList(value);
+    if (tokens.length === 0) continue;
+    const wild = tokens.find((t) => isWildcardTool(t));
+    if (wild) {
+      findings.push(
+        finding(
+          "tools/wildcard-grant",
+          `\`${key}\` grants a wildcard ("${wild}"). Least-privilege: list only the specific tools this skill needs.`,
+          line,
+          { evidence: makeEvidence(tokens.join(", ")) }
+        )
+      );
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const dups = /* @__PURE__ */ new Set();
+    for (const t of tokens) {
+      const key2 = t.trim();
+      if (seen.has(key2)) dups.add(key2);
+      seen.add(key2);
+    }
+    if (dups.size > 0) {
+      findings.push(
+        finding(
+          "tools/duplicate-tool",
+          `\`${key}\` lists duplicate tool(s): ${[...dups].join(", ")}.`,
+          line
+        )
+      );
+    }
+    const desc = typeof data["description"] === "string" ? data["description"] : "";
+    const sensitiveGranted = tokens.map((t) => normalizeToolName(t)).filter((n) => SENSITIVE_TOOLS.has(n));
+    if (!wild && sensitiveGranted.length > 0 && READONLY_HINT_RE.test(desc)) {
+      findings.push(
+        finding(
+          "tools/over-broad-for-readonly",
+          `Description implies a read-only task but \`${key}\` grants write/exec/network tool(s): ${[
+            ...new Set(sensitiveGranted)
+          ].join(", ")}. Drop them or adjust the description.`,
+          line,
+          { evidence: makeEvidence(desc) }
+        )
+      );
+    }
+  }
+}
+function lintUnknownFields(file, data, findings) {
+  const fmStart = file.frontmatter.startLine || 1;
+  const allowed = file.kind === "subagent" ? SUBAGENT_FIELDS : unionFields();
+  for (const key of Object.keys(data)) {
+    if (!allowed.has(key)) {
+      findings.push(
+        finding(
+          "skill/unknown-field",
+          `Unknown frontmatter field "${key}" \u2014 not part of the Agent Skills spec or known Claude Code extensions. (Lenient: clients may add custom fields.)`,
+          findKeyLine(file.frontmatter.raw, key, fmStart)
+        )
+      );
+    }
+  }
+}
+function unionFields() {
+  const s = new Set(SPEC_SKILL_FIELDS);
+  for (const f of CLAUDE_CODE_SKILL_FIELDS) s.add(f);
+  return s;
+}
+function lintTrailingWhitespace(file, findings) {
+  if (!file.frontmatter.present) return;
+  const lines = file.frontmatter.raw.split(/\r?\n/);
+  const fmStart = file.frontmatter.startLine || 1;
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i] ?? "";
+    if (/[ \t]+$/.test(l) && l.trim().length > 0) {
+      findings.push(
+        finding(
+          "skill/trailing-whitespace",
+          "Frontmatter line has trailing whitespace.",
+          fmStart + i
+        )
+      );
+    }
+  }
+}
+function lintDuplicateKeys(file, findings) {
+  if (!file.frontmatter.present) return;
+  const lines = file.frontmatter.raw.split(/\r?\n/);
+  const fmStart = file.frontmatter.startLine || 1;
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i] ?? "";
+    const m = /^([A-Za-z0-9_-]+)\s*:/.exec(l);
+    if (!m) continue;
+    const key = m[1];
+    if (seen.has(key)) {
+      findings.push(
+        finding(
+          "skill/duplicate-key",
+          `Frontmatter key "${key}" appears more than once; YAML keeps only the last value.`,
+          fmStart + i
+        )
+      );
+    } else {
+      seen.set(key, i);
+    }
+  }
+}
+
+// src/security/scan.ts
+var INJECTION_PATTERNS = [
+  {
+    ruleId: "sec/prompt-injection",
+    re: /ignore (?:all |any |the )?(?:previous|prior|above|earlier|preceding)[^\n]{0,30}\b(?:instruction|prompt|message|context|rule)s?/gi,
+    message: () => 'Contains "ignore previous instructions"-style injection.'
+  },
+  {
+    ruleId: "sec/prompt-injection",
+    re: /disregard[^\n]{0,30}\b(?:previous|prior|system|above|all)[^\n]{0,20}\b(?:instruction|prompt|rule|message)s?/gi,
+    message: () => 'Contains "disregard ... instructions/system prompt" injection.'
+  },
+  {
+    ruleId: "sec/prompt-injection",
+    re: /(?:forget|override|bypass)[^\n]{0,30}\b(?:your |the )?(?:system )?(?:prompt|instruction|rule|guideline)s?/gi,
+    message: () => "Instructs the agent to forget/override/bypass its prompt or rules."
+  },
+  {
+    ruleId: "sec/prompt-injection",
+    re: /\b(?:you are now|from now on,? you are|act as)[^\n]{0,40}\b(?:DAN|jailbroken|unrestricted|developer mode|no(?:t bound by| longer bound by| restrictions))/gi,
+    message: () => "Contains a role-override / jailbreak persona instruction."
+  },
+  {
+    ruleId: "sec/prompt-injection",
+    re: /\bnew (?:system )?(?:instructions?|prompt|directive)s?\s*:/gi,
+    message: () => 'Injects a "new instructions:" block (prompt-override pattern).'
+  }
+];
+var SAFETY_PATTERNS = [
+  {
+    ruleId: "sec/disable-safety",
+    // Negative lookbehind: don't flag safety *documentation* like
+    // "never disable the content filter" / "do not bypass guardrails".
+    re: /(?<!\b(?:never|not|do not|don'?t|cannot|must not|should not)\s{1,6})\b(?:disable|turn off|bypass|skip|remove|ignore)[^\n]{0,40}\b(?:safety|guardrail|guard|content[- ]?filter|moderation|approval|confirmation|hook)s?\b/gi,
+    message: () => "Instructs the agent to disable safety/guardrails/hooks."
+  },
+  {
+    ruleId: "sec/disable-safety",
+    re: /(?<!\b(?:never|not|do not|don'?t|cannot|must not|should not)\s{1,6})\b(?:without|skip|no need for|don'?t (?:ask|request|require))[^\n]{0,30}\b(?:permission|approval|confirmation|consent)\b/gi,
+    message: () => "Tells the agent to act without permission/approval/confirmation."
+  },
+  {
+    ruleId: "sec/disable-safety",
+    re: /--dangerously-skip-permissions|CLAUDE_SKIP_[A-Z_]+\s*=\s*1|--yolo\b/g,
+    message: () => "References a flag/env that disables the harness safety prompts."
+  }
+];
+var ENCODE_PATTERNS = [
+  {
+    ruleId: "sec/env-base64",
+    re: /\b(?:base64|btoa|b64encode|xxd|openssl enc)\b[^\n]{0,60}\b(?:env|environ|secret|token|key|password|credential)/gi,
+    message: () => "Encodes environment/secret values (possible covert exfil)."
+  },
+  {
+    ruleId: "sec/env-base64",
+    re: /\b(?:env|printenv|cat[^\n]{0,20}\.env)\b[^\n]{0,30}\|\s*(?:base64|xxd|openssl)/gi,
+    message: () => "Pipes environment/.env contents into an encoder."
+  }
+];
+var SECRET_ACCESS_PATTERNS = [
+  {
+    ruleId: "sec/secret-access",
+    re: /(?:~\/?\.ssh\/|\.ssh\/id_(?:rsa|ed25519|ecdsa)|authorized_keys|known_hosts)/g,
+    message: () => "References SSH key material (~/.ssh, id_rsa, \u2026)."
+  },
+  {
+    ruleId: "sec/secret-access",
+    re: /(?:\.aws\/credentials|\.config\/gcloud|\.kube\/config|\.docker\/config\.json|\.netrc|\.npmrc)\b/g,
+    message: () => "References a cloud/credential config file."
+  },
+  {
+    ruleId: "sec/secret-access",
+    re: /\b(?:cat|read|open|less|head|tail)\b[^\n]{0,20}\b[^\n]{0,40}\.env(?:\.[a-z]+)?\b/gi,
+    message: () => "Reads a .env file (may contain secrets)."
+  },
+  {
+    ruleId: "sec/secret-access",
+    re: /\b(?:AWS_SECRET_ACCESS_KEY|AWS_ACCESS_KEY_ID|GITHUB_TOKEN|OPENAI_API_KEY|ANTHROPIC_API_KEY|GH_TOKEN|NPM_TOKEN|STRIPE_[A-Z_]*KEY|DATABASE_URL)\b/g,
+    message: (m) => `References a known secret environment variable (${m[0]}).`
+  }
+];
+var DESTRUCTIVE_PATTERNS = [
+  {
+    ruleId: "sec/destructive-command",
+    re: /\brm\s+-[a-z]*r[a-z]*f?\s+(?:\/|~|\$HOME|\*)/gi,
+    message: () => "Contains a recursive force-delete (rm -rf) of a broad path."
+  },
+  {
+    ruleId: "sec/destructive-command",
+    re: /\b(?:curl|wget)\b[^\n]{0,80}\|\s*(?:sudo\s+)?(?:bash|sh|zsh|python3?|node)\b/gi,
+    message: () => "Pipes a downloaded script straight into a shell (curl | sh)."
+  },
+  {
+    ruleId: "sec/destructive-command",
+    re: /\bgit\s+push[^\n]{0,40}(?:--force\b|-f\b|\+[A-Za-z])/gi,
+    message: () => "Contains a force-push (git push --force)."
+  },
+  {
+    ruleId: "sec/destructive-command",
+    re: /\b(?:chmod|chown)\s+-R[^\n]{0,20}(?:777|a\+rwx)/gi,
+    message: () => "Recursively grants world-writable permissions."
+  }
+];
+var OUTBOUND_RE = /\b(?:curl|wget|fetch|axios|http(?:s)?\.request|requests\.(?:post|get)|invoke-webrequest|Invoke-RestMethod)\b[^\n]{0,200}https?:\/\/[^\s"'`]+/gi;
+var SECRET_NEAR_RE = /\b(?:env|environ|process\.env|secret|token|api[_-]?key|password|credential|\$[A-Z_]{3,})\b/i;
+var SINGLE_PATTERN_GROUPS = [
+  INJECTION_PATTERNS,
+  SAFETY_PATTERNS,
+  ENCODE_PATTERNS,
+  SECRET_ACCESS_PATTERNS,
+  DESTRUCTIVE_PATTERNS
+];
+var HIDDEN_UNICODE_RE = new RegExp(
+  "[\\u200B-\\u200F\\u202A-\\u202E\\u2060\\u2066-\\u2069\\uFEFF]",
+  "g"
+);
+function finding2(ruleId, message, line, column, evidence) {
+  const rule = getRule(ruleId);
+  const f = {
+    ruleId: rule.ruleId,
+    title: rule.title,
+    category: rule.category,
+    severity: rule.defaultSeverity,
+    message,
+    line: Math.max(1, line),
+    column: Math.max(1, column),
+    fixable: rule.fixable
+  };
+  if (evidence !== void 0) f.evidence = evidence;
+  return f;
+}
+function scanFile(file) {
+  const findings = [];
+  const segments = [];
+  if (file.body.length > 0) {
+    segments.push({ text: file.body, baseLine: file.bodyStartLine });
+  }
+  const desc = file.frontmatter.data?.["description"];
+  if (typeof desc === "string" && desc.length > 0) {
+    segments.push({ text: desc, baseLine: file.frontmatter.startLine || 1 });
+  }
+  if (file.kind === "agents-md" || file.kind === "unknown") {
+    segments.length = 0;
+    segments.push({ text: file.raw, baseLine: 1 });
+  }
+  for (const seg of segments) {
+    runSinglePatterns(seg.text, seg.baseLine, findings);
+    runExfilCheck(seg.text, seg.baseLine, findings);
+    runHiddenUnicode(seg.text, seg.baseLine, findings);
+  }
+  runSuspiciousToolCombo(file, findings);
+  return findings;
+}
+function locInSegment(text, index, baseLine) {
+  const { line, column } = offsetToLineCol(text, index);
+  return { line: baseLine + (line - 1), column };
+}
+function runSinglePatterns(text, baseLine, findings) {
+  for (const group of SINGLE_PATTERN_GROUPS) {
+    for (const pat of group) {
+      pat.re.lastIndex = 0;
+      let m;
+      let guard = 0;
+      while ((m = pat.re.exec(text)) !== null) {
+        const { line, column } = locInSegment(text, m.index, baseLine);
+        findings.push(
+          finding2(pat.ruleId, pat.message(m), line, column, makeEvidence(m[0]))
+        );
+        if (m.index === pat.re.lastIndex) pat.re.lastIndex++;
+        if (++guard > 1e3) break;
+      }
+    }
+  }
+}
+function runExfilCheck(text, baseLine, findings) {
+  OUTBOUND_RE.lastIndex = 0;
+  let m;
+  let guard = 0;
+  while ((m = OUTBOUND_RE.exec(text)) !== null) {
+    const start = Math.max(0, m.index - 160);
+    const end = Math.min(text.length, m.index + m[0].length + 160);
+    const window = text.slice(start, end);
+    if (SECRET_NEAR_RE.test(window)) {
+      const { line, column } = locInSegment(text, m.index, baseLine);
+      findings.push(
+        finding2(
+          "sec/data-exfiltration",
+          "Outbound network call near secret/env values \u2014 possible data exfiltration.",
+          line,
+          column,
+          makeEvidence(m[0])
+        )
+      );
+    }
+    if (m.index === OUTBOUND_RE.lastIndex) OUTBOUND_RE.lastIndex++;
+    if (++guard > 1e3) break;
+  }
+}
+function runHiddenUnicode(text, baseLine, findings) {
+  HIDDEN_UNICODE_RE.lastIndex = 0;
+  const m = HIDDEN_UNICODE_RE.exec(text);
+  if (m) {
+    const { line, column } = locInSegment(text, m.index, baseLine);
+    findings.push(
+      finding2(
+        "sec/hidden-unicode",
+        "Contains zero-width or bidirectional Unicode control characters that can hide text from a human reviewer.",
+        line,
+        column
+      )
+    );
+  }
+}
+function runSuspiciousToolCombo(file, findings) {
+  const data = file.frontmatter.data;
+  if (!data) return;
+  const toolValue = data["allowed-tools"] ?? data["tools"];
+  const tokens = parseToolList(toolValue).map((t) => normalizeToolName(t));
+  if (tokens.length === 0) return;
+  const hasExec = tokens.some((t) => EXEC_TOOLS.has(t));
+  const hasNet = tokens.some((t) => NETWORK_TOOLS.has(t));
+  const desc = typeof data["description"] === "string" ? data["description"] : "";
+  const readonly = READONLY_HINT_RE.test(desc);
+  if (readonly && hasExec && hasNet) {
+    findings.push(
+      finding2(
+        "sec/suspicious-tool-combo",
+        "A read-only/docs skill grants both shell execution and network access \u2014 this combination enables data exfiltration. Remove one or revise the description.",
+        file.frontmatter.startLine || 1,
+        1,
+        makeEvidence(tokens.join(", "))
+      )
+    );
+  }
+}
+
+// src/grade.ts
+var PENALTY = {
+  lint: { error: 12, warning: 5, info: 1 },
+  // Security errors are deliberately severe: a single hard hit should never
+  // leave a file with a passing grade.
+  security: { error: 60, warning: 20, info: 4 }
+};
+function scoreFindings(findings) {
+  let penalty = 0;
+  for (const f of findings) {
+    penalty += PENALTY[f.category][f.severity];
+  }
+  return Math.max(0, Math.min(100, 100 - penalty));
+}
+function scoreToGrade(score) {
+  if (score >= 90) return "A";
+  if (score >= 80) return "B";
+  if (score >= 70) return "C";
+  if (score >= 60) return "D";
+  return "F";
+}
+function tally(findings) {
+  const totals = { error: 0, warning: 0, info: 0 };
+  for (const f of findings) totals[f.severity]++;
+  return totals;
+}
+function aggregateScore(fileScores) {
+  if (fileScores.length === 0) return 100;
+  const mean = fileScores.reduce((a, b) => a + b, 0) / fileScores.length;
+  const worst = Math.min(...fileScores);
+  return Math.round(mean * 0.6 + worst * 0.4);
+}
+
+// src/analyze.ts
+function sortFindings(findings) {
+  return [...findings].sort(
+    (a, b) => a.line - b.line || a.column - b.column || a.ruleId.localeCompare(b.ruleId) || a.message.localeCompare(b.message)
+  );
+}
+function analyzeParsed(file) {
+  const findings = [];
+  findings.push(...lintFile(file));
+  findings.push(...scanFile(file));
+  return findings;
+}
+function toFileReport(file, findings) {
+  const sorted = sortFindings(findings);
+  const score = scoreFindings(sorted);
+  return {
+    filePath: file.filePath,
+    kind: file.kind,
+    findings: sorted,
+    score,
+    grade: scoreToGrade(score)
+  };
+}
+function applyDuplicateNameRule(files, perFileFindings) {
+  const rule = getRule("skill/duplicate-name");
+  const byName = /* @__PURE__ */ new Map();
+  files.forEach((f, i) => {
+    const name = f.frontmatter.data?.["name"];
+    if (typeof name === "string" && name.trim().length > 0) {
+      const key = name.trim();
+      const arr = byName.get(key) ?? [];
+      arr.push(i);
+      byName.set(key, arr);
+    }
+  });
+  for (const [name, indices] of byName) {
+    if (indices.length < 2) continue;
+    for (const i of indices) {
+      const others = indices.filter((j) => j !== i).map((j) => files[j]?.filePath ?? "?");
+      perFileFindings[i]?.push({
+        ruleId: rule.ruleId,
+        title: rule.title,
+        category: rule.category,
+        severity: rule.defaultSeverity,
+        message: `Duplicate skill name "${name}" \u2014 also declared in: ${others.join(
+          ", "
+        )}. Clients keep only one.`,
+        line: files[i]?.frontmatter.startLine || 1,
+        column: 1,
+        fixable: rule.fixable
+      });
+    }
+  }
+}
+function analyzeContent(filePath, content, options = {}) {
+  const parsed = parseFile(filePath, content, options.forceKind);
+  const findings = analyzeParsed(parsed);
+  return toFileReport(parsed, findings);
+}
+function analyzeFiles(inputs, options = {}) {
+  const parsed = inputs.map(
+    (i) => parseFile(i.filePath, i.content, options.forceKind)
+  );
+  const perFileFindings = parsed.map((p) => analyzeParsed(p));
+  applyDuplicateNameRule(parsed, perFileFindings);
+  const reports = parsed.map(
+    (p, i) => toFileReport(p, perFileFindings[i] ?? [])
+  );
+  const all = reports.flatMap((r) => r.findings);
+  const aggregate = aggregateScore(reports.map((r) => r.score));
+  return {
+    files: reports,
+    score: aggregate,
+    grade: scoreToGrade(aggregate),
+    totals: tally(all)
+  };
+}
+function analyzePaths(paths, options = {}) {
+  const inputs = paths.map((p) => ({
+    filePath: p,
+    content: readFileSync(p, "utf-8")
+  }));
+  return analyzeFiles(inputs, options);
+}
+function parseForFix(filePath, content) {
+  return parseFile(filePath, content);
+}
+
+// src/fix.ts
+var DESCRIPTION_STUB = "TODO describe what this skill does and when to use it.";
+function fixFile(file) {
+  const applied = [];
+  if (file.kind === "agents-md" || file.kind === "unknown") {
+    return { output: file.raw, changed: false, applied };
+  }
+  if (!file.frontmatter.present) {
+    return { output: file.raw, changed: false, applied };
+  }
+  if (file.frontmatter.error) {
+    return { output: file.raw, changed: false, applied };
+  }
+  const fmLines = file.frontmatter.raw.split("\n");
+  let trimmedAny = false;
+  for (let i = 0; i < fmLines.length; i++) {
+    const line = fmLines[i] ?? "";
+    const trimmed = line.replace(/[ \t]+$/, "");
+    if (trimmed !== line) {
+      fmLines[i] = trimmed;
+      trimmedAny = true;
+    }
+  }
+  if (trimmedAny) applied.push("trailing-whitespace");
+  for (const key of ["allowed-tools", "tools"]) {
+    const idx = fmLines.findIndex(
+      (l) => new RegExp(`^${key}\\s*:`).test(l ?? "")
+    );
+    if (idx === -1) continue;
+    const line = fmLines[idx] ?? "";
+    const m = new RegExp(`^(${key}\\s*:\\s*)(.*)$`).exec(line);
+    if (!m) continue;
+    const prefix = m[1];
+    const rest = (m[2] ?? "").trim();
+    if (rest.length === 0 || rest.startsWith("[")) continue;
+    const tokens = parseToolList(rest);
+    if (tokens.length === 0) continue;
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const t of tokens) {
+      const key2 = t.trim();
+      if (!seen.has(key2)) {
+        deduped.push(t);
+        seen.add(key2);
+      }
+    }
+    if (deduped.length !== tokens.length) {
+      const sep2 = rest.includes(",") ? ", " : " ";
+      fmLines[idx] = prefix + deduped.join(sep2);
+      applied.push(`dedupe-${key}`);
+    }
+  }
+  const hasDescriptionKey = fmLines.some((l) => /^description\s*:/.test(l ?? ""));
+  const data = file.frontmatter.data;
+  const descMissing = !data || data["description"] === void 0 || data["description"] === null;
+  if (!hasDescriptionKey && descMissing) {
+    const nameIdx = fmLines.findIndex((l) => /^name\s*:/.test(l ?? ""));
+    let insertAt = 0;
+    if (nameIdx !== -1) {
+      const nameHasInlineValue = /^name\s*:\s*\S/.test(fmLines[nameIdx] ?? "");
+      const nextIsContinuation = /^\s/.test(fmLines[nameIdx + 1] ?? "");
+      insertAt = nameHasInlineValue && !nextIsContinuation ? nameIdx + 1 : 0;
+    }
+    fmLines.splice(insertAt, 0, `description: "${DESCRIPTION_STUB}"`);
+    applied.push("add-description-stub");
+  }
+  if (applied.length === 0) {
+    return { output: file.raw, changed: false, applied };
+  }
+  const newFrontmatter = fmLines.join("\n");
+  const eol = file.raw.includes("\r\n") ? "\r\n" : "\n";
+  const rebuilt = "---" + eol + newFrontmatter.split("\n").join(eol) + eol + "---" + eol + file.body.split("\n").join(eol);
+  return { output: rebuilt, changed: true, applied };
+}
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".cache"
+]);
+function isCandidateMarkdown(name) {
+  const lower = name.toLowerCase();
+  if (!lower.endsWith(".md")) return false;
+  return true;
+}
+function isGlob(p) {
+  return /[*?[\]{}]/.test(p);
+}
+function globToRegExp(glob) {
+  const g = glob.replace(/\\/g, "/");
+  let re = "";
+  for (let i = 0; i < g.length; i++) {
+    const c = g[i];
+    if (c === "*") {
+      if (g[i + 1] === "*") {
+        i++;
+        if (g[i + 1] === "/") i++;
+        while (g[i + 1] === "*" && g[i + 2] === "*") {
+          i += 2;
+          if (g[i + 1] === "/") i++;
+        }
+        re += "(?:.*/)?";
+      } else {
+        re += "[^/]*";
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if ("\\^$.|+()[]{}".includes(c)) {
+      re += "\\" + c;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp("^" + re + "$");
+}
+function walk(dir, out) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = join(dir, entry);
+    let st;
+    try {
+      st = statSync(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) {
+      if (IGNORED_DIRS.has(entry)) continue;
+      walk(full, out);
+    } else if (st.isFile() && isCandidateMarkdown(entry)) {
+      out.push(full);
+    }
+  }
+}
+function globBaseDir(glob) {
+  const norm = glob.replace(/\\/g, "/");
+  const firstMeta = norm.search(/[*?[\]{}]/);
+  const head = firstMeta === -1 ? norm : norm.slice(0, firstMeta);
+  const lastSlash = head.lastIndexOf("/");
+  const base = lastSlash === -1 ? "." : head.slice(0, lastSlash) || "/";
+  return base;
+}
+function toPosix(p) {
+  return p.split(sep).join(posix.sep);
+}
+function discoverFiles(specs) {
+  const found = /* @__PURE__ */ new Set();
+  for (const spec of specs) {
+    if (isGlob(spec)) {
+      const base = resolve(globBaseDir(spec));
+      const collected = [];
+      walk(base, collected);
+      const re = globToRegExp(toPosix(resolve(spec)));
+      for (const f of collected) {
+        if (re.test(toPosix(f))) found.add(f);
+      }
+      continue;
+    }
+    const abs = resolve(spec);
+    if (!existsSync(abs)) {
+      continue;
+    }
+    const st = statSync(abs);
+    if (st.isDirectory()) {
+      const collected = [];
+      walk(abs, collected);
+      for (const f of collected) found.add(f);
+    } else if (st.isFile()) {
+      found.add(abs);
+    }
+  }
+  return [...found].sort();
+}
+
+// src/output/terminal.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+function colorEnabled(opt) {
+  if (opt !== void 0) return opt;
+  if (process.env["NO_COLOR"] !== void 0) return false;
+  if (process.env["FORCE_COLOR"] !== void 0) return true;
+  return Boolean(process.stdout.isTTY);
+}
+function paint(s, code, on) {
+  return on ? `${code}${s}${ANSI.reset}` : s;
+}
+var SEVERITY_ICON = {
+  error: "\u2716",
+  warning: "\u26A0",
+  info: "\u2139"
+};
+var SEVERITY_COLOR = {
+  error: ANSI.red,
+  warning: ANSI.yellow,
+  info: ANSI.blue
+};
+var GRADE_COLOR = {
+  A: ANSI.green,
+  B: ANSI.green,
+  C: ANSI.yellow,
+  D: ANSI.yellow,
+  F: ANSI.red
+};
+function severityLabel(sev, on) {
+  return paint(`${SEVERITY_ICON[sev]} ${sev}`, SEVERITY_COLOR[sev], on);
+}
+function fileHeader(file, on) {
+  const gradeBadge = paint(
+    ` ${file.grade} `,
+    `${ANSI.bold}${GRADE_COLOR[file.grade]}`,
+    on
+  );
+  const kind = paint(`[${file.kind}]`, ANSI.gray, on);
+  return `${paint(file.filePath, ANSI.bold, on)} ${kind} ${gradeBadge}${paint(
+    `(${file.score}/100)`,
+    ANSI.dim,
+    on
+  )}`;
+}
+function findingLine(f, on) {
+  const loc = paint(`${f.line}:${f.column}`, ANSI.gray, on);
+  const sev = severityLabel(f.severity, on);
+  const rule = paint(f.ruleId, ANSI.cyan, on);
+  let out = `  ${loc}  ${sev}  ${f.message}  ${rule}`;
+  if (f.fixable) out += paint(" (fixable)", ANSI.dim, on);
+  if (f.evidence) {
+    out += `
+      ${paint("\u21B3 " + f.evidence, ANSI.gray, on)}`;
+  }
+  return out;
+}
+function renderTerminal(report, options = {}) {
+  const on = colorEnabled(options.color);
+  const lines = [];
+  if (report.files.length === 0) {
+    return paint("No skill / instruction files found.", ANSI.yellow, on);
+  }
+  for (const file of report.files) {
+    lines.push(fileHeader(file, on));
+    if (file.findings.length === 0) {
+      lines.push(paint("  \u2713 no findings", ANSI.green, on));
+    } else {
+      for (const f of file.findings) {
+        lines.push(findingLine(f, on));
+      }
+    }
+    lines.push("");
+  }
+  const { error, warning, info } = report.totals;
+  const summaryBadge = paint(
+    ` Grade ${report.grade} `,
+    `${ANSI.bold}${GRADE_COLOR[report.grade]}`,
+    on
+  );
+  lines.push(
+    paint("\u2500".repeat(48), ANSI.gray, on)
+  );
+  lines.push(
+    `${summaryBadge} ${paint(`${report.score}/100`, ANSI.bold, on)}  across ${report.files.length} file(s)`
+  );
+  lines.push(
+    `  ${paint(`${error} error(s)`, error ? ANSI.red : ANSI.gray, on)}  ${paint(`${warning} warning(s)`, warning ? ANSI.yellow : ANSI.gray, on)}  ${paint(`${info} info`, info ? ANSI.blue : ANSI.gray, on)}`
+  );
+  return lines.join("\n");
+}
+
+// src/output/json.ts
+var JSON_REPORT_VERSION = 1;
+function toJsonReport(report, toolVersion) {
+  return {
+    schemaVersion: JSON_REPORT_VERSION,
+    tool: { name: "skilldoctor", version: toolVersion },
+    summary: {
+      grade: report.grade,
+      score: report.score,
+      fileCount: report.files.length,
+      errors: report.totals.error,
+      warnings: report.totals.warning,
+      infos: report.totals.info
+    },
+    files: report.files
+  };
+}
+function jsonString(report, toolVersion) {
+  return JSON.stringify(toJsonReport(report, toolVersion), null, 2);
+}
+var SARIF_VERSION = "2.1.0";
+var SARIF_SCHEMA = "https://json.schemastore.org/sarif-2.1.0.json";
+var TOOL_NAME = "skilldoctor";
+var TOOL_INFO_URI = "https://github.com/studiomeyer-io/skilldoctor";
+function toSarifLevel(sev) {
+  switch (sev) {
+    case "error":
+      return "error";
+    case "warning":
+      return "warning";
+    case "info":
+      return "note";
+  }
+}
+function toUri(filePath, baseDir) {
+  const rel = relative(baseDir, filePath);
+  const norm = (rel === "" ? filePath : rel).split("\\").join("/");
+  return norm.replace(/^\.\//, "");
+}
+function fingerprint(uri, f) {
+  const norm = (f.evidence ?? f.message).replace(/\s+/g, " ").trim().toLowerCase();
+  return createHash("sha256").update(f.ruleId).update("\0").update(uri).update("\0").update(norm).digest("hex").slice(0, 16);
+}
+function toSarif(report, options = {}) {
+  const baseDir = options.baseDir ?? process.cwd();
+  const toolVersion = options.version ?? "0.0.0";
+  const ruleIndex = /* @__PURE__ */ new Map();
+  const rules = RULES.map((r, i) => {
+    ruleIndex.set(r.ruleId, i);
+    return {
+      id: r.ruleId,
+      name: toPascalName(r.ruleId),
+      shortDescription: { text: r.title },
+      fullDescription: { text: r.description },
+      defaultConfiguration: { level: toSarifLevel(r.defaultSeverity) },
+      properties: {
+        category: r.category,
+        fixable: r.fixable
+      }
+    };
+  });
+  const results = [];
+  for (const file of report.files) {
+    const uri = toUri(file.filePath, baseDir);
+    for (const f of file.findings) {
+      const idx = ruleIndex.get(f.ruleId);
+      if (idx === void 0) continue;
+      results.push({
+        ruleId: f.ruleId,
+        ruleIndex: idx,
+        level: toSarifLevel(f.severity),
+        message: { text: f.message },
+        locations: [
+          {
+            physicalLocation: {
+              artifactLocation: { uri },
+              region: {
+                startLine: f.line,
+                startColumn: f.column,
+                ...f.evidence ? { snippet: { text: f.evidence } } : {}
+              }
+            }
+          }
+        ],
+        partialFingerprints: {
+          skilldoctor: fingerprint(uri, f)
+        },
+        properties: {
+          category: f.category,
+          fixable: f.fixable
+        }
+      });
+    }
+  }
+  return {
+    $schema: SARIF_SCHEMA,
+    version: SARIF_VERSION,
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: TOOL_NAME,
+            informationUri: TOOL_INFO_URI,
+            version: toolVersion,
+            rules
+          }
+        },
+        results
+      }
+    ]
+  };
+}
+function sarifString(report, options) {
+  return JSON.stringify(toSarif(report, options), null, 2);
+}
+function toPascalName(ruleId) {
+  return ruleId.split(/[/\-_]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+
+export { DESCRIPTION_STUB, JSON_REPORT_VERSION, RULES, SARIF_SCHEMA, SARIF_VERSION, SEVERITY_RANK, aggregateScore, allRuleIds, analyzeContent, analyzeFiles, analyzePaths, detectKind, discoverFiles, extractFrontmatter, fixFile, getRule, globToRegExp, isGlob, jsonString, parseFile, parseForFix, renderTerminal, sarifString, scoreFindings, scoreToGrade, tally, toJsonReport, toSarif };