bearings 0.2.0 → 0.3.0

package/dist/cli.js

@@ -1,53 +1,22 @@
 #!/usr/bin/env node
+import {
+  inspectManifest,
+  renderVerifyReport,
+  runInit,
+  sha256,
+  validateHarnesses
+} from "./chunk-GUIHDRBB.js";
 
 // src/cli.ts
 import { Command } from "commander";
 import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname4, join as join8 } from "path";
-
-// src/commands/init.ts
-import { lstat as lstat2, readdir as readdir2 } from "fs/promises";
-import { join as join6 } from "path";
-
-// src/scanner.ts
-import { access, symlink, rm } from "fs/promises";
-import { join as join2 } from "path";
-
-// src/paths.ts
 import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-function templatesDir() {
-  return join(dirname(fileURLToPath(import.meta.url)), "..", "templates");
-}
-var SKILLS = [
-  "repo-navigation",
-  "implementing-task",
-  "installing-dependencies",
-  "secrets-handling",
-  "enforcement-gates",
-  "commit-convention",
-  "defer-work",
-  "resurface-deferred-work"
-];
-var SCAFFOLD = [
-  { template: "AGENTS.md", target: "AGENTS.md", owner: "agent" },
-  { template: "CLAUDE.md", target: "CLAUDE.md", owner: "bearings" },
-  { template: "docs/CURRENT_STATE.md", target: "docs/CURRENT_STATE.md", owner: "agent" },
-  { template: "docs/conventions/current-state.md", target: "docs/conventions/current-state.md", owner: "bearings" },
-  { template: "docs/conventions/doc-lifecycle.md", target: "docs/conventions/doc-lifecycle.md", owner: "bearings" },
-  { template: "docs/adr/0000-template.md", target: "docs/adr/0000-template.md", owner: "bearings" },
-  { template: "docs/deferred/INDEX.md", target: "docs/deferred/INDEX.md", owner: "agent" },
-  { template: "agents/commands/current-state.md", target: ".agents/commands/current-state.md", owner: "bearings" },
-  { template: "agents/commands/setup-repo.md", target: ".agents/commands/setup-repo.md", owner: "bearings" },
-  ...SKILLS.map((s) => ({
-    template: `agents/skills/${s}/SKILL.md`,
-    target: `.agents/skills/${s}/SKILL.md`,
-    owner: s === "installing-dependencies" || s === "secrets-handling" ? "agent" : "bearings"
-  }))
-];
+import { dirname as dirname2, join as join2 } from "path";
 
