specpipe 1.0.0

package/src/lib/agents.js

@@ -0,0 +1,280 @@
+/**
+ * Agent registry + skill emitters.
+ *
+ * The canonical source of truth is the Claude-form skill:
+ *   kit/skills/<skill>/SKILL.md  (agent-neutral source; frontmatter: description [+ allowed-tools], body markdown)
+ *
+ * Each target agent gets its own emitter that rewrites the install path, the
+ * file name, and the frontmatter to that agent's native convention — while
+ * keeping the markdown body unchanged. Formats verified 2026-06-22 against
+ * each tool's docs / real repos; see docs/multi-agent.md for sources.
+ */
+
+/**
+ * Parse a SKILL.md into ordered top-level frontmatter keys + body.
+ * Block scalars (description: |) and their indented continuation lines are
+ * kept attached to their key, so we can re-emit them verbatim.
+ */
+export function parseSkill(content) {
+  const m = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!m) return { keys: [], body: content, hasFrontmatter: false };
+
+  const lines = m[1].split('\n');
+  const keys = [];
+  let cur = null;
+  for (const line of lines) {
+    const km = line.match(/^([A-Za-z][\w-]*):(.*)$/);
+    if (km && !/^\s/.test(line)) {
+      cur = { key: km[1], lines: [line] };
+      keys.push(cur);
+    } else if (cur) {
+      cur.lines.push(line);
+    }
+  }
+  return { keys, body: m[2], hasFrontmatter: true };
+}
+
+function getKeyBlock(parsed, key) {
+  const k = parsed.keys.find((x) => x.key === key);
+  return k ? k.lines.join('\n') : null;
+}
+
+/** Wrap frontmatter + body back into a file. */
+function compose(frontmatter, body) {
+  return `---\n${frontmatter}\n---\n${body}`;
+}
+
+/**
+ * Split a canonical skill relative path into its skill name + inner path.
+ * Canonical skills live in the agent-neutral `kit/skills/` (relative: `skills/`);
+ * each agent's emitter maps them to its own output location.
+ *   'skills/sp-plan/SKILL.md'            -> { skill: 'sp-plan', inner: 'SKILL.md' }
+ *   'skills/sp-scaffold/references/x.md' -> { skill: 'sp-scaffold', inner: 'references/x.md' }
+ */
+export function parseSkillPath(rel) {
+  const m = rel.replace(/\\/g, '/').match(/^skills\/([^/]+)\/(.+)$/);
+  if (!m) return null;
+  return { skill: m[1], inner: m[2] };
+}
+
+// ── Frontmatter emitters (per agent) ──────────────────────────────────────
+
+/** Claude: identity — keep the canonical frontmatter exactly. */
+function fmClaude(parsed) {
+  return parsed.keys.map((k) => k.lines.join('\n')).join('\n');
+}
+
+/** name + description only. allowed-tools (Claude-specific) is dropped. */
+function fmNameDesc(parsed, name) {
+  const desc = getKeyBlock(parsed, 'description') || 'description: ""';
+  return `name: ${name}\n${desc}`;
+}
+
+/** Hermes adds version + a metadata.hermes.tags block. */
+function fmHermes(parsed, name) {
+  const desc = getKeyBlock(parsed, 'description') || 'description: ""';
+  return [
+    `name: ${name}`,
+    desc,
+    'version: 1.0.0',
+    'metadata:',
+    '  hermes:',
+    '    tags: [specpipe, spec-first, tdd]',
+  ].join('\n');
+}
+
+
+// ── Agent registry ─────────────────────────────────────────────────────────
+
+export const AGENTS = {
+  claude: {
+    label: 'Claude Code',
+    // Verified: code.claude.com/docs/en/skills
+    skillTarget: (name, inner) => `.claude/skills/${name}/${inner}`,
+    globalRoot: '.claude/skills',
+    skillFile: 'SKILL.md',
+    hooks: 'native',
+    capabilities: 'full',
+    emitFrontmatter: fmClaude,
+  },
+  // Antigravity + Codex share the vendor-neutral `.agents/skills/` standard, so they emit
+  // to the same path with identical frontmatter — computeDesired's Map dedups them (one
+  // emission serves the family). Intentional; `list` then shows that file under one agent.
+  antigravity: {
+    label: 'Antigravity',
+    // Verified: official Google Codelab — .agents/skills/<name>/SKILL.md
+    skillTarget: (name, inner) => `.agents/skills/${name}/${inner}`,
+    globalRoot: '.agents/skills',
+    skillFile: 'SKILL.md',
+    hooks: 'rules', // guards emitted to .agent/rules/ (plain markdown)
+    capabilities: 'router-no-hooks',
+    emitFrontmatter: fmNameDesc,
+  },
+  openclaw: {
+    label: 'OpenClaw',
+    // Verified: github.com/openclaw/openclaw  skills/<name>/SKILL.md
+    skillTarget: (name, inner) => `skills/${name}/${inner}`,
+    globalRoot: 'skills',
+    skillFile: 'SKILL.md',
+    hooks: 'none',
+    capabilities: 'router-no-hooks',
+    emitFrontmatter: fmNameDesc,
+  },
+  hermes: {
+    label: 'Hermes-Agent',
+    // Verified: github.com/NousResearch/hermes-agent  optional-skills/<cat>/<name>/SKILL.md
+    skillTarget: (name, inner) => `optional-skills/specpipe/${name}/${inner}`,
+    globalRoot: 'optional-skills/specpipe',
+    skillFile: 'SKILL.md',
+    hooks: 'none',
+    capabilities: 'router-no-hooks',
+    emitFrontmatter: fmHermes,
+  },
+  codex: {
+    label: 'OpenAI Codex CLI',
+    // Verified (developers.openai.com/codex/skills + openai/codex repo): Codex Agent
+    // Skills live in the vendor-neutral `.agents/skills/` (NOT `.codex/skills/`, which
+    // is a known non-working path — openai/codex#15136). Custom-prompts are deprecated.
+    skillTarget: (name, inner) => `.agents/skills/${name}/${inner}`,
+    globalRoot: '.agents/skills',
+    skillFile: 'SKILL.md',
+    hooks: 'agents-md', // guards fold into AGENTS.md (plain markdown, no frontmatter)
+    capabilities: 'router-no-hooks',
+    emitFrontmatter: fmNameDesc,
+  },
+  cursor: {
+    label: 'Cursor',
+    // Verified: cursor.com/help/customization/skills — Cursor has NATIVE skills at
+    // .cursor/skills/<name>/SKILL.md (also reads .claude/skills & .agents/skills).
+    // Skills are on-demand (/skill, @skill) — the correct home, not always-on .mdc rules.
+    // Guards stay an always-on .cursor/rules/*.mdc (see RULES.cursor).
+    skillTarget: (name, inner) => `.cursor/skills/${name}/${inner}`,
+    globalRoot: '.cursor/skills',
+    skillFile: 'SKILL.md',
+    hooks: 'rules', // advisory now; Cursor DOES support blocking hooks (.cursor/hooks.json) — roadmapped
+    capabilities: 'router-no-hooks',
+    emitFrontmatter: fmNameDesc,
+  },
+};
+
+export const AGENT_IDS = Object.keys(AGENTS);
+export const DEFAULT_AGENT = 'claude';
+
+/**
+ * Resolve a --agents string into a validated list of agent ids.
+ * 'all' -> every agent. Comma-separated -> those ids. Throws on unknown id.
+ */
+export function resolveAgents(spec) {
+  if (!spec) return [DEFAULT_AGENT];
+  if (spec === 'all') return [...AGENT_IDS];
+  const ids = spec.split(',').map((s) => s.trim()).filter(Boolean);
+  const unknown = ids.filter((id) => !AGENTS[id]);
+  if (unknown.length) {
+    throw new Error(`Unknown agent(s): ${unknown.join(', ')}. Valid: ${AGENT_IDS.join(', ')}, all`);
+  }
+  return ids;
+}
+
+/**
+ * Emit one canonical skill file for a target agent.
+ * @param {string} agentId
+ * @param {string} canonicalRel - e.g. '.claude/skills/sp-plan/SKILL.md'
+ * @param {string} content - the canonical file content
+ * @returns {{ path: string, content: string } | null} target rel path + content, or null if not a skill file
+ */
+export function emitSkillFile(agentId, canonicalRel, content) {
+  const agent = AGENTS[agentId];
+  if (!agent) throw new Error(`Unknown agent: ${agentId}`);
+
+  const parts = parseSkillPath(canonicalRel);
+  if (!parts) return null;
+  const { skill, inner } = parts;
+
+  const path = agent.skillTarget(skill, inner);
+
+  // Non-SKILL.md files (references, templates, examples) copy verbatim.
+  if (inner !== 'SKILL.md') return { path, content };
+
+  // Claude is identity — skip the parse/recompose round-trip entirely.
+  if (agentId === 'claude') return { path, content };
+
+  const parsed = parseSkill(content);
+  if (!parsed.hasFrontmatter) return { path, content };
+
+  const body = adaptBody(agentId, parsed.body, toolsOf(parsed));
+  return { path, content: compose(agent.emitFrontmatter(parsed, skill), body) };
+}
+
+/** Tools a canonical skill declares (from its `allowed-tools` frontmatter). */
+function toolsOf(parsed) {
+  const block = getKeyBlock(parsed, 'allowed-tools');
+  if (!block) return [];
+  return block.replace(/^allowed-tools:\s*/, '').split(',').map((s) => s.trim()).filter(Boolean);
+}
+
+// Phrase-level rewrites that turn Claude's `AskUserQuestion` tool references into
+// an explicit, mechanism-named instruction every conversational agent can follow:
+// present one structured multiple-choice question in plain text and wait. Ordered
+// most-specific first so the result stays grammatical (not a bare token swap).
+const ASK = 'a single plain-text multiple-choice question';
+const ASK_SUBS = [
+  [/go through the `?AskUserQuestion`? tool\s+—\s+never ask inline in text/gi, `be presented as ${ASK} (wait for the reply — don't bury choices in prose)`],
+  [/\bthe `?AskUserQuestion`? tool\b/gi, ASK],
+  [/\b(a single|one) `?AskUserQuestion`? call\b/gi, ASK],
+  [/`?AskUserQuestion`? call\b/gi, ASK],
+  [/`?AskUserQuestion`? format\b/gi, 'question format'],
+  [/\bEvery `?AskUserQuestion`?\b/g, 'Every question'],
+  [/\b(via|through|with|using) `?AskUserQuestion`?/gi, `$1 ${ASK}`],
+  [/\b[Uu]se `?AskUserQuestion`?/g, `ask ${ASK}`],
+  [/`?AskUserQuestion`?/g, ASK],
+];
+
+function rewriteAsk(body) {
+  return ASK_SUBS.reduce((s, [re, to]) => s.replace(re, to), body);
+}
+
+/**
+ * Adapt a skill body for a non-Claude agent (Phase 3). Claude gets the body
+ * verbatim. For other agents:
+ *  - AskUserQuestion references are rewritten in place into an explicit
+ *    "plain-text multiple-choice question" instruction (mechanism named, so the
+ *    agent knows exactly what to do — not vague prose).
+ *  - Subagent orchestration can't be fixed by wording (it's an execution model),
+ *    so it gets an honest caveat appended.
+ *  - GraphAtlas already self-degrades in the body ("if GA available … else grep"),
+ *    so it needs no adaptation.
+ */
+function adaptBody(agentId, body, tools) {
+  if (agentId === 'claude') return body;
+
+  const has = (name) => tools.some((t) => t === name || t.startsWith(name));
+  let out = rewriteAsk(body);
+
+  if (has('Agent') || has('Task')) {
+    out = `${out.replace(/\s*$/, '')}\n\n---\n\n## Running on ${AGENTS[agentId].label}\n\n` +
+      '- **Subagents:** parts of this skill describe Claude subagent orchestration ' +
+      '(parallel waves, worktrees, auto-mode dispatch). If your runtime has no ' +
+      'subagents, do that work yourself — one item at a time, sequentially, in this ' +
+      'session — and skip the parallel/worktree mechanics.\n';
+  }
+  return out;
+}
+
+/**
+ * Emit ANY canonical template file for an agent.
+ * Skill files are transformed (see emitSkillFile); everything else (hooks,
+ * config, docs) is copied verbatim at its original relative path. This gives
+ * lifecycle commands a single way to reproduce a file's desired content.
+ * @returns {{ path: string, content: string }}
+ */
+export function emitFile(agentId, templateRel, content) {
+  const skill = emitSkillFile(agentId, templateRel, content);
+  return skill || { path: templateRel, content };
+}
+
+// Guardrails (advisory rules) + enforced (blocking) hooks live in agent-guards.js;
+// re-exported here so callers keep importing them from agents.js.
+export {
+  GUARDS_BEGIN, GUARDS_END, HOOKS_SRC_DIR,
+  agentRulesMode, emitRules, agentHasHooks, emitHooks,
+} from './agent-guards.js';

