@cmnwlth/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1081 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import path6 from "path";
+import { parseArgs } from "util";
+
+// src/commands.ts
+import { spawn } from "child_process";
+import { createRequire } from "module";
+import path2 from "path";
+import { FEATURE_FLAGS, loadBrainConfig, resolveBrainDir, setFeature } from "@cmnwlth/core";
+import { gatherCandidates } from "@cmnwlth/seed";
+
+// src/discover.ts
+import { promises as fs } from "fs";
+import path from "path";
+async function findGitRepos(baseDir, opts = {}) {
+  const maxDepth = opts.maxDepth ?? 2;
+  const root = path.resolve(baseDir);
+  const found = /* @__PURE__ */ new Set();
+  const visit = async (dir, depth) => {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (entries.some((e) => e.name === ".git")) {
+      found.add(dir);
+    }
+    if (depth >= maxDepth) return;
+    for (const entry of entries) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+      if (entry.name === "node_modules") continue;
+      if (entry.name.startsWith(".")) continue;
+      const child = path.join(dir, entry.name);
+      try {
+        const stat = await fs.stat(child);
+        if (!stat.isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      await visit(child, depth + 1);
+    }
+  };
+  await visit(root, 0);
+  return [...found].sort();
+}
+
+// src/commands.ts
+var require2 = createRequire(import.meta.url);
+function resolvePkgBin(pkg) {
+  const pkgJsonPath = require2.resolve(`${pkg}/package.json`);
+  const pkgJson = require2(`${pkg}/package.json`);
+  const rel = typeof pkgJson.bin === "string" ? pkgJson.bin : Object.values(pkgJson.bin ?? {})[0];
+  if (!rel) throw new Error(`${pkg} exposes no bin`);
+  return path2.join(path2.dirname(pkgJsonPath), rel);
+}
+function runBin(bin, args, input) {
+  return new Promise((resolve) => {
+    const child = spawn("node", [bin, ...args], {
+      stdio: [input === void 0 ? "inherit" : "pipe", "inherit", "inherit"]
+    });
+    child.on("error", () => resolve(1));
+    child.on("close", (code) => resolve(code ?? 0));
+    if (input !== void 0 && child.stdin) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.write(input, () => child.stdin.end());
+    }
+  });
+}
+async function brainOrError() {
+  const env = process.env.COMMONWEALTH_BRAIN_DIR;
+  const brain = env && env.length > 0 ? path2.resolve(env) : await resolveBrainDir(process.cwd());
+  if (!brain) {
+    process.stderr.write(
+      `No Commonwealth brain is configured for ${process.cwd()}. Run \`commonwealth init\` here, or add a prefix \u2192 brain mapping to ~/.commonwealth/registry.json.
+`
+    );
+    return null;
+  }
+  return brain;
+}
+async function cmdConfig(rest) {
+  const brain = await brainOrError();
+  if (!brain) return 1;
+  const [sub, key, value] = rest;
+  const config = await loadBrainConfig(brain);
+  const flagNames = FEATURE_FLAGS.map((f) => f.name);
+  if (sub === void 0 || sub === "list") {
+    process.stdout.write(
+      `brain: ${brain}
+name: ${config.name}
+remotes: ${config.remotes.join(", ") || "(none)"}
+features:
+`
+    );
+    for (const flag of FEATURE_FLAGS) {
+      const val = config.features[flag.name] ?? flag.default;
+      process.stdout.write(`  ${flag.name} = ${val}  \u2014 ${flag.description}
+`);
+    }
+    return 0;
+  }
+  if (sub === "get") {
+    if (!key) {
+      process.stderr.write("usage: commonwealth config get <key>\n");
+      return 2;
+    }
+    if (key === "name") process.stdout.write(`${config.name}
+`);
+    else if (flagNames.includes(key)) process.stdout.write(`${config.features[key] ?? false}
+`);
+    else {
+      process.stderr.write(`Unknown config key "${key}". Known: name, ${flagNames.join(", ")}
+`);
+      return 2;
+    }
+    return 0;
+  }
+  if (sub === "set") {
+    if (!key || value === void 0) {
+      process.stderr.write("usage: commonwealth config set <key> <value>\n");
+      return 2;
+    }
+    if (!flagNames.includes(key)) {
+      process.stderr.write(`Unknown feature flag "${key}". Known: ${flagNames.join(", ")}
+`);
+      return 2;
+    }
+    const on = value === "true" || value === "1" || value === "on" || value === "yes";
+    await setFeature(brain, key, on);
+    process.stderr.write(`[commonwealth] set ${key} = ${on} for ${brain}
+`);
+    return 0;
+  }
+  process.stderr.write("usage: commonwealth config <list | get <key> | set <key> <value>>\n");
+  return 2;
+}
+async function cmdReseed(rest) {
+  const brain = await brainOrError();
+  if (!brain) return 1;
+  const all = rest.includes("--all");
+  const explicit = rest.filter((a) => !a.startsWith("-")).map((a) => path2.resolve(a));
+  const repos = explicit.length > 0 ? explicit : all ? await findGitRepos(process.cwd()) : [path2.resolve(process.cwd())];
+  if (repos.length === 0) {
+    process.stderr.write("No repositories to reseed.\n");
+    return 0;
+  }
+  const curateBin = resolvePkgBin("@cmnwlth/curate");
+  let total = 0;
+  for (const repo of repos) {
+    const { candidates } = await gatherCandidates(repo);
+    if (candidates.length === 0) {
+      process.stderr.write(`[commonwealth] ${repo}: no candidates.
+`);
+      continue;
+    }
+    process.stderr.write(`[commonwealth] ${repo}: mined ${candidates.length} candidate(s)\u2026
+`);
+    const code = await runBin(
+      curateBin,
+      ["capture", "--dir", brain, "--cwd", repo, "--force"],
+      JSON.stringify(candidates)
+    );
+    if (code === 0) total += candidates.length;
+  }
+  process.stderr.write(
+    `[commonwealth] reseed done: ${total} candidate(s) captured into ${brain}.
+`
+  );
+  return 0;
+}
+function delegateCurate(args) {
+  return runBin(resolvePkgBin("@cmnwlth/curate"), args);
+}
+function delegateSync(args) {
+  return runBin(resolvePkgBin("@cmnwlth/sync"), args);
+}
+
+// src/deps.ts
+import { spawn as spawn2, spawnSync } from "child_process";
+import { existsSync as existsSync2, promises as fs2 } from "fs";
+import { createInterface } from "readline";
+import { createRequire as createRequire2 } from "module";
+import os2 from "os";
+import path4 from "path";
+import { fileURLToPath } from "url";
+import * as core from "@cmnwlth/core";
+import { gatherCandidates as gatherCandidates2 } from "@cmnwlth/seed";
+
+// src/init.ts
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import os from "os";
+import path3 from "path";
+function findRepoRoot(startDir) {
+  let dir = path3.resolve(startDir);
+  for (; ; ) {
+    if (existsSync(path3.join(dir, ".git"))) return dir;
+    const parent = path3.dirname(dir);
+    if (parent === dir) return path3.resolve(startDir);
+    dir = parent;
+  }
+}
+function defaultBrainDir(repoRoot) {
+  const resolved = path3.resolve(repoRoot);
+  const hash = createHash("sha256").update(resolved).digest("hex").slice(0, 8);
+  return path3.join(os.homedir(), ".commonwealth", "brains", `${path3.basename(resolved)}-${hash}`);
+}
+async function runInit(cwd, opts, deps) {
+  const projectDir = path3.resolve(cwd);
+  const repoRoot = findRepoRoot(cwd);
+  const existing = await deps.resolveBrain(cwd);
+  if (existing !== null && !opts.reseed && !opts.brain) {
+    await deps.registerBrain(projectDir, existing);
+    deps.log(`Joined existing brain at ${existing}. Run the sync daemon to pull.`);
+    return { mode: "join", brainDir: existing, staged: 0, gathered: 0 };
+  }
+  const brainDir = opts.brain ?? existing ?? defaultBrainDir(projectDir);
+  await deps.createBrain(brainDir, path3.basename(brainDir));
+  await deps.registerBrain(projectDir, brainDir);
+  if (opts.seed === false) {
+    deps.log(`Seeding skipped. Brain created at ${brainDir}.`);
+    return { mode: "skipped", brainDir, staged: 0, gathered: 0 };
+  }
+  const { candidates, bySource } = await deps.gather(repoRoot);
+  deps.log(
+    `Found ${candidates.length} candidates \u2014 adr:${bySource.adr} git:${bySource.git} config:${bySource.config}`
+  );
+  if (candidates.length > 0 && !opts.yes) {
+    const ok = await deps.confirm(
+      `Seed ${candidates.length} candidates into the brain's review queue?`
+    );
+    if (!ok) {
+      deps.log(`Skipped seeding. Brain created at ${brainDir}.`);
+      return { mode: "skipped", brainDir, staged: 0, gathered: candidates.length };
+    }
+  }
+  const { captured } = candidates.length ? await deps.stage(brainDir, candidates) : { captured: 0 };
+  deps.log(
+    `Your brain has ${captured} notes pending review. Run \`commonwealth-curate list\` to approve, then start a Claude session here and ask it something your team already knows.`
+  );
+  return { mode: "new", brainDir, staged: captured, gathered: candidates.length };
+}
+
+// src/deps.ts
+function resolveCurateEntry(override) {
+  if (override) return override;
+  const fromEnv = process.env.COMMONWEALTH_CURATE_BIN;
+  if (fromEnv) return fromEnv;
+  const require3 = createRequire2(import.meta.url);
+  const pkgJsonPath = require3.resolve("@cmnwlth/curate/package.json");
+  const pkg = require3("@cmnwlth/curate/package.json");
+  const rel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["commonwealth-curate"];
+  if (!rel) throw new Error("@cmnwlth/curate exposes no `commonwealth-curate` bin");
+  return path4.resolve(path4.dirname(pkgJsonPath), rel);
+}
+function makeStage(curateEntry, log) {
+  return (brainDir, candidates) => new Promise((resolve) => {
+    const child = spawn2("node", [curateEntry, "capture", "--dir", brainDir, "--force"], {
+      stdio: ["pipe", "pipe", "inherit"]
+    });
+    let out = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      out += chunk;
+    });
+    child.on("error", (err) => {
+      log(`Staging failed to spawn commonwealth-curate: ${err.message}`);
+      resolve({ captured: 0 });
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        log(`commonwealth-curate exited with code ${code ?? "null"}; staged nothing.`);
+        resolve({ captured: 0 });
+        return;
+      }
+      const captured = out.split("\n").filter((line) => line.trim().length > 0).length;
+      resolve({ captured });
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(JSON.stringify(candidates));
+  });
+}
+function promptConfirm(message) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+function defaultInitDeps(opts = {}) {
+  const log = (m) => {
+    process.stderr.write(m + "\n");
+  };
+  let curateEntry = null;
+  let curateError = null;
+  try {
+    curateEntry = resolveCurateEntry(opts.curateEntry);
+  } catch (err) {
+    curateError = err.message;
+  }
+  const stage = curateEntry ? makeStage(curateEntry, log) : async () => {
+    log(`Cannot stage: ${curateError ?? "commonwealth-curate not found"}.`);
+    return { captured: 0 };
+  };
+  return {
+    gather: (repoDir) => gatherCandidates2(repoDir),
+    resolveBrain: (cwd) => core.resolveBrainDir(cwd),
+    createBrain: (dir, name) => core.initBrain(dir, { name }),
+    registerBrain: async (repoDir, brainDir) => {
+      await core.addRegistryMapping(repoDir, brainDir);
+      await core.linkBrain(path4.basename(brainDir), brainDir);
+    },
+    stage,
+    confirm: opts.assumeYes ? async () => true : promptConfirm,
+    log
+  };
+}
+var REQUIRED_DIST_PACKAGES = ["core", "mcp", "sync", "curate", "seed", "cli"];
+function hasExecutable(name) {
+  const probe = process.platform === "win32" ? "where" : "which";
+  const res = spawnSync(probe, [name], { stdio: "ignore" });
+  return res.status === 0;
+}
+function hasClaudeEntry(args, name) {
+  const json = spawnSync("claude", [...args, "--json"], { encoding: "utf8" });
+  if (json.status === 0 && json.stdout) {
+    try {
+      const parsed = JSON.parse(json.stdout);
+      const rows = Array.isArray(parsed) ? parsed : Array.isArray(parsed.plugins) ? parsed.plugins : [];
+      return rows.some((row) => {
+        if (typeof row !== "object" || row === null) return false;
+        const r = row;
+        return r.id === name || r.name === name || r.plugin === name || typeof r.id === "string" && r.id.split("@")[0] === name;
+      });
+    } catch {
+    }
+  }
+  const text = spawnSync("claude", args, { encoding: "utf8" });
+  const out = `${text.stdout ?? ""}${text.stderr ?? ""}`;
+  return text.status === 0 && new RegExp(`(^|\\s)${name}(\\s|@|$)`, "m").test(out);
+}
+function commonwealthRoot() {
+  let dir = path4.dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    if (existsSync2(path4.join(dir, "pnpm-workspace.yaml"))) return dir;
+    const parent = path4.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function defaultOnboardDeps(opts = {}) {
+  const log = (m) => {
+    process.stderr.write(m + "\n");
+  };
+  const repoRoot = opts.repoRoot ?? commonwealthRoot() ?? findRepoRoot(process.cwd());
+  const isWorkspace = existsSync2(path4.join(repoRoot, "pnpm-workspace.yaml"));
+  const distEntry = (pkg) => path4.join(repoRoot, "packages", pkg, "dist", "index.js");
+  const ensureBuilt = async () => {
+    if (!isWorkspace) {
+      return { built: false, skipped: "not a workspace checkout; assuming an installed build" };
+    }
+    const missing = REQUIRED_DIST_PACKAGES.filter((pkg) => !existsSync2(distEntry(pkg)));
+    if (missing.length === 0) return { built: false };
+    if (!hasExecutable("pnpm")) {
+      return {
+        built: false,
+        skipped: `pnpm not found; cannot build (missing: ${missing.join(", ")})`
+      };
+    }
+    const build = spawnSync("pnpm", ["-r", "build"], { cwd: repoRoot, stdio: "inherit" });
+    if (build.status !== 0) {
+      const reason = build.error ? build.error.message : build.signal ? `signal ${build.signal}` : `exit code ${build.status}`;
+      return { built: false, skipped: `pnpm -r build failed (${reason})` };
+    }
+    const bundle = path4.join(repoRoot, "packages", "plugin", "scripts", "bundle.mjs");
+    if (existsSync2(bundle)) {
+      const res = spawnSync("node", [bundle], { cwd: repoRoot, stdio: "inherit" });
+      if (res.status !== 0)
+        log(`Plugin bundle exited with code ${res.status ?? "null"} (ignored).`);
+    }
+    return { built: true };
+  };
+  const init = (cwd, initOpts) => runInit(
+    cwd,
+    initOpts,
+    defaultInitDeps({ assumeYes: initOpts.yes, curateEntry: opts.curateEntry })
+  );
+  const configureScope = async (repoRoot2) => {
+    let curateEntry;
+    try {
+      curateEntry = resolveCurateEntry(opts.curateEntry);
+    } catch (err) {
+      return { added: false, skipped: `commonwealth-curate not found: ${err.message}` };
+    }
+    const res = spawnSync("node", [curateEntry, "scope", "allow", repoRoot2], { stdio: "ignore" });
+    if (res.error || res.status !== 0) {
+      const reason = res.error ? res.error.message : `exit code ${res.status ?? "null"}`;
+      return { added: false, skipped: `scope allow failed (${reason})` };
+    }
+    return { added: true };
+  };
+  const setAutoAdr = async (brainDir, on) => {
+    let curateEntry;
+    try {
+      curateEntry = resolveCurateEntry(opts.curateEntry);
+    } catch (err) {
+      return { set: false, skipped: `commonwealth-curate not found: ${err.message}` };
+    }
+    const verb = on ? "enable" : "disable";
+    const res = spawnSync("node", [curateEntry, "feature", verb, "autoAdr", "--dir", brainDir], {
+      stdio: "ignore"
+    });
+    if (res.error || res.status !== 0) {
+      const reason = res.error ? res.error.message : `exit code ${res.status ?? "null"}`;
+      return { set: false, skipped: `feature ${verb} autoAdr failed (${reason})` };
+    }
+    return { set: true };
+  };
+  const setRemote = async (brainDir, url) => {
+    const existing = spawnSync("git", ["-C", brainDir, "remote", "get-url", "origin"], {
+      stdio: "ignore"
+    });
+    if (existing.status === 0) return { set: false, skipped: "origin exists" };
+    const add = spawnSync("git", ["-C", brainDir, "remote", "add", "origin", url], {
+      stdio: "ignore"
+    });
+    if (add.error || add.status !== 0) {
+      const reason = add.error ? add.error.message : `exit code ${add.status ?? "null"}`;
+      return { set: false, skipped: `git remote add failed (${reason})` };
+    }
+    return { set: true };
+  };
+  const installPlugin = async () => {
+    if (!hasExecutable("claude")) {
+      return { installed: false, skipped: "claude CLI not found" };
+    }
+    const bundle = path4.join(repoRoot, "packages", "plugin", "scripts", "bundle.mjs");
+    if (existsSync2(bundle)) {
+      const res = spawnSync("node", [bundle], { cwd: repoRoot, stdio: "inherit" });
+      if (res.status !== 0)
+        log(`Plugin bundle exited with code ${res.status ?? "null"} (ignored).`);
+    }
+    if (!hasClaudeEntry(["plugin", "marketplace", "list"], "commonwealth")) {
+      const add = spawnSync("claude", ["plugin", "marketplace", "add", repoRoot], {
+        stdio: "inherit"
+      });
+      if (add.error || add.status !== 0) {
+        return {
+          installed: false,
+          skipped: `claude plugin marketplace add failed (code ${add.status ?? "null"})`
+        };
+      }
+    }
+    if (!hasClaudeEntry(["plugin", "list"], "commonwealth")) {
+      const install = spawnSync("claude", ["plugin", "install", "commonwealth@cmnwlth"], {
+        stdio: "inherit"
+      });
+      if (install.error || install.status !== 0) {
+        return {
+          installed: false,
+          skipped: `claude plugin install failed (code ${install.status ?? "null"})`
+        };
+      }
+    }
+    const staleGet = spawnSync("claude", ["mcp", "get", "commonwealth"], { stdio: "ignore" });
+    if (staleGet.status === 0) {
+      spawnSync("claude", ["mcp", "remove", "commonwealth", "-s", "local"], { stdio: "ignore" });
+    }
+    return { installed: true };
+  };
+  const startDaemon = async (brainDir) => {
+    const syncEntry = distEntry("sync");
+    if (!existsSync2(syncEntry)) {
+      return { started: false, skipped: "sync daemon not built" };
+    }
+    const status = spawnSync("node", [syncEntry, "status", "--dir", brainDir], {
+      encoding: "utf8"
+    });
+    const output = `${status.stdout ?? ""}${status.stderr ?? ""}`;
+    if (/\brunning on\b/.test(output) && !/\bnot running on\b/.test(output)) {
+      return { started: false, alreadyRunning: true };
+    }
+    try {
+      const child = spawn2("node", [syncEntry, "start", "--dir", brainDir], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+      return { started: true };
+    } catch (err) {
+      return { started: false, skipped: `failed to start daemon: ${err.message}` };
+    }
+  };
+  const registerBrain = async (folder, brainDir) => {
+    try {
+      const map = await core.addRegistryMapping(folder, brainDir);
+      const link = await core.linkBrain(path4.basename(brainDir), brainDir);
+      return { mapped: map.added || map.updated, linked: link.linked, skipped: link.skipped };
+    } catch (err) {
+      return { mapped: false, linked: false, skipped: err.message };
+    }
+  };
+  const seedFrom = async (brainDir, repoDir) => {
+    let curateEntry;
+    try {
+      curateEntry = resolveCurateEntry(opts.curateEntry);
+    } catch (err) {
+      return { staged: 0, skipped: `commonwealth-curate not found: ${err.message}` };
+    }
+    const seedEntry = distEntry("seed");
+    if (!existsSync2(seedEntry)) return { staged: 0, skipped: "seed CLI not built" };
+    return new Promise((resolve) => {
+      const gather = spawn2("node", [seedEntry, "gather", "--repo", repoDir], {
+        stdio: ["ignore", "pipe", "inherit"]
+      });
+      const capture = spawn2("node", [curateEntry, "capture", "--dir", brainDir, "--force"], {
+        stdio: ["pipe", "pipe", "inherit"]
+      });
+      let settled = false;
+      const done = (result) => {
+        if (settled) return;
+        settled = true;
+        resolve(result);
+      };
+      gather.on(
+        "error",
+        (err) => done({ staged: 0, skipped: `seed spawn failed (${err.message})` })
+      );
+      capture.on(
+        "error",
+        (err) => done({ staged: 0, skipped: `capture spawn failed (${err.message})` })
+      );
+      gather.stdout.pipe(capture.stdin);
+      let out = "";
+      capture.stdout.setEncoding("utf8");
+      capture.stdout.on("data", (chunk) => {
+        out += chunk;
+      });
+      capture.on("close", (code) => {
+        if (code !== 0) {
+          done({ staged: 0, skipped: `capture exited with code ${code ?? "null"}` });
+          return;
+        }
+        const staged = out.split("\n").filter((line) => line.trim().length > 0).length;
+        done({ staged });
+      });
+    });
+  };
+  const ensureUserConfig = async () => {
+    const configPath = process.env.COMMONWEALTH_CONFIG ?? path4.join(os2.homedir(), ".commonwealth", "config.json");
+    if (!existsSync2(configPath)) {
+      try {
+        await fs2.mkdir(path4.dirname(configPath), { recursive: true });
+        await fs2.writeFile(
+          configPath,
+          `${JSON.stringify({ allow: [], deny: [] }, null, 2)}
+`,
+          "utf8"
+        );
+      } catch (err) {
+        log(`Could not create scope config at ${configPath}: ${err.message}`);
+      }
+    }
+    return { path: configPath };
+  };
+  return {
+    ensureBuilt,
+    init,
+    configureScope,
+    registerBrain,
+    seedFrom,
+    ensureUserConfig,
+    setAutoAdr,
+    setRemote,
+    installPlugin,
+    startDaemon,
+    confirm: promptConfirm,
+    log
+  };
+}
+
+// src/onboard.ts
+import path5 from "path";
+async function runOnboard(cwd, opts, deps) {
+  const doBuild = opts.build !== false;
+  const doSeed = opts.seed !== false;
+  const doScope = opts.scope !== false;
+  const doAutoAdr = opts.autoAdr === true;
+  const doRemote = typeof opts.remote === "string" && opts.remote.trim().length > 0;
+  const doPlugin = opts.plugin !== false && opts.mcp !== false;
+  const doDaemon = opts.daemon !== false;
+  const syncFolders = opts.syncFolders ?? [path5.resolve(cwd)];
+  const seedRepos = opts.seedRepos ?? (doSeed ? syncFolders : []);
+  const brainLabel = opts.brain ?? "the project's default brain dir";
+  const plan = [
+    doBuild ? "build the workspace if needed" : null,
+    `create brain at ${brainLabel}`,
+    doScope ? `sync ${syncFolders.length} folder(s) into the brain` : null,
+    seedRepos.length > 0 ? `seed from ${seedRepos.length} repo(s)` : null,
+    doAutoAdr ? "enable auto-ADR" : null,
+    doRemote ? `set brain remote to ${opts.remote}` : null,
+    doPlugin ? "install the Commonwealth plugin (global MCP + session hooks)" : null,
+    doDaemon ? "start the sync daemon" : null,
+    "ensure the per-user scope config exists"
+  ].filter((step) => step !== null);
+  deps.log(`Will: ${plan.join(", ")}.`);
+  if (!opts.yes) {
+    const ok = await deps.confirm("Proceed with the plan above?");
+    if (!ok) {
+      deps.log("Aborted. Nothing was changed.");
+      return {
+        brainDir: opts.brain ?? "",
+        mode: "skipped",
+        built: false,
+        staged: 0,
+        scopedFolders: 0,
+        mappedFolders: 0,
+        seededRepos: 0,
+        scopeConfigPath: "",
+        scope: "skipped",
+        autoAdr: "skipped",
+        remote: "skipped",
+        plugin: "skipped",
+        daemon: "skipped"
+      };
+    }
+  }
+  let built = false;
+  if (doBuild) {
+    const res = await deps.ensureBuilt();
+    built = res.built;
+    if (res.skipped) deps.log(`Build: ${res.skipped}`);
+    else deps.log(built ? "Build: built workspace." : "Build: dist up to date.");
+  }
+  const initResult = await deps.init(cwd, {
+    brain: opts.brain,
+    yes: opts.yes,
+    reseed: opts.reseed,
+    seed: false
+  });
+  const brainDir = initResult.brainDir;
+  let scopedFolders = 0;
+  let mappedFolders = 0;
+  let scope = "skipped";
+  if (doScope) {
+    for (const folder of syncFolders) {
+      const scopeRes = await deps.configureScope(folder);
+      if (scopeRes.skipped) {
+        deps.log(`WARNING: scope step skipped for ${folder}: ${scopeRes.skipped}`);
+      } else if (scopeRes.added) {
+        scopedFolders += 1;
+        deps.log(`Scope: added ${folder}`);
+      } else {
+        deps.log(`Scope: ${folder} already allowed`);
+      }
+      const regRes = await deps.registerBrain(folder, brainDir);
+      if (regRes.mapped) mappedFolders += 1;
+      deps.log(`registered ${folder} -> ${brainDir} (symlink brains/${path5.basename(brainDir)})`);
+      if (regRes.skipped) {
+        deps.log(`WARNING: brain symlink skipped for ${folder}: ${regRes.skipped}`);
+      }
+    }
+    scope = scopedFolders > 0 ? `added ${scopedFolders}` : "none added";
+  }
+  let staged = 0;
+  let seededRepos = 0;
+  if (seedRepos.length > 0) {
+    for (const repo of seedRepos) {
+      const seedRes = await deps.seedFrom(brainDir, repo);
+      if (seedRes.skipped) {
+        deps.log(`WARNING: seed step skipped for ${repo}: ${seedRes.skipped}`);
+      } else {
+        staged += seedRes.staged;
+        seededRepos += 1;
+        deps.log(`Seed: staged ${seedRes.staged} from ${repo}`);
+      }
+    }
+  }
+  let autoAdr = "skipped";
+  if (doAutoAdr) {
+    const res = await deps.setAutoAdr(brainDir, true);
+    autoAdr = res.skipped ?? (res.set ? "enabled" : "not enabled");
+    deps.log(`Auto-ADR: ${autoAdr}`);
+  }
+  let remote = "skipped";
+  if (doRemote) {
+    const res = await deps.setRemote(brainDir, opts.remote);
+    remote = res.skipped ?? (res.set ? "set" : "not set");
+    deps.log(`Remote: ${remote}`);
+  }
+  let plugin = "skipped";
+  if (doPlugin) {
+    const res = await deps.installPlugin();
+    if (res.skipped) {
+      deps.log(`WARNING: plugin step skipped: ${res.skipped}`);
+      plugin = res.skipped;
+    } else {
+      plugin = res.installed ? "installed" : "not installed";
+      deps.log(`Plugin: ${plugin}`);
+    }
+  }
+  let daemon = "skipped";
+  if (doDaemon) {
+    const res = await deps.startDaemon(brainDir);
+    if (res.skipped) {
+      deps.log(`WARNING: daemon step skipped: ${res.skipped}`);
+      daemon = res.skipped;
+    } else if (res.alreadyRunning) {
+      daemon = "already running";
+      deps.log(`Daemon: ${daemon}`);
+    } else {
+      daemon = res.started ? "started" : "not started";
+      deps.log(`Daemon: ${daemon}`);
+    }
+  }
+  const { path: scopeConfigPath } = await deps.ensureUserConfig();
+  deps.log(
+    `Done. mode=${initResult.mode} brain=${brainDir} staged=${staged} scopedFolders=${scopedFolders} mappedFolders=${mappedFolders} seededRepos=${seededRepos} scope=${scope} autoAdr=${autoAdr} remote=${remote} plugin=${plugin} daemon=${daemon}. Scope config: ${scopeConfigPath}. Open a Claude session here and ask it something your team knows.`
+  );
+  return {
+    brainDir,
+    mode: initResult.mode,
+    built,
+    staged,
+    scopedFolders,
+    mappedFolders,
+    seededRepos,
+    scopeConfigPath,
+    scope,
+    autoAdr,
+    remote,
+    plugin,
+    daemon
+  };
+}
+function defaultWizardDeps() {
+  return { scan: (baseDir) => findGitRepos(baseDir) };
+}
+async function runWizard(defaults, prompter, deps = defaultWizardDeps()) {
+  const brain = await prompter.text("Brain directory", defaults.brain);
+  const scanDefault = path5.dirname(defaults.projectDir);
+  const scanDir = await prompter.text("Scan which directory for projects?", scanDefault);
+  const repos = await deps.scan(scanDir);
+  let syncFolders;
+  let seedRepos;
+  if (repos.length > 0) {
+    const items = repos.map((r) => ({ label: r, value: r }));
+    const allTrue = repos.map(() => true);
+    syncFolders = await prompter.select("Folders to SYNC into this brain", items, allTrue);
+    const seedDefault = repos.map((r) => syncFolders.includes(r));
+    seedRepos = await prompter.select("Repos to SEED from now", items, seedDefault);
+  } else {
+    syncFolders = [defaults.projectDir];
+    seedRepos = [defaults.projectDir];
+  }
+  const plugin = await prompter.confirm(
+    "Install the Commonwealth plugin (global MCP + session hooks)?",
+    defaults.plugin
+  );
+  const daemon = await prompter.confirm("Start the sync daemon?", defaults.daemon);
+  const autoAdr = await prompter.confirm("Enable auto-ADR?", defaults.autoAdr);
+  const remote = await prompter.text("Brain git remote (blank to skip)", "");
+  const opts = {
+    brain: brain.trim() === "" ? void 0 : brain,
+    yes: true,
+    seed: seedRepos.length > 0,
+    plugin,
+    daemon,
+    scope: true,
+    autoAdr,
+    remote: remote.trim() === "" ? void 0 : remote,
+    syncFolders,
+    seedRepos
+  };
+  const ok = await prompter.confirm("Proceed?", true);
+  if (!ok) return { proceed: false, opts: null };
+  return { proceed: true, opts };
+}
+
+// src/prompt.ts
+import { createInterface as createInterface2 } from "readline/promises";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function parseConfirm(input, def) {
+  const v = input.trim().toLowerCase();
+  if (v === "") return def;
+  if (v === "y" || v === "yes") return true;
+  if (v === "n" || v === "no") return false;
+  return def;
+}
+function parseText(input, def) {
+  const v = input.trim();
+  return v === "" ? def : v;
+}
+function parseSelection(input, values, defaultSelected) {
+  const v = input.trim().toLowerCase();
+  if (v === "") return values.filter((_, i) => defaultSelected[i]);
+  if (v === "all") return [...values];
+  if (v === "none") return [];
+  const picked = /* @__PURE__ */ new Set();
+  for (const token of v.split(/[\s,]+/).filter((t) => t.length > 0)) {
+    const n = Number.parseInt(token, 10);
+    if (!Number.isInteger(n)) continue;
+    const idx = n - 1;
+    if (idx >= 0 && idx < values.length) picked.add(idx);
+  }
+  return values.filter((_, i) => picked.has(i));
+}
+function confirmHint(def) {
+  return def ? "[Y/n]" : "[y/N]";
+}
+function createReadlinePrompter() {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  let closed = false;
+  return {
+    async text(message, def) {
+      const answer = await rl.question(`${message} [${def}]: `);
+      return parseText(answer, def);
+    },
+    async confirm(message, def) {
+      const answer = await rl.question(`${message} ${confirmHint(def)}: `);
+      return parseConfirm(answer, def);
+    },
+    async select(message, items, defaultSelected) {
+      const lines = items.map(
+        (item, i) => `  ${i + 1}. [${defaultSelected[i] ? "x" : " "}] ${item.label}`
+      );
+      const prompt = `${message}
+${lines.join("\n")}
+Select (all/none/1,3 \u2014 Enter keeps defaults): `;
+      const answer = await rl.question(prompt);
+      return parseSelection(
+        answer,
+        items.map((item) => item.value),
+        defaultSelected
+      );
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      rl.close();
+    }
+  };
+}
+
+// src/index.ts
+function printUsage() {
+  process.stderr.write(
+    [
+      "commonwealth \u2014 git-backed markdown team-brain",
+      "",
+      "Usage:",
+      "  commonwealth init      [flags]                 onboard: build, create/join brain, plugin, daemon",
+      "  commonwealth reseed    [<repo>...] [--all]     mine repo(s) into the mapped brain and capture",
+      "  commonwealth config    <list | get <k> | set <k> <v>>   read/set the brain's shared config",
+      "  commonwealth status                            review queue + sync-daemon state",
+      "  commonwealth health                            freshness/trust rollup for the brain",
+      "  commonwealth consolidate  [--dry-run]          supersede near-duplicate canon notes",
+      "  commonwealth sync      <start | stop | once>   control/run the sync daemon",
+      "  commonwealth pending                           list notes awaiting review",
+      "  commonwealth promote   <id...> | --all         approve staged notes into canon",
+      "  commonwealth reject    <id...>                 discard staged notes",
+      "  commonwealth scope     <show | allow <p> | deny <p> | check>   per-user capture scope",
+      "  commonwealth recall    <query>                 search the brain",
+      "",
+      "All commands resolve the brain from the registry for the current directory \u2014 no --dir needed.",
+      "",
+      "init flags: [--brain <dir>] [--yes] [--reseed] [--auto-adr] [--remote <url>]",
+      "            [--sync <dir,dir,...>] [--seed-repo <dir,dir,...>]",
+      "            [--no-scope] [--no-seed] [--no-plugin] [--no-daemon] [--no-build]",
+      "",
+      "`init` is a single idempotent command: it builds the workspace (if needed), creates or",
+      "joins the brain, syncs one or more folders into it (allowlist + a global-registry mapping",
+      "with a ~/.commonwealth/brains/<name> symlink), seeds it from one or more repos, installs",
+      "the Commonwealth plugin (global MCP + session hooks), and starts the sync daemon. Run in a",
+      "terminal without --yes for an interactive wizard that scans for and lets you multi-select",
+      "folders/repos; with --yes (or non-interactively) it uses defaults + flags and never prompts.",
+      "",
+      "Options:",
+      "  --brain <dir>          Create/use the brain at <dir> (default: ~/.commonwealth/brains/<project>)",
+      "  --yes                  Run non-interactively; skip the wizard and all prompts",
+      "  --reseed               Re-seed even if this project already resolves to a brain",
+      "  --auto-adr             Enable auto-ADR capture for the brain",
+      "  --remote <url>         Add <url> as the brain's git origin remote",
+      "  --sync <dir,dir,...>   Folders to sync into the brain (default: this repo)",
+      "  --seed-repo <dir,...>  Repos to seed from now (default: the --sync folders)",
+      "  --no-scope             Skip adding folders to the capture allowlist",
+      "  --no-seed       Create the brain but skip gathering/staging seed candidates",
+      "  --no-plugin     Skip installing the Commonwealth plugin (alias: --no-mcp)",
+      "  --no-daemon     Skip starting the sync daemon",
+      "  --no-build      Skip the workspace build even if dist artifacts are missing",
+      ""
+    ].join("\n")
+  );
+}
+async function run(argv) {
+  const [command, ...rest] = argv;
+  if (command === void 0 || command === "--help" || command === "-h") {
+    printUsage();
+    return command === void 0 ? 2 : 0;
+  }
+  switch (command) {
+    case "init":
+      return cmdInit(rest);
+    case "reseed":
+      return cmdReseed(rest);
+    case "config":
+      return cmdConfig(rest);
+    case "status": {
+      const queue = await delegateCurate(["list"]);
+      const daemon = await delegateSync(["status"]);
+      return queue || daemon;
+    }
+    case "sync": {
+      const sub = rest[0] === "once" ? "sync" : rest[0] ?? "status";
+      return delegateSync([sub, ...rest.slice(1)]);
+    }
+    case "health":
+      return delegateCurate(["health"]);
+    case "consolidate":
+      return delegateCurate(["consolidate", ...rest]);
+    case "pending":
+      return delegateCurate(["list"]);
+    case "promote":
+      return delegateCurate(rest.includes("--all") ? ["approve-all"] : ["approve", ...rest]);
+    case "reject":
+      return delegateCurate(["reject", ...rest]);
+    case "scope":
+      return delegateCurate(["scope", ...rest]);
+    case "recall":
+      return delegateCurate(["context", "--cwd", process.cwd(), "--query", rest.join(" ")]);
+    default:
+      process.stderr.write(`Unknown command: ${command}
+`);
+      printUsage();
+      return 2;
+  }
+}
+async function cmdInit(rest) {
+  if (rest.includes("--help") || rest.includes("-h")) {
+    printUsage();
+    return 0;
+  }
+  const negations = [
+    "--no-scope",
+    "--no-seed",
+    "--no-plugin",
+    "--no-mcp",
+    "--no-daemon",
+    "--no-build"
+  ];
+  const scope = !rest.includes("--no-scope");
+  const seed = !rest.includes("--no-seed");
+  const plugin = !rest.includes("--no-plugin") && !rest.includes("--no-mcp");
+  const daemon = !rest.includes("--no-daemon");
+  const build = !rest.includes("--no-build");
+  const positional = rest.filter((a) => !negations.includes(a));
+  let values;
+  try {
+    ({ values } = parseArgs({
+      args: positional,
+      options: {
+        brain: { type: "string" },
+        yes: { type: "boolean", default: false },
+        reseed: { type: "boolean", default: false },
+        "auto-adr": { type: "boolean", default: false },
+        remote: { type: "string" },
+        sync: { type: "string" },
+        "seed-repo": { type: "string" }
+      },
+      allowPositionals: false
+    }));
+  } catch (err) {
+    process.stderr.write(`${err.message}
+`);
+    printUsage();
+    return 2;
+  }
+  const cwd = process.cwd();
+  const projectDir = path6.resolve(cwd);
+  const interactive = isInteractive();
+  if (!interactive && !values.yes) {
+    process.stderr.write("Non-interactive: re-run in a terminal or pass --yes.\n");
+    return 0;
+  }
+  const claudePresent = hasExecutable2("claude");
+  const deps = defaultOnboardDeps({ curateEntry: process.env.COMMONWEALTH_CURATE_BIN });
+  const splitDirs = (raw) => {
+    if (raw === void 0) return void 0;
+    const dirs = raw.split(",").map((d) => d.trim()).filter((d) => d.length > 0);
+    return dirs.length > 0 ? dirs : void 0;
+  };
+  let opts;
+  let prompter = null;
+  try {
+    if (interactive && !values.yes) {
+      const defaults = {
+        brain: defaultBrainDir(projectDir),
+        projectDir,
+        scope: true,
+        seed: true,
+        plugin: claudePresent,
+        daemon: true,
+        autoAdr: false
+      };
+      prompter = createReadlinePrompter();
+      const outcome = await runWizard(defaults, prompter);
+      if (!outcome.proceed) {
+        process.stderr.write("Aborted.\n");
+        return 0;
+      }
+      opts = outcome.opts;
+    } else {
+      const syncFolders = splitDirs(values.sync) ?? [projectDir];
+      const seedRepos = splitDirs(values["seed-repo"]) ?? (seed ? syncFolders : []);
+      opts = {
+        brain: values.brain,
+        yes: true,
+        reseed: values.reseed,
+        seed,
+        plugin,
+        daemon,
+        build,
+        scope,
+        autoAdr: values["auto-adr"],
+        remote: values.remote,
+        syncFolders,
+        seedRepos
+      };
+    }
+    const result = await runOnboard(cwd, opts, deps);
+    process.stderr.write(
+      `init: mode=${result.mode} brain=${result.brainDir} built=${result.built} staged=${result.staged} scopedFolders=${result.scopedFolders} mappedFolders=${result.mappedFolders} seededRepos=${result.seededRepos} scope=${result.scope} autoAdr=${result.autoAdr} remote=${result.remote} plugin=${result.plugin} daemon=${result.daemon} scopeConfig=${result.scopeConfigPath}
+`
+    );
+    return 0;
+  } finally {
+    prompter?.close();
+  }
+}
+function hasExecutable2(name) {
+  const probe = process.platform === "win32" ? "where" : "which";
+  const res = spawnSync2(probe, [name], { stdio: "ignore" });
+  return res.status === 0;
+}
+var isEntrypoint = process.argv[1] !== void 0 && import.meta.url === new URL(`file://${process.argv[1]}`).href;
+if (isEntrypoint) {
+  run(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+  }).catch((err) => {
+    process.stderr.write(`${err.stack ?? String(err)}
+`);
+    process.exitCode = 1;
+  });
+}
+export {
+  createReadlinePrompter,
+  defaultBrainDir,
+  defaultInitDeps,
+  defaultOnboardDeps,
+  findGitRepos,
+  findRepoRoot,
+  isInteractive,
+  parseConfirm,
+  parseSelection,
+  parseText,
+  run,
+  runInit,
+  runOnboard,
+  runWizard
+};
+//# sourceMappingURL=index.js.map