-// src/scanner.ts
+// src/verifier.ts
+import { access, lstat, readFile, readdir, readlink, stat } from "fs/promises";
+import { dirname, join, resolve } from "path";
+var KINDS = ["skills", "commands"];
 async function exists(p) {
   try {
     await access(p);
@@ -56,348 +25,56 @@ async function exists(p) {
     return false;
   }
 }
-async function scan(repoDir) {
-  const collisions = [];
-  for (const e of SCAFFOLD) if (await exists(join2(repoDir, e.target))) collisions.push(e.target);
-  const harnessDirsPresent = [];
-  for (const h of ["claude", "opencode"])
-    if (await exists(join2(repoDir, `.${h}`))) harnessDirsPresent.push(h);
-  let symlinksSupported = true;
-  const probe = join2(repoDir, ".bearings-symlink-probe");
-  try {
-    await symlink(".", probe);
-    await rm(probe);
-  } catch {
-    symlinksSupported = false;
-  }
-  return { collisions, harnessDirsPresent, symlinksSupported };
-}
-
-// src/generator.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, rename, access as access2 } from "fs/promises";
-import { dirname as dirname2, join as join4 } from "path";
-
-// src/manifest.ts
-import { createHash } from "crypto";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { join as join3 } from "path";
-function sha256(content) {
-  return "sha256:" + createHash("sha256").update(content).digest("hex");
-}
-function manifestPath(repoDir) {
-  return join3(repoDir, ".agents", "bearings.json");
-}
-async function saveManifest(repoDir, m) {
-  await mkdir(join3(repoDir, ".agents"), { recursive: true });
-  await writeFile(manifestPath(repoDir), JSON.stringify(m, null, 2) + "\n");
-}
-async function loadManifest(repoDir) {
-  try {
-    return JSON.parse(await readFile(manifestPath(repoDir), "utf8"));
-  } catch {
-    return null;
-  }
-}
-
-// src/generator.ts
-async function exists2(p) {
-  try {
-    await access2(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function freeBackupPath(repoDir, target) {
-  let candidate = `${target}.bkp`;
-  for (let i = 1; await exists2(join4(repoDir, candidate)); i++) candidate = `${target}.bkp.${i}`;
-  return candidate;
-}
-async function generate(repoDir, bearingsVersion) {
-  const prior = await loadManifest(repoDir);
-  const result = { written: [], backedUp: [], skippedUnchanged: [], files: [] };
-  for (const entry of SCAFFOLD) {
-    const abs = join4(repoDir, entry.target);
-    const templateContent = await readFile2(join4(templatesDir(), entry.template), "utf8");
-    const priorEntry = prior?.files.find((f) => f.path === entry.target);
-    let backup;
-    if (await exists2(abs)) {
-      const current = await readFile2(abs, "utf8");
-      if (priorEntry && sha256(current) === priorEntry.hash) {
-        result.skippedUnchanged.push(entry.target);
-        result.files.push(priorEntry);
-        continue;
-      }
-      backup = await freeBackupPath(repoDir, entry.target);
-      await rename(abs, join4(repoDir, backup));
-      result.backedUp.push({ path: entry.target, backup });
-    }
-    await mkdir2(dirname2(abs), { recursive: true });
-    await writeFile2(abs, templateContent);
-    result.written.push(entry.target);
-    result.files.push({
-      path: entry.target,
-      template: entry.template,
-      templateVersion: bearingsVersion,
-      hash: sha256(templateContent),
-      owner: entry.owner,
-      ...backup ? { backup } : {}
-    });
-  }
-  return result;
-}
-
-// src/adapters.ts
-import { mkdir as mkdir3, readdir, symlink as symlink2, lstat, readlink, rm as rm2, cp, readFile as readFile3 } from "fs/promises";
-import { join as join5 } from "path";
-var KINDS = ["skills", "commands"];
-async function entriesMatch(src, dst) {
-  const srcStat = await lstat(src).catch(() => null);
-  const dstStat = await lstat(dst).catch(() => null);
-  if (!srcStat || !dstStat) return false;
-  if (srcStat.isSymbolicLink() || dstStat.isSymbolicLink()) {
-    return srcStat.isSymbolicLink() && dstStat.isSymbolicLink() && await readlink(src) === await readlink(dst);
+async function verify(repoDir) {
+  const failures = [];
+  const warnings = [];
+  const state = await inspectManifest(repoDir);
+  if (state.kind === "absent") {
+    return { failures: [{ code: "no-manifest", path: ".agents/bearings.json", message: "run bearings init first" }], warnings };
   }
-  if (srcStat.isDirectory() || dstStat.isDirectory()) {
-    if (!srcStat.isDirectory() || !dstStat.isDirectory()) return false;
-    const [srcEntries, dstEntries] = await Promise.all([readdir(src), readdir(dst)]);
-    if (srcEntries.length !== dstEntries.length) return false;
-    srcEntries.sort();
-    dstEntries.sort();
-    for (let i = 0; i < srcEntries.length; i++) {
-      if (srcEntries[i] !== dstEntries[i]) return false;
-      if (!await entriesMatch(join5(src, srcEntries[i]), join5(dst, dstEntries[i]))) return false;
-    }
-    return true;
+  if (state.kind === "invalid") {
+    return { failures: [{ code: "invalid-manifest", path: ".agents/bearings.json", message: state.message }], warnings };
   }
-  if (srcStat.isFile() || dstStat.isFile()) {
-    return srcStat.isFile() && dstStat.isFile() && (await readFile3(src)).equals(await readFile3(dst));
+  const m = state.manifest;
+  if ("setupPending" in m && m.setupPending) {
+    warnings.push({ code: "setup-pending", path: ".agents/bearings.json", message: "run /setup-repo to finish the pending update" });
   }
-  return false;
-}
-async function expose(repoDir, harness, mode) {
-  const created = [];
-  for (const kind of KINDS) {
-    const srcDir = join5(repoDir, ".agents", kind);
-    let entries;
-    try {
-      entries = await readdir(srcDir);
-    } catch {
-      continue;
-    }
-    const dstDir = join5(repoDir, `.${harness}`, kind);
-    await mkdir3(dstDir, { recursive: true });
-    for (const name of entries) {
-      const dst = join5(dstDir, name);
-      const adapterPath = join5(`.${harness}`, kind, name);
-      const relTarget = join5("..", "..", ".agents", kind, name);
-      const stat2 = await lstat(dst).catch(() => null);
-      if (mode === "symlink") {
-        if (stat2?.isSymbolicLink() && await readlink(dst) === relTarget) continue;
-        if (stat2 && !stat2.isSymbolicLink()) throw new Error(`Refusing to replace existing adapter entry: ${adapterPath}`);
-        if (stat2) await rm2(dst, { recursive: true });
-        await symlink2(relTarget, dst);
+  for (const f of m.files) {
+    const retired = "retired" in f && f.retired === true;
+    if (!retired) {
+      const abs = join(repoDir, f.path);
+      if (!await exists(abs)) {
+        failures.push({ code: "missing-file", path: f.path, message: "managed file deleted" });
       } else {
-        const src = join5(srcDir, name);
-        if (stat2 && await entriesMatch(src, dst)) continue;
-        if (stat2 && !stat2.isSymbolicLink()) throw new Error(`Refusing to replace existing adapter entry: ${adapterPath}`);
-        if (stat2) await rm2(dst, { recursive: true });
-        await cp(src, dst, { recursive: true });
-      }
-      created.push(adapterPath);
-    }
-  }
-  return created;
-}
-
-// src/report.ts
-function renderInitReport(r, exposed, m) {
-  const lines = ["bearings init complete.", ""];
-  lines.push(`Written (${r.written.length}):`, ...r.written.map((p) => `  + ${p}`));
-  if (r.backedUp.length) {
-    lines.push("", `Backed up (${r.backedUp.length}) \u2014 review during /setup-repo:`);
-    lines.push(...r.backedUp.map((b) => `  \u26A0 ${b.path} -> ${b.backup}`));
-  }
-  if (r.skippedUnchanged.length) {
-    lines.push(
-      "",
-      `Skipped, unchanged (${r.skippedUnchanged.length}):`,
-      ...r.skippedUnchanged.map((p) => `  = ${p}`)
-    );
-  }
-  lines.push(
-    "",
-    `Exposed to harnesses [${m.harnesses.join(", ")}] via ${m.exposure}:`,
-    ...exposed.map((p) => `  ~ ${p}`)
-  );
-  lines.push(
-    "",
-    "Next step \u2014 finish setup with your AI agent:",
-    "  Open your agent (Claude Code, OpenCode, ...) in this repo and run:",
-    "    /setup-repo",
-    "  It will review any backups, interview you, and tailor the setup.",
-    "  Finish by running: bearings verify"
-  );
-  return lines.join("\n");
-}
-function renderVerifyReport(v) {
-  const lines = [];
-  for (const f of v.failures) lines.push(`FAIL ${f.code} ${f.path} \u2014 ${f.message}`);
-  for (const w of v.warnings) lines.push(`warn ${w.code} ${w.path} \u2014 ${w.message}`);
-  lines.push(v.failures.length ? `
-${v.failures.length} failure(s).` : "\nbearings verify: OK");
-  return lines.join("\n");
-}
-
-// src/commands/init.ts
-var VALID_HARNESSES = ["claude", "opencode"];
-var KINDS2 = ["skills", "commands"];
-function validateHarnesses(harnesses) {
-  if (!harnesses) return void 0;
-  for (const harness of harnesses) {
-    if (!VALID_HARNESSES.includes(harness)) {
-      throw new Error(`Invalid harness: ${String(harness)}`);
-    }
-  }
-  return harnesses;
-}
-function cancelInit(p) {
-  p.cancel("Init cancelled.");
-  throw new Error("Init cancelled.");
-}
-async function plannedAdapterSources(repoDir) {
-  const sources = { skills: /* @__PURE__ */ new Map(), commands: /* @__PURE__ */ new Map() };
-  for (const entry of SCAFFOLD) {
-    for (const kind of KINDS2) {
-      const prefix = `.agents/${kind}/`;
-      if (entry.target.startsWith(prefix)) {
-        const name = entry.target.slice(prefix.length).split("/")[0];
-        sources[kind].set(name, join6(templatesDir(), "agents", kind, name));
+        const content = await readFile(abs, "utf8");
+        if (f.owner === "agent" && content.includes("<agent:")) {
+          warnings.push({ code: "unfilled-placeholder", path: f.path, message: "run /setup-repo to fill" });
+        }
       }
     }
-  }
-  for (const kind of KINDS2) {
-    const srcDir = join6(repoDir, ".agents", kind);
-    for (const name of await readdir2(srcDir).catch(() => [])) {
-      if (!sources[kind].has(name)) sources[kind].set(name, join6(srcDir, name));
-    }
-  }
-  return sources;
-}
-async function preflightAdapterCollisions(repoDir, harnesses, exposure) {
-  const sources = await plannedAdapterSources(repoDir);
-  for (const h of harnesses) {
-    for (const kind of KINDS2) {
-      for (const [name, source] of sources[kind]) {
-        const adapterPath = join6(`.${h}`, kind, name);
-        const target = join6(repoDir, adapterPath);
-        const stat2 = await lstat2(target).catch(() => null);
-        if (!stat2 || stat2.isSymbolicLink()) continue;
-        if (exposure === "copy" && await entriesMatch(source, target)) continue;
-        throw new Error(`Refusing to replace existing adapter entry: ${adapterPath}`);
-      }
+    if ("backup" in f && f.backup && await exists(join(repoDir, f.backup))) {
+      warnings.push({ code: "unreviewed-backup", path: f.backup, message: "review during /setup-repo, then delete" });
     }
-  }
-}
-async function runInit(repoDir, flags, version) {
-  const s = await scan(repoDir);
-  let harnesses = validateHarnesses(flags.harnesses);
-  let exposure = flags.exposure;
-  if (!harnesses || !exposure) {
-    if (flags.yes || !process.stdin.isTTY) {
-      harnesses ??= s.harnessDirsPresent.length ? s.harnessDirsPresent : ["claude", "opencode"];
-      exposure ??= s.symlinksSupported ? "symlink" : "copy";
-    } else {
-      const p = await import("@clack/prompts");
-      if (!harnesses) {
-        const selectedHarnesses = await p.multiselect({
-          message: "Expose skills/commands to which harnesses?",
-          options: [
-            { value: "claude", label: "Claude Code (.claude/)" },
-            { value: "opencode", label: "OpenCode (.opencode/)" }
-          ],
-          initialValues: s.harnessDirsPresent.length ? s.harnessDirsPresent : ["claude", "opencode"]
-        });
-        if (p.isCancel(selectedHarnesses)) {
-          cancelInit(p);
+    if ("reconciliations" in f && f.reconciliations) {
+      for (const r of f.reconciliations) {
+        if (await exists(join(repoDir, r.backup))) {
+          warnings.push({ code: "pending-reconciliation", path: r.backup, message: "review during /setup-repo, then delete" });
         }
-        harnesses = validateHarnesses(selectedHarnesses);
       }
-      if (!exposure && s.symlinksSupported) {
-        const selectedExposure = await p.select({
-          message: "Exposure mode?",
-          options: [
-            { value: "symlink", label: "Symlinks (recommended)" },
-            { value: "copy", label: "Copies (verify checks drift)" }
-          ]
-        });
-        if (p.isCancel(selectedExposure)) {
-          cancelInit(p);
-        }
-        exposure = selectedExposure;
-      } else {
-        exposure ??= "copy";
-      }
-    }
-  }
-  await preflightAdapterCollisions(repoDir, harnesses, exposure);
-  const gen = await generate(repoDir, version);
-  const exposed = [];
-  for (const h of harnesses) exposed.push(...await expose(repoDir, h, exposure));
-  const manifest = {
-    version: 1,
-    bearingsVersion: version,
-    harnesses,
-    exposure,
-    files: gen.files
-  };
-  await saveManifest(repoDir, manifest);
-  return { manifest, report: renderInitReport(gen, exposed, manifest) };
-}
-
-// src/verifier.ts
-import { access as access3, lstat as lstat3, readFile as readFile4, readdir as readdir3, readlink as readlink2, stat } from "fs/promises";
-import { dirname as dirname3, join as join7, resolve } from "path";
-var KINDS3 = ["skills", "commands"];
-async function exists3(p) {
-  try {
-    await access3(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function verify(repoDir) {
-  const failures = [];
-  const warnings = [];
-  const m = await loadManifest(repoDir);
-  if (!m) return { failures: [{ code: "no-manifest", path: ".agents/bearings.json", message: "run bearings init first" }], warnings };
-  for (const f of m.files) {
-    const abs = join7(repoDir, f.path);
-    if (!await exists3(abs)) {
-      failures.push({ code: "missing-file", path: f.path, message: "managed file deleted" });
-      continue;
-    }
-    const content = await readFile4(abs, "utf8");
-    if (content.includes("<agent:")) {
-      warnings.push({ code: "unfilled-placeholder", path: f.path, message: "run /setup-repo to fill" });
-    }
-    if (f.backup && await exists3(join7(repoDir, f.backup))) {
-      warnings.push({ code: "unreviewed-backup", path: f.backup, message: "review during /setup-repo, then delete" });
     }
   }
-  for (const kind of KINDS3) {
-    const srcDir = join7(repoDir, ".agents", kind);
+  for (const kind of KINDS) {
+    const srcDir = join(repoDir, ".agents", kind);
     let entries = [];
     try {
-      entries = await readdir3(srcDir);
+      entries = await readdir(srcDir);
     } catch {
     }
     for (const h of m.harnesses) {
       for (const name of entries) {
-        const exposurePath = join7(`.${h}`, kind, name);
-        const dst = join7(repoDir, `.${h}`, kind, name);
-        const l = await lstat3(dst).catch(() => null);
+        const exposurePath = join(`.${h}`, kind, name);
+        const dst = join(repoDir, `.${h}`, kind, name);
+        const l = await lstat(dst).catch(() => null);
         if (!l) {
           failures.push({ code: "missing-exposure", path: exposurePath, message: `not exposed to ${h}` });
           continue;
@@ -406,15 +83,15 @@ async function verify(repoDir) {
           if (!await stat(dst).catch(() => null)) {
             failures.push({ code: "broken-symlink", path: exposurePath, message: "symlink target missing" });
           } else {
-            const target = await readlink2(dst);
-            if (resolve(dirname3(dst), target) !== resolve(srcDir, name)) {
+            const target = await readlink(dst);
+            if (resolve(dirname(dst), target) !== resolve(srcDir, name)) {
               failures.push({ code: "missing-exposure", path: exposurePath, message: `not exposed to ${h}` });
             }
           }
         } else if (m.exposure === "symlink") {
           failures.push({ code: "missing-exposure", path: exposurePath, message: `not exposed to ${h}` });
         } else {
-          const src = join7(srcDir, name);
+          const src = join(srcDir, name);
           if (await copyDrifted(src, dst)) {
             failures.push({ code: "copy-drift", path: exposurePath, message: "diverged from .agents source" });
           }
@@ -428,8 +105,8 @@ async function copyDrifted(src, dst) {
   const s = await stat(src);
   if (s.isDirectory()) {
     const [srcChildren, dstChildren] = await Promise.all([
-      readdir3(src),
-      readdir3(dst).catch(() => null)
+      readdir(src),
+      readdir(dst).catch(() => null)
     ]);
     if (dstChildren === null) return true;
     const srcNames = new Set(srcChildren);
@@ -437,13 +114,13 @@ async function copyDrifted(src, dst) {
       if (!srcNames.has(child)) return true;
     }
     for (const child of srcChildren) {
-      if (await copyDrifted(join7(src, child), join7(dst, child))) return true;
+      if (await copyDrifted(join(src, child), join(dst, child))) return true;
     }
     return false;
   }
   const [a, b] = await Promise.all([
-    readFile4(src, "utf8"),
-    readFile4(dst, "utf8").catch(() => null)
+    readFile(src, "utf8"),
+    readFile(dst, "utf8").catch(() => null)
   ]);
   return b === null || sha256(a) !== sha256(b);
 }
@@ -457,7 +134,7 @@ async function runVerify(repoDir) {
 
 // src/cli.ts
 var pkg = JSON.parse(
-  readFileSync(join8(dirname4(fileURLToPath2(import.meta.url)), "../package.json"), "utf8")
+  readFileSync(join2(dirname2(fileURLToPath(import.meta.url)), "../package.json"), "utf8")
 );
 var program = new Command("bearings").version(pkg.version);
 program.command("init").description("Scaffold the agent-friendly setup in the current repository").option("--harness <name...>", "claude and/or opencode").option("--copy", "copy instead of symlink").option("-y, --yes", "accept defaults, no prompts").action(async (o) => {