package/src/lib/claude-global.js

@@ -0,0 +1,183 @@
+import { copyFile as fsCopyFile, mkdir, readFile, writeFile, chmod } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { log } from './logger.js';
+import { getTemplateDir } from './installer.js';
+
+// Claude's global install (~/.claude/skills, ~/.claude/hooks, ~/.claude/settings.json).
+// Claude-only: it's Claude Code's own enforcement engine; other agents have no equivalent.
+
+/** Global skills directory: ~/.claude/skills/ */
+export function getGlobalSkillsDir() {
+  return join(homedir(), '.claude', 'skills');
+}
+
+/** Global hooks directory: ~/.claude/hooks/ */
+export function getGlobalHooksDir() {
+  return join(homedir(), '.claude', 'hooks');
+}
+
+/**
+ * Copy a hook to the global ~/.claude/hooks/ directory.
+ * Strips the '.claude/hooks/' prefix so path-guard.sh lands at ~/.claude/hooks/path-guard.sh.
+ * @returns {{ result: 'copied'|'skipped'|'identical', kitHash: string }}
+ */
+export async function installHookGlobal(hookRelPath, globalHooksDir, { force = false, globalFiles = {} } = {}) {
+  const stripped = hookRelPath.replace(/^\.claude\/hooks\//, '');
+  const src = join(getTemplateDir(), hookRelPath);
+  const dst = join(globalHooksDir, stripped);
+
+  const { hashFile } = await import('./hasher.js');
+  const srcHash = await hashFile(src);
+
+  if (existsSync(dst) && !force) {
+    try {
+      const dstHash = await hashFile(dst);
+      if (srcHash === dstHash) {
+        log.same(`~/.claude/hooks/${stripped} (identical)`);
+        return { result: 'identical', kitHash: srcHash };
+      }
+      const savedKitHash = globalFiles[hookRelPath]?.kitHash;
+      if (savedKitHash && dstHash === savedKitHash) {
+        // fall through to copy
+      } else {
+        log.skip(`~/.claude/hooks/${stripped} (customized — use --force to overwrite)`);
+        return { result: 'skipped', kitHash: srcHash };
+      }
+    } catch { /* hash failed */ }
+  }
+
+  await mkdir(dirname(dst), { recursive: true });
+  await fsCopyFile(src, dst);
+  await chmod(dst, 0o755);
+  log.copy(`~/.claude/hooks/${stripped}`);
+  return { result: 'copied', kitHash: srcHash };
+}
+
+/** Build hook entries for ~/.claude/settings.json pointing to globalHooksDir. */
+function buildGlobalHookEntries(globalHooksDir) {
+  // Normalize to forward slashes — bash on all platforms (WSL, Git Bash, macOS, Linux)
+  // requires forward slashes even when the host OS is Windows.
+  const dir = globalHooksDir.replace(/\\/g, '/');
+  const h = (file) => `"${dir}/${file}"`;
+  return {
+    PreToolUse: [
+      { matcher: 'Bash', hooks: [
+        { type: 'command', command: `bash ${h('path-guard.sh')}` },
+        { type: 'command', command: `bash ${h('sensitive-guard.sh')}` },
+      ]},
+      { matcher: 'Read|Write|Edit|MultiEdit|Grep', hooks: [
+        { type: 'command', command: `bash ${h('sensitive-guard.sh')}` },
+      ]},
+      { matcher: 'Edit|MultiEdit', hooks: [
+        { type: 'command', command: `node ${h('comment-guard.js')}` },
+      ]},
+      { matcher: 'Glob', hooks: [
+        { type: 'command', command: `node ${h('glob-guard.js')}` },
+      ]},
+    ],
+    PostToolUse: [
+      { matcher: 'Write|Edit|MultiEdit', hooks: [
+        { type: 'command', command: `node ${h('file-guard.js')}` },
+      ]},
+    ],
+    Stop: [
+      { matcher: '', hooks: [
+        { type: 'command', command: `bash ${h('self-review.sh')}` },
+      ]},
+    ],
+  };
+}
+
+function isDevkitHookCommand(command) {
+  return command.includes('/.claude/hooks/');
+}
+
+function stripDevkitHooks(existingHooks) {
+  if (!existingHooks || typeof existingHooks !== 'object') return {};
+  const result = {};
+  for (const [event, matchers] of Object.entries(existingHooks)) {
+    if (!Array.isArray(matchers)) continue;
+    const kept = [];
+    for (const group of matchers) {
+      const keptHooks = (group.hooks || []).filter((h) => !isDevkitHookCommand(h.command || ''));
+      if (keptHooks.length > 0) kept.push({ ...group, hooks: keptHooks });
+    }
+    if (kept.length > 0) result[event] = kept;
+  }
+  return result;
+}
+
+/**
+ * Merge devkit hook registrations into ~/.claude/settings.json.
+ * Preserves any existing non-devkit hooks the user may have.
+ */
+export async function mergeGlobalSettings(globalHooksDir) {
+  const settingsPath = join(homedir(), '.claude', 'settings.json');
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(settingsPath, 'utf-8'));
+  } catch { /* file doesn't exist yet — start fresh */ }
+
+  const cleanedHooks = stripDevkitHooks(existing.hooks);
+  const newEntries = buildGlobalHookEntries(globalHooksDir);
+  const mergedHooks = { ...cleanedHooks };
+  for (const [event, entries] of Object.entries(newEntries)) {
+    mergedHooks[event] = [...(mergedHooks[event] || []), ...entries];
+  }
+
+  await mkdir(dirname(settingsPath), { recursive: true });
+  await writeFile(settingsPath, JSON.stringify({ ...existing, hooks: mergedHooks }, null, 2) + '\n');
+}
+
+/**
+ * Remove devkit hook registrations from ~/.claude/settings.json.
+ * Leaves any non-devkit hooks untouched.
+ */
+export async function removeGlobalHooksFromSettings() {
+  const settingsPath = join(homedir(), '.claude', 'settings.json');
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(settingsPath, 'utf-8'));
+  } catch { return; }
+
+  const cleanedHooks = stripDevkitHooks(existing.hooks || {});
+  await writeFile(settingsPath, JSON.stringify({ ...existing, hooks: cleanedHooks }, null, 2) + '\n');
+}
+
+/**
+ * Copy a skill to the global ~/.claude/skills/ directory.
+ * Strips the 'skills/' prefix so sp-plan/SKILL.md lands at ~/.claude/skills/sp-plan/SKILL.md.
+ * @returns {{ result: 'copied'|'skipped'|'identical', kitHash: string }}
+ */
+export async function installSkillGlobal(skillRelPath, globalSkillsDir, { force = false, globalFiles = {} } = {}) {
+  const stripped = skillRelPath.replace(/^skills\//, '');
+  const src = join(getTemplateDir(), skillRelPath);
+  const dst = join(globalSkillsDir, stripped);
+
+  const { hashFile } = await import('./hasher.js');
+  const srcHash = await hashFile(src);
+
+  if (existsSync(dst) && !force) {
+    try {
+      const dstHash = await hashFile(dst);
+      if (srcHash === dstHash) {
+        log.same(`~/.claude/skills/${stripped} (identical)`);
+        return { result: 'identical', kitHash: srcHash };
+      }
+      const savedKitHash = globalFiles[skillRelPath]?.kitHash;
+      if (savedKitHash && dstHash === savedKitHash) {
+        // fall through to copy
+      } else {
+        log.skip(`~/.claude/skills/${stripped} (customized — use --force to overwrite)`);
+        return { result: 'skipped', kitHash: srcHash };
+      }
+    } catch { /* hash failed, treat as conflict */ }
+  }
+
+  await mkdir(dirname(dst), { recursive: true });
+  await fsCopyFile(src, dst);
+  log.copy(`~/.claude/skills/${stripped}`);
+  return { result: 'copied', kitHash: srcHash };
+}

package/src/lib/detector.js

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Auto-detect project type from marker files.
+ * @param {string} targetDir
+ * @returns {{ lang: string, framework: string, srcDir: string, testDir: string } | null}
+ */
+export function detectProject(targetDir) {
+  const has = (file) => existsSync(join(targetDir, file));
+  const hasGlob = (ext) => {
+    try {
+      return readdirSync(targetDir).some((f) => f.endsWith(ext));
+    } catch {
+      return false;
+    }
+  };
+  const packageContains = (str) => {
+    try {
+      return readFileSync(join(targetDir, 'package.json'), 'utf-8').includes(str);
+    } catch {
+      return false;
+    }
+  };
+  const gemfileContains = (str) => {
+    try {
+      return readFileSync(join(targetDir, 'Gemfile'), 'utf-8').includes(str);
+    } catch {
+      return false;
+    }
+  };
+
+  // Swift (SPM)
+  if (has('Package.swift')) {
+    return { lang: 'Swift', framework: 'XCTest (SPM)', srcDir: 'Sources', testDir: 'Tests' };
+  }
+
+  // Swift (Xcode)
+  if (hasGlob('.xcworkspace') || hasGlob('.xcodeproj')) {
+    return { lang: 'Swift', framework: 'XCTest (Xcode)', srcDir: 'Sources', testDir: 'Tests' };
+  }
+
+  // Node.js / TypeScript
+  if (has('package.json')) {
+    let framework = 'npm test';
+    if (has('vitest.config.ts') || has('vitest.config.js') || has('vitest.config.mts') || packageContains('"vitest"')) {
+      framework = 'Vitest';
+    } else if (has('jest.config.ts') || has('jest.config.js') || has('jest.config.mjs') || packageContains('"jest"')) {
+      framework = 'Jest';
+    }
+    const testDir = existsSync(join(targetDir, '__tests__')) ? '__tests__' : 'tests';
+    return { lang: 'TypeScript/JavaScript', framework, srcDir: 'src', testDir };
+  }
+
+  // Python
+  if (has('pyproject.toml') || has('setup.py') || has('pytest.ini')) {
+    return { lang: 'Python', framework: 'pytest', srcDir: 'src', testDir: 'tests' };
+  }
+
+  // Rust
+  if (has('Cargo.toml')) {
+    return { lang: 'Rust', framework: 'cargo test', srcDir: 'src', testDir: 'tests' };
+  }
+
+  // Go
+  if (has('go.mod')) {
+    return { lang: 'Go', framework: 'go test', srcDir: '.', testDir: '.' };
+  }
+
+  // Java/Kotlin (Gradle)
+  if (has('build.gradle') || has('build.gradle.kts')) {
+    return { lang: 'Java/Kotlin', framework: 'Gradle', srcDir: 'src/main', testDir: 'src/test' };
+  }
+
+  // Java (Maven)
+  if (has('pom.xml')) {
+    return { lang: 'Java', framework: 'Maven', srcDir: 'src/main', testDir: 'src/test' };
+  }
+
+  // C# (.NET)
+  if (hasGlob('.sln')) {
+    return { lang: 'C#', framework: '.NET (dotnet test)', srcDir: 'src', testDir: 'tests' };
+  }
+
+  // Ruby
+  if (has('Gemfile')) {
+    const framework = gemfileContains('rspec') ? 'RSpec' : 'Minitest';
+    const testDir = framework === 'RSpec' ? 'spec' : 'test';
+    return { lang: 'Ruby', framework, srcDir: 'lib', testDir };
+  }
+
+  return null;
+}

package/src/lib/hasher.js

@@ -0,0 +1,21 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+
+/**
+ * Compute SHA-256 hash of a file.
+ * @param {string} filePath
+ * @returns {Promise<string>} hex digest
+ */
+export async function hashFile(filePath) {
+  const content = await readFile(filePath);
+  return createHash('sha256').update(content).digest('hex');
+}
+
+/**
+ * Compute SHA-256 hash of a string/buffer.
+ * @param {string|Buffer} content
+ * @returns {string} hex digest
+ */
+export function hashContent(content) {
+  return createHash('sha256').update(content).digest('hex');
+}