substrata-cli 0.1.0

package/dist/chunk-5LCVXNHI.js

@@ -0,0 +1,1279 @@
+import {
+  GITIGNORE_LINES,
+  NotFoundError,
+  SecretDetectedError,
+  appendMemoryEntries,
+  buildIndex,
+  configPath,
+  ensureGitignore,
+  existingEntryIds,
+  findFootprintById,
+  getIndexStatus,
+  initProject,
+  installSecretHook,
+  listFootprints,
+  listMemoryDocuments,
+  loadConfig,
+  memoryDir,
+  renderConfig,
+  scanForSecrets,
+  search,
+  substrataDir,
+  supersedeFootprint,
+  upsertAgentsMd,
+  writeFootprint,
+  writeShellEnv
+} from "./chunk-5V44C5UO.js";
+
+// src/index.ts
+import { Command } from "commander";
+import pc5 from "picocolors";
+
+// src/wizard/prompts.ts
+import {
+  confirm as clackConfirm,
+  isCancel,
+  multiselect as clackMultiselect,
+  text as clackText
+} from "@clack/prompts";
+var assumeYesFlag = false;
+function setAssumeYes(value) {
+  assumeYesFlag = value;
+}
+function isNonInteractive() {
+  return assumeYesFlag || !process.stdout.isTTY || !process.stdin.isTTY;
+}
+var PromptCancelledError = class extends Error {
+  constructor() {
+    super("Prompt cancelled");
+    this.name = "PromptCancelledError";
+  }
+};
+function guardCancel(value) {
+  if (isCancel(value)) throw new PromptCancelledError();
+  return value;
+}
+async function promptText(options) {
+  if (isNonInteractive()) return options.defaultValue;
+  const result = await clackText({
+    message: options.message,
+    placeholder: options.placeholder ?? options.defaultValue,
+    defaultValue: options.defaultValue,
+    initialValue: options.defaultValue
+  });
+  const value = guardCancel(result);
+  return value.length > 0 ? value : options.defaultValue;
+}
+async function promptConfirm(options) {
+  if (isNonInteractive()) return options.defaultValue;
+  const result = await clackConfirm({
+    message: options.message,
+    initialValue: options.defaultValue
+  });
+  return guardCancel(result);
+}
+async function promptMultiselect(options) {
+  if (isNonInteractive()) return options.defaultValues;
+  if (options.choices.length === 0) return [];
+  const choices = options.choices.map((c) => ({
+    value: c.value,
+    label: c.label,
+    ...c.hint !== void 0 ? { hint: c.hint } : {}
+  }));
+  const result = await clackMultiselect({
+    message: options.message,
+    options: choices,
+    initialValues: options.defaultValues,
+    required: false
+  });
+  return guardCancel(result);
+}
+
+// src/util.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import pc from "picocolors";
+var execFileAsync = promisify(execFile);
+var CliError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+};
+function resolveCwd(opts) {
+  return opts?.cwd ? opts.cwd : process.cwd();
+}
+var out = {
+  ok: (msg) => process.stdout.write(`${pc.green("\u2714")} ${msg}
+`),
+  info: (msg) => process.stdout.write(`${pc.blue("\u2139")} ${msg}
+`),
+  warn: (msg) => process.stderr.write(`${pc.yellow("!")} ${msg}
+`),
+  err: (msg) => process.stderr.write(`${pc.red("\u2716")} ${msg}
+`),
+  plain: (msg) => process.stdout.write(`${msg}
+`)
+};
+async function git(cwd, args) {
+  try {
+    const { stdout } = await execFileAsync("git", args, { cwd });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function isGitRepo(cwd) {
+  const result = await git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  return result === "true";
+}
+async function collectGitContext(cwd) {
+  const branch = await git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]) ?? void 0;
+  const commit = await git(cwd, ["rev-parse", "HEAD"]) ?? void 0;
+  const staged = await git(cwd, ["diff", "--cached", "--name-only"]);
+  const unstaged = await git(cwd, ["diff", "--name-only"]);
+  const files = /* @__PURE__ */ new Set();
+  for (const block of [staged, unstaged]) {
+    if (!block) continue;
+    for (const line of block.split(/\r?\n/)) {
+      const t = line.trim();
+      if (t.length > 0) files.add(t);
+    }
+  }
+  return {
+    branch: branch && branch !== "HEAD" ? branch : void 0,
+    files: Array.from(files),
+    commit
+  };
+}
+async function resolveAttribution(cwd, config, flags) {
+  const env = process.env;
+  const actor = flags.actor || env.SUBSTRATA_ACTOR || config.agent.default_actor || "unknown-agent";
+  const model = flags.model || env.SUBSTRATA_MODEL || config.agent.default_model || void 0;
+  let requester = flags.requester || env.SUBSTRATA_REQUESTER || void 0;
+  if (!requester) {
+    const email = await git(cwd, ["config", "user.email"]);
+    if (email) requester = email;
+  }
+  return { actor, model, requester };
+}
+async function requireConfig(cwd) {
+  try {
+    return await loadConfig(cwd);
+  } catch (err) {
+    throw new CliError(
+      `${err.message}
+Run \`substrata init\` to set up this repository.`
+    );
+  }
+}
+
+// src/commands/add.ts
+var SECURITY_REMINDER = "Reminder: Substrata files are intended to be committed.\nDo not include secrets, credentials, or sensitive user data.";
+function collect(value, previous = []) {
+  return [...previous, value];
+}
+function splitCsv(value) {
+  if (!value) return [];
+  return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function parseRejected(values) {
+  if (!values) return [];
+  return values.map((v) => {
+    const idx = v.indexOf(":");
+    if (idx === -1) return { option: v.trim(), reason: "" };
+    return { option: v.slice(0, idx).trim(), reason: v.slice(idx + 1).trim() };
+  });
+}
+var VALID_WORK_TYPES = /* @__PURE__ */ new Set([
+  "implementation",
+  "implementation_decision",
+  "bug_fix",
+  "refactor",
+  "investigation",
+  "architecture_decision",
+  "test_update",
+  "documentation"
+]);
+function registerAddCommand(program) {
+  program.command("add").description("Create a new footprint").option("--title <title>", "Footprint title").option("--purpose <text>", "Why this work was done").option("--actor <id>", "Agent that performed the work").option("--requester <id>", "Who requested the work").option("--model <id>", "Agent model identifier").option("--files <csv>", "Comma-separated files touched").option("--tag <tag>", "Tag (repeatable)", collect, []).option("--work-type <type>", "Footprint work type").option("--decision <text>", "Decision made (repeatable)", collect, []).option("--rejected <option:reason>", "Rejected option (repeatable)", collect, []).option("--notes <text>", "Implementation notes").option("--memory <text>", "Memory learned (repeatable)", collect, []).option("--guidance <text>", "Future agent guidance").option("--template <type>", "Work type template to seed the footprint").option("--supersedes <id>", "Mark this footprint as superseding an old one").option("--allow-secret", "Write even if a secret is detected (NOT recommended)").option("--from-git", "Populate branch/files/commit from Git").action(async (opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    const config = await requireConfig(cwd);
+    const attribution = await resolveAttribution(cwd, config, {
+      actor: opts.actor,
+      model: opts.model,
+      requester: opts.requester
+    });
+    let title = opts.title;
+    if (!title) {
+      if (isNonInteractive()) {
+        throw new CliError("`--title` is required in non-interactive mode.");
+      }
+      title = await promptText({ message: "Title", defaultValue: "" });
+      if (!title.trim()) throw new CliError("A title is required.");
+    }
+    const purpose = opts.purpose ?? (isNonInteractive() ? void 0 : await promptText({ message: "Purpose", defaultValue: "" }) || void 0);
+    const workTypeRaw = opts.workType ?? opts.template;
+    if (workTypeRaw && !VALID_WORK_TYPES.has(workTypeRaw)) {
+      throw new CliError(
+        `Invalid work type "${workTypeRaw}". Valid: ${Array.from(VALID_WORK_TYPES).join(", ")}.`
+      );
+    }
+    const workType = workTypeRaw;
+    let filesTouched = splitCsv(opts.files);
+    let repoBranch;
+    let commits;
+    if (opts.fromGit) {
+      const ctx = await collectGitContext(cwd);
+      repoBranch = ctx.branch;
+      if (ctx.files.length > 0) {
+        filesTouched = Array.from(/* @__PURE__ */ new Set([...filesTouched, ...ctx.files]));
+      }
+      if (ctx.commit) commits = [ctx.commit];
+    }
+    const supersedes = opts.supersedes ? [opts.supersedes] : void 0;
+    const input = {
+      cwd,
+      title,
+      purpose,
+      actor: attribution.actor,
+      requester: attribution.requester,
+      agentModel: attribution.model,
+      workType,
+      decisions: opts.decision && opts.decision.length > 0 ? opts.decision : void 0,
+      rejectedOptions: opts.rejected && opts.rejected.length > 0 ? parseRejected(opts.rejected) : void 0,
+      implementationNotes: opts.notes,
+      memoryLearned: opts.memory && opts.memory.length > 0 ? opts.memory : void 0,
+      futureAgentGuidance: opts.guidance,
+      filesTouched: filesTouched.length > 0 ? filesTouched : void 0,
+      tags: opts.tag && opts.tag.length > 0 ? opts.tag : void 0,
+      repo: repoBranch ? { branch: repoBranch } : void 0,
+      related: commits ? { commits } : void 0,
+      supersedes,
+      allowSecret: opts.allowSecret
+    };
+    let footprint;
+    try {
+      footprint = await writeFootprint(input);
+    } catch (err) {
+      if (err instanceof SecretDetectedError) {
+        const detail = err.findings.map((f) => `  - ${f.name} at body line ${f.line}`).join("\n");
+        throw new CliError(
+          `Refusing to write footprint: ${err.findings.length} potential secret(s) detected
+${detail}
+  Redact these or pass --allow-secret to override (NOT recommended \u2014 footprints are committed).`
+        );
+      }
+      throw err;
+    }
+    if (opts.supersedes) {
+      await supersedeFootprint(cwd, opts.supersedes, footprint.frontmatter.id);
+    }
+    out.ok(`Footprint written: ${footprint.frontmatter.id}`);
+    out.plain(`  ${footprint.filePath}`);
+    out.warn(SECURITY_REMINDER);
+  });
+}
+
+// src/render/context.ts
+var CHARS_PER_TOKEN = 3.5;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+var HEADER = "Relevant Substrata context:";
+var APPROX_NOTE = "(Token counts are approximate \u2014 estimated, not tokenizer-exact.)";
+function firstLine(text) {
+  if (!text) return void 0;
+  for (const line of text.split(/\r?\n/)) {
+    const t = line.trim();
+    if (t.length > 0) return t;
+  }
+  return void 0;
+}
+function footprintPoint(fp) {
+  const s = fp.sections;
+  if (s.decisions && s.decisions.length > 0) {
+    const rejected = s.rejectedOptions?.[0];
+    return {
+      statement: s.decisions[0],
+      reason: rejected ? `${rejected.option} was rejected \u2014 ${rejected.reason}` : void 0
+    };
+  }
+  if (s.rejectedOptions && s.rejectedOptions.length > 0) {
+    const r = s.rejectedOptions[0];
+    return { statement: `Avoid ${r.option} for ${fp.title}.`, reason: r.reason };
+  }
+  if (s.futureAgentGuidance) {
+    return { statement: firstLine(s.futureAgentGuidance) ?? fp.title };
+  }
+  if (s.purpose) {
+    return { statement: fp.title, reason: firstLine(s.purpose) };
+  }
+  return { statement: fp.title };
+}
+function memoryPoint(doc) {
+  for (const line of doc.body.split(/\r?\n/)) {
+    const t = line.trim();
+    if (t.startsWith("- ")) return { statement: t.slice(2).trim() };
+  }
+  return { statement: doc.title };
+}
+function blockFor(result, footprintsById, memoryById, index) {
+  const fp = footprintsById.get(result.id);
+  const mem = memoryById.get(result.id);
+  let statement;
+  let reason;
+  if (fp) {
+    ({ statement, reason } = footprintPoint(fp));
+  } else if (mem) {
+    ({ statement } = memoryPoint(mem));
+  } else {
+    statement = result.title || result.id;
+  }
+  const lines = [`${index}. ${statement}`];
+  if (reason) lines.push(`   Reason: ${reason}`);
+  lines.push(`   Source: ${result.filePath}`);
+  return {
+    source: { id: result.id, title: result.title, filePath: result.filePath },
+    block: lines.join("\n")
+  };
+}
+function renderContext(results, footprints, memory, maxTokens) {
+  const footprintsById = new Map(footprints.map((f) => [f.frontmatter.id, f]));
+  const memoryById = new Map(memory.map((m) => [m.frontmatter.id, m]));
+  const header = `${HEADER}
+
+`;
+  const footer = `
+
+${APPROX_NOTE}`;
+  let used = estimateTokens(header) + estimateTokens(footer);
+  const chosen = [];
+  const blocks = [];
+  let n = 1;
+  for (const result of results) {
+    const { source, block } = blockFor(result, footprintsById, memoryById, n);
+    const blockTokens = estimateTokens(`${block}
+
+`);
+    if (used + blockTokens > maxTokens && blocks.length > 0) break;
+    blocks.push(block);
+    chosen.push(source);
+    used += blockTokens;
+    n += 1;
+  }
+  if (blocks.length === 0) {
+    return { text: `${HEADER}
+
+No relevant context found.`, sources: [] };
+  }
+  return { text: `${header}${blocks.join("\n\n")}${footer}`, sources: chosen };
+}
+
+// src/commands/auto-index.ts
+async function ensureFreshIndex(cwd, autoIndex) {
+  const status = await getIndexStatus(cwd);
+  if (status.state === "fresh") return;
+  if (!autoIndex) {
+    out.info(
+      status.state === "missing" ? "Index missing \u2014 run `substrata index` (auto-index disabled)." : `Index stale (${status.reason}) \u2014 run \`substrata index\` (auto-index disabled).`
+    );
+    return;
+  }
+  await buildIndex(cwd);
+}
+
+// src/commands/context.ts
+function collect2(value, previous = []) {
+  return [...previous, value];
+}
+function registerContextCommand(program) {
+  program.command("context <task>").description("Return concise, source-linked context for an agent").option("--json", "Output JSON ({ context, sources })").option("--max-tokens <n>", "Approximate token budget (chars/3.5)").option("--files <path>", "Bias toward docs touching this file (repeatable)", collect2, []).option("--no-auto-index", "Do not auto-(re)build a stale/missing index").action(async (task, opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    const config = await requireConfig(cwd);
+    await ensureFreshIndex(cwd, opts.autoIndex !== false);
+    const maxTokens = opts.maxTokens ? Number(opts.maxTokens) : config.search.max_context_tokens;
+    const budget = Number.isFinite(maxTokens) ? maxTokens : config.search.max_context_tokens;
+    const results = await search(task, {
+      cwd,
+      limit: config.search.default_limit,
+      files: opts.files && opts.files.length > 0 ? opts.files : void 0,
+      excludeSuperseded: true
+    });
+    const [footprints, memory] = await Promise.all([
+      listFootprints(cwd),
+      listMemoryDocuments(cwd)
+    ]);
+    const rendered = renderContext(results, footprints, memory, budget);
+    if (opts.json) {
+      out.plain(JSON.stringify({ context: rendered.text, sources: rendered.sources }, null, 2));
+      return;
+    }
+    out.plain(rendered.text);
+  });
+}
+
+// src/commands/doctor.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+async function runDoctor(cwd) {
+  let failures = 0;
+  if (existsSync(substrataDir(cwd))) {
+    out.ok(".substrata exists");
+  } else {
+    out.err(".substrata missing \u2014 run `substrata init`");
+    return 1;
+  }
+  try {
+    await loadConfig(cwd);
+    out.ok("config valid");
+  } catch (err) {
+    out.err(`config invalid: ${err.message}`);
+    failures += 1;
+  }
+  const status = await getIndexStatus(cwd);
+  if (status.state === "fresh") {
+    out.ok("index fresh");
+  } else if (status.state === "missing") {
+    out.info("index missing \u2014 run `substrata index` (or it builds automatically on first search)");
+  } else {
+    out.info(`index stale (${status.reason}) \u2014 run \`substrata index\``);
+  }
+  const gitignorePath = path.join(cwd, ".gitignore");
+  const gitignore = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf8") : "";
+  const ignoredLines = new Set(gitignore.split(/\r?\n/).map((l) => l.trim()));
+  const indexCovered = ignoredLines.has(".substrata/index/") || ignoredLines.has(".substrata/");
+  if (indexCovered) {
+    out.ok("gitignore covers index/ and cache/");
+  } else {
+    out.err(`gitignore would commit the generated DB \u2014 add: ${GITIGNORE_LINES.join(", ")}`);
+    failures += 1;
+  }
+  try {
+    const footprints = await listFootprints(cwd);
+    out.ok(`${footprints.length} footprint file(s) parsed`);
+  } catch (err) {
+    out.err(`footprint parse error: ${err.message}`);
+    failures += 1;
+  }
+  try {
+    const memory = await listMemoryDocuments(cwd);
+    out.ok(`${memory.length} memory file(s) parsed`);
+  } catch (err) {
+    out.err(`memory parse error: ${err.message}`);
+    failures += 1;
+  }
+  return failures;
+}
+function registerDoctorCommand(program) {
+  program.command("doctor").description("Check repository setup").action(async (_opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    const failures = await runDoctor(cwd);
+    if (failures > 0) {
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/hook.ts
+import { readFile } from "fs/promises";
+import path2 from "path";
+async function scanStaged(cwd) {
+  const staged = await git(cwd, ["diff", "--cached", "--name-only"]);
+  if (!staged) return 0;
+  const files = staged.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.startsWith(".substrata/") && l.endsWith(".md"));
+  let flagged = 0;
+  for (const rel of files) {
+    let content;
+    try {
+      content = await readFile(path2.join(cwd, rel), "utf8");
+    } catch {
+      continue;
+    }
+    const findings = scanForSecrets(content);
+    if (findings.length > 0) {
+      flagged += 1;
+      out.err(`${findings.length} potential secret(s) in ${rel}:`);
+      for (const f of findings) out.plain(`  - ${f.name} at line ${f.line}`);
+    }
+  }
+  return flagged;
+}
+function registerHookCommand(program) {
+  const hook = program.command("hook").description("Pre-commit secret hook utilities");
+  hook.command("install").description("Install the pre-commit secret scan hook").action(async (_opts, command) => {
+    const cwd = resolveCwd(command.parent?.parent?.opts());
+    const result = installSecretHook(cwd);
+    if (result.action === "skip") {
+      out.info("Pre-commit hook already installed.");
+    } else {
+      out.ok(`Pre-commit hook ${result.action === "create" ? "installed" : "updated"}.`);
+    }
+  });
+  hook.command("run").description("Scan staged .substrata files for secrets").action(async (_opts, command) => {
+    const cwd = resolveCwd(command.parent?.parent?.opts());
+    const flagged = await scanStaged(cwd);
+    if (flagged > 0) process.exitCode = 1;
+  });
+  program.command("internal-scan-staged", { hidden: true }).action(async (_opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    const flagged = await scanStaged(cwd);
+    if (flagged > 0) process.exitCode = 1;
+  });
+}
+
+// src/commands/index.ts
+function registerIndexCommand(program) {
+  program.command("index").description("Build or rebuild the local search index").option("--rebuild", "Force a full rebuild of the index").action(async (_opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    await requireConfig(cwd);
+    await buildIndex(cwd, { rebuild: true });
+    out.ok("Index built.");
+  });
+}
+
+// src/commands/init.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+
+// src/wizard/init-wizard.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import path7 from "path";
+import pc2 from "picocolors";
+
+// src/mcp-clients/claude-code.ts
+import { execFile as execFile2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import path4 from "path";
+import { promisify as promisify2 } from "util";
+
+// src/mcp-clients/json-config.ts
+import { lstatSync, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import path3 from "path";
+function isSymlink(filePath) {
+  try {
+    return lstatSync(filePath).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function readJson(filePath) {
+  try {
+    const raw = readFileSync2(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return null;
+  }
+}
+function entryMatches(existing, spec) {
+  const entry = existing?.mcpServers?.[spec.name];
+  if (!entry) return false;
+  return entry.command === spec.command && JSON.stringify(entry.args ?? []) === JSON.stringify(spec.args);
+}
+function mergeMcpJson(filePath, spec, dry = false) {
+  if (isSymlink(filePath)) {
+    return {
+      path: filePath,
+      action: "skip",
+      description: `refused: ${path3.basename(filePath)} is a symlink`
+    };
+  }
+  const existing = readJson(filePath);
+  if (entryMatches(existing, spec)) {
+    return { path: filePath, action: "skip", description: "MCP entry already current" };
+  }
+  const base = existing ?? {};
+  const servers = { ...base.mcpServers ?? {} };
+  delete servers[spec.name];
+  servers[spec.name] = { command: spec.command, args: spec.args };
+  const next = { ...base, mcpServers: servers };
+  const contents = `${JSON.stringify(next, null, 2)}
+`;
+  if (!dry) {
+    mkdirSync(path3.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, contents, "utf8");
+  }
+  return {
+    path: filePath,
+    action: existing === null ? "create" : "update",
+    description: `register Substrata MCP server (${spec.name})`,
+    contents
+  };
+}
+function removeMcpJson(filePath, name) {
+  const existing = readJson(filePath);
+  if (!existing?.mcpServers?.[name]) return;
+  const servers = { ...existing.mcpServers };
+  delete servers[name];
+  const next = { ...existing, mcpServers: servers };
+  writeFileSync(filePath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+}
+
+// src/mcp-clients/claude-code.ts
+var execFileAsync2 = promisify2(execFile2);
+function mcpJsonPath(cwd) {
+  return path4.join(cwd, ".mcp.json");
+}
+async function hasClaudeBinary() {
+  try {
+    await execFileAsync2("which", ["claude"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var claudeCodeClient = {
+  name: "claude",
+  label: "Claude Code",
+  async detect(cwd) {
+    if (existsSync2(mcpJsonPath(cwd))) return true;
+    return hasClaudeBinary();
+  },
+  async register(cwd, spec, dry = false) {
+    return mergeMcpJson(mcpJsonPath(cwd), spec, dry);
+  },
+  async unregister(cwd, name) {
+    removeMcpJson(mcpJsonPath(cwd), name);
+  }
+};
+
+// src/mcp-clients/cursor.ts
+import { existsSync as existsSync3 } from "fs";
+import path5 from "path";
+function cursorMcpPath(cwd) {
+  return path5.join(cwd, ".cursor", "mcp.json");
+}
+var cursorClient = {
+  name: "cursor",
+  label: "Cursor",
+  async detect(cwd) {
+    return existsSync3(path5.join(cwd, ".cursor")) || existsSync3(cursorMcpPath(cwd));
+  },
+  async register(cwd, spec, dry = false) {
+    return mergeMcpJson(cursorMcpPath(cwd), spec, dry);
+  },
+  async unregister(cwd, name) {
+    removeMcpJson(cursorMcpPath(cwd), name);
+  }
+};
+
+// src/mcp-clients/windsurf.ts
+import { existsSync as existsSync4 } from "fs";
+import { homedir } from "os";
+import path6 from "path";
+function windsurfConfigPath() {
+  return path6.join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+}
+function snippet(spec) {
+  const block = {
+    mcpServers: {
+      [spec.name]: { command: spec.command, args: spec.args }
+    }
+  };
+  return `${windsurfConfigPath()}
+${JSON.stringify(block, null, 2)}`;
+}
+var windsurfClient = {
+  name: "windsurf",
+  label: "Windsurf",
+  async detect() {
+    return existsSync4(path6.join(homedir(), ".codeium", "windsurf"));
+  },
+  async register(_cwd, spec) {
+    return {
+      path: windsurfConfigPath(),
+      action: "skip",
+      description: `add manually (global config):
+${snippet(spec)}`
+    };
+  },
+  async unregister() {
+  }
+};
+
+// src/mcp-clients/registry.ts
+var SUBSTRATA_MCP_SPEC = {
+  name: "substrata",
+  command: "npx",
+  args: ["-y", "substrata-cli", "mcp"]
+};
+var MCP_CLIENTS = [claudeCodeClient, cursorClient, windsurfClient];
+function getMcpClient(name) {
+  return MCP_CLIENTS.find((c) => c.name === name);
+}
+async function detectMcpClients(cwd) {
+  const detected = [];
+  for (const client of MCP_CLIENTS) {
+    if (await client.detect(cwd)) detected.push(client);
+  }
+  return detected;
+}
+
+// src/wizard/init-wizard.ts
+function detectShellRc() {
+  const shell = process.env.SHELL ?? "";
+  const home = homedir2();
+  if (shell.includes("bash")) return path7.join(home, ".bashrc");
+  return path7.join(home, ".zshrc");
+}
+function defaultProjectName(cwd) {
+  const pkgPath = path7.join(cwd, "package.json");
+  if (existsSync5(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+      if (pkg.name && typeof pkg.name === "string") {
+        return pkg.name.replace(/^@[^/]+\//, "");
+      }
+    } catch {
+    }
+  }
+  return path7.basename(path7.resolve(cwd));
+}
+async function preflight(cwd, flags) {
+  if (!await isGitRepo(cwd)) {
+    const doInit = await promptConfirm({
+      message: "This is not a Git repository. Run `git init`?",
+      defaultValue: true
+    });
+    if (doInit) {
+      const result = await git(cwd, ["init"]);
+      if (result !== null) out.ok("Initialized a Git repository.");
+      else out.warn("Could not run `git init`; continuing without Git.");
+    }
+  }
+  void flags;
+}
+async function resolveMcpClients(cwd, flags) {
+  if (flags.mcp === false) return [];
+  if (flags.mcpClient && flags.mcpClient.length > 0) {
+    const chosen = [];
+    for (const name of flags.mcpClient) {
+      const client = getMcpClient(name);
+      if (client) chosen.push(client);
+      else out.warn(`Unknown MCP client "${name}" \u2014 skipping.`);
+    }
+    return chosen;
+  }
+  const detected = await detectMcpClients(cwd);
+  if (detected.length === 0) return [];
+  return promptMultiselect({
+    message: "Register the Substrata MCP server with which clients?",
+    choices: detected.map((c) => ({ value: c, label: c.label })),
+    defaultValues: detected
+  });
+}
+async function collectAnswers(cwd, flags) {
+  const projectName = flags.project ?? await promptText({
+    message: "Project name",
+    defaultValue: defaultProjectName(cwd)
+  });
+  const actor = await promptText({
+    message: "Default actor (agent id)",
+    defaultValue: flags.actor ?? "unknown-agent"
+  });
+  const model = flags.model ?? await promptText({ message: "Default agent model (optional)", defaultValue: "" });
+  const gitEmail = await git(cwd, ["config", "user.email"]) ?? "";
+  const requester = flags.requester ?? await promptText({ message: "Default requester (optional)", defaultValue: gitEmail });
+  const attribution = {
+    actor: actor || void 0,
+    model: model || void 0,
+    requester: requester || void 0
+  };
+  const writeEnv = flags.env === false ? false : await promptConfirm({
+    message: "Persist attribution env vars to your shell rc?",
+    defaultValue: true
+  });
+  const redact = flags.redact === false ? false : await promptConfirm({
+    message: "Enable security redaction + content scan?",
+    defaultValue: true
+  });
+  const withHook = flags.withHook === true ? true : await promptConfirm({
+    message: "Install the pre-commit secret hook?",
+    defaultValue: false
+  });
+  const writeAgentsMd = flags.agentsMd === false ? false : await promptConfirm({
+    message: "Add the Substrata section to AGENTS.md?",
+    defaultValue: true
+  });
+  const writeGitignore = flags.gitignore !== false;
+  const mcpClients = await resolveMcpClients(cwd, flags);
+  return {
+    projectName,
+    attribution,
+    writeEnv,
+    rcPath: detectShellRc(),
+    redact,
+    withHook,
+    writeAgentsMd,
+    writeGitignore,
+    mcpClients
+  };
+}
+async function buildPlan(cwd, answers) {
+  const changes = [];
+  changes.push({
+    path: path7.join(cwd, ".substrata"),
+    action: existsSync5(path7.join(cwd, ".substrata", "config.yml")) ? "skip" : "create",
+    description: "Substrata scaffold (config, README, footprints, memory, templates)"
+  });
+  if (answers.writeGitignore) {
+    changes.push(ensureGitignore(cwd, true));
+  }
+  if (answers.writeEnv && (answers.attribution.actor || answers.attribution.model || answers.attribution.requester)) {
+    changes.push(writeShellEnv(answers.rcPath, answers.attribution, true));
+  }
+  if (answers.writeAgentsMd) {
+    changes.push(upsertAgentsMd(cwd, true));
+  }
+  if (answers.withHook) {
+    changes.push(installSecretHook(cwd, true));
+  }
+  for (const client of answers.mcpClients) {
+    changes.push(await client.register(cwd, SUBSTRATA_MCP_SPEC, true));
+  }
+  return changes;
+}
+async function applyPlan(cwd, answers) {
+  const applied = [];
+  applied.push(...await initProject(cwd, { projectName: answers.projectName }));
+  if (answers.writeGitignore) {
+    applied.push(ensureGitignore(cwd, false));
+  }
+  if (answers.writeEnv && (answers.attribution.actor || answers.attribution.model || answers.attribution.requester)) {
+    applied.push(writeShellEnv(answers.rcPath, answers.attribution, false));
+  } else if (!answers.writeEnv) {
+    printEnvSnippet(answers.attribution);
+  }
+  if (answers.writeAgentsMd) {
+    applied.push(upsertAgentsMd(cwd, false));
+  }
+  if (answers.withHook) {
+    applied.push(installSecretHook(cwd, false));
+  }
+  for (const client of answers.mcpClients) {
+    const result = await client.register(cwd, SUBSTRATA_MCP_SPEC, false);
+    applied.push(result);
+    if (result.action === "skip" && result.description.includes("\n")) {
+      out.info(`${client.label}: ${result.description}`);
+    }
+  }
+  return applied;
+}
+function printEnvSnippet(attribution) {
+  const lines = [];
+  if (attribution.actor) lines.push(`export SUBSTRATA_ACTOR="${attribution.actor}"`);
+  if (attribution.model) lines.push(`export SUBSTRATA_MODEL="${attribution.model}"`);
+  if (attribution.requester) lines.push(`export SUBSTRATA_REQUESTER="${attribution.requester}"`);
+  if (lines.length === 0) return;
+  out.info("Add these to your shell rc to attribute footprints:");
+  out.plain(lines.map((l) => `  ${l}`).join("\n"));
+}
+function printResolvedConfig(cwd, flags) {
+  const name = flags.project ?? defaultProjectName(cwd);
+  out.plain(renderConfig(name));
+}
+async function runInitWizard(cwd, flags) {
+  const updateMode = existsSync5(path7.join(cwd, ".substrata", "config.yml"));
+  if (updateMode) {
+    out.info("Existing .substrata detected \u2014 running in update mode.");
+  }
+  await preflight(cwd, flags);
+  const answers = await collectAnswers(cwd, flags);
+  const plan = await buildPlan(cwd, answers);
+  out.plain(pc2.bold("\nPlanned changes:"));
+  out.plain(
+    plan.map((c) => {
+      const label = c.action === "create" ? pc2.green("CREATE") : c.action === "update" ? pc2.yellow("UPDATE") : pc2.dim("SKIP  ");
+      return `  ${label}  ${c.path}${c.description ? pc2.dim(` \u2014 ${c.description.split("\n")[0]}`) : ""}`;
+    }).join("\n")
+  );
+  out.plain("");
+  const confirmed = await promptConfirm({ message: "Apply these changes?", defaultValue: true });
+  if (!confirmed) {
+    out.info("Aborted. Nothing was written.");
+    return { applied: [], aborted: true };
+  }
+  const applied = await applyPlan(cwd, answers);
+  out.ok("Substrata setup applied.");
+  if (answers.writeEnv) {
+    out.info(`Run \`source ${answers.rcPath}\` to load attribution env vars.`);
+  }
+  return { applied, aborted: false };
+}
+
+// src/commands/init.ts
+async function disableRedaction(cwd) {
+  const file = configPath(cwd);
+  let raw;
+  try {
+    raw = await readFile2(file, "utf8");
+  } catch {
+    return;
+  }
+  const next = raw.replace(/^(\s*)redact:\s*true\s*$/m, "$1redact: false").replace(/^(\s*)scan_content:\s*true\s*$/m, "$1scan_content: false").replace(/^(\s*)block_on_secret:\s*true\s*$/m, "$1block_on_secret: false");
+  if (next !== raw) await writeFile(file, next, "utf8");
+}
+function registerInitCommand(program) {
+  program.command("init").description("Set up Substrata in this repository (interactive wizard)").option("--yes", "Accept all defaults, no prompts").option("--project <name>", "Project name").option("--actor <id>", "Default actor").option("--model <id>", "Default agent model").option("--requester <id>", "Default requester").option("--no-env", "Don't touch shell rc; print snippet instead").option("--no-agents-md", "Skip AGENTS.md").option("--no-mcp", "Skip MCP registration").option("--mcp-client <name>", "Register only this client (repeatable)", collect3, []).option("--no-gitignore", "Don't edit .gitignore").option("--no-redact", "Disable security redaction (NOT recommended)").option("--with-hook", "Install the pre-commit secret hook").option("--no-index", "Skip building the initial index").option("--print-config", "Print resolved config.yml without writing anything").action(async (opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    const flags = {
+      yes: opts.yes,
+      project: opts.project,
+      actor: opts.actor,
+      model: opts.model,
+      requester: opts.requester,
+      env: opts.env,
+      agentsMd: opts.agentsMd,
+      mcp: opts.mcp,
+      mcpClient: opts.mcpClient,
+      gitignore: opts.gitignore,
+      redact: opts.redact,
+      withHook: opts.withHook,
+      index: opts.index,
+      printConfig: opts.printConfig
+    };
+    if (flags.printConfig) {
+      printResolvedConfig(cwd, flags);
+      return;
+    }
+    if (flags.yes) setAssumeYes(true);
+    const result = await runInitWizard(cwd, flags);
+    if (result.aborted) return;
+    if (flags.redact === false) {
+      await disableRedaction(cwd);
+      out.warn("Security redaction disabled (--no-redact).");
+    }
+    out.plain("");
+    await runDoctor(cwd);
+    if (flags.index !== false) {
+      await buildIndex(cwd);
+      out.ok("Initial index built.");
+    }
+  });
+}
+function collect3(value, previous = []) {
+  return [...previous, value];
+}
+
+// src/render/table.ts
+import pc3 from "picocolors";
+function statusLabel(status) {
+  switch (status) {
+    case "superseded":
+      return pc3.yellow("[superseded]");
+    case "deprecated":
+      return pc3.red("[deprecated]");
+    case "draft":
+      return pc3.dim("[draft]");
+    default:
+      return "";
+  }
+}
+function renderSearchResults(results) {
+  if (results.length === 0) {
+    return pc3.dim("No matching footprints or memory found.");
+  }
+  const blocks = results.map((r, i) => {
+    const n = pc3.dim(`${i + 1}.`);
+    const status = statusLabel(r.status);
+    const header = `${n} ${pc3.bold(r.title || r.id)}${status ? ` ${status}` : ""}`;
+    const lines = [header, `   ${pc3.dim("id:")} ${r.id}`, `   ${pc3.dim("path:")} ${r.filePath}`];
+    if (r.tags.length > 0) lines.push(`   ${pc3.dim("tags:")} ${r.tags.join(", ")}`);
+    if (r.snippet.trim().length > 0) {
+      lines.push(`   ${pc3.dim(r.snippet.replace(/\s+/g, " ").trim())}`);
+    }
+    return lines.join("\n");
+  });
+  return blocks.join("\n\n");
+}
+function renderFootprintList(rows) {
+  if (rows.length === 0) {
+    return pc3.dim("No footprints found.");
+  }
+  return rows.map((r) => {
+    const date = r.createdAt ? r.createdAt.slice(0, 10) : "----------";
+    const status = statusLabel(r.status);
+    const tags = r.tags.length > 0 ? pc3.dim(` (${r.tags.join(", ")})`) : "";
+    return `${pc3.dim(date)}  ${pc3.bold(r.title || r.id)}${status ? ` ${status}` : ""}
+  ${pc3.dim(r.id)}${tags}`;
+  }).join("\n");
+}
+
+// src/commands/list.ts
+function matches(fp, opts) {
+  if (opts.tag && !(fp.frontmatter.tags ?? []).includes(opts.tag)) return false;
+  if (opts.file && !(fp.frontmatter.files_touched ?? []).includes(opts.file)) return false;
+  if (opts.since && fp.frontmatter.created_at < opts.since) return false;
+  return true;
+}
+function registerListCommand(program) {
+  program.command("list").description("List recent footprints").option("--tag <tag>", "Only footprints carrying this tag").option("--file <path>", "Only footprints touching this file").option("--since <date>", "Only footprints created on/after this ISO date").option("--json", "Output JSON").action(async (opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    await requireConfig(cwd);
+    const all = await listFootprints(cwd);
+    const filtered = all.filter((fp) => matches(fp, opts));
+    if (opts.json) {
+      const rows = filtered.map((fp) => ({
+        id: fp.frontmatter.id,
+        title: fp.title,
+        status: fp.frontmatter.status,
+        createdAt: fp.frontmatter.created_at,
+        tags: fp.frontmatter.tags ?? [],
+        filesTouched: fp.frontmatter.files_touched ?? [],
+        filePath: fp.filePath
+      }));
+      out.plain(JSON.stringify(rows, null, 2));
+      return;
+    }
+    out.plain(
+      renderFootprintList(
+        filtered.map((fp) => ({
+          id: fp.frontmatter.id,
+          title: fp.title,
+          status: fp.frontmatter.status,
+          createdAt: fp.frontmatter.created_at,
+          tags: fp.frontmatter.tags ?? []
+        }))
+      )
+    );
+  });
+}
+
+// src/commands/mcp.ts
+function registerMcpCommand(program) {
+  program.command("mcp").description("Run the Substrata MCP server (stdio)").action(async (_opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    let mod;
+    try {
+      mod = await import("./dist-OCRLBALV.js");
+    } catch (err) {
+      throw new CliError(`Failed to load @substrata/mcp-server: ${err.message}`);
+    }
+    if (typeof mod.runMcpServer !== "function") {
+      throw new CliError("@substrata/mcp-server does not export runMcpServer().");
+    }
+    await mod.runMcpServer({ cwd });
+  });
+}
+
+// src/commands/memory-update.ts
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import path8 from "path";
+var CONVENTIONS_FRONTMATTER = `---
+schema_version: 1
+id: mem_repo_conventions
+type: repo_conventions
+tags:
+  - conventions
+---
+
+# Repo conventions
+
+Curated, durable knowledge agents should read often.
+
+<!-- substrata:entries:start -->
+<!-- substrata:entries:end -->
+`;
+function registerMemoryUpdateCommand(program) {
+  const memory = program.command("memory").description("Curated memory utilities");
+  memory.command("update").description("Suggest and append memory entries from footprints").option("--since <date>", "Only footprints created on/after this ISO date").option("--yes", "Append without confirmation").action(async (opts, command) => {
+    const cwd = resolveCwd(command.parent?.parent?.opts());
+    await requireConfig(cwd);
+    const footprints = await listFootprints(cwd);
+    const filtered = opts.since ? footprints.filter((fp) => fp.frontmatter.created_at >= opts.since) : footprints;
+    const candidates = [];
+    for (const fp of filtered) {
+      const learned = fp.sections.memoryLearned ?? [];
+      if (learned.length === 0) continue;
+      candidates.push({
+        sourceId: fp.frontmatter.id,
+        lines: learned.map((l) => `- ${l}`)
+      });
+    }
+    if (candidates.length === 0) {
+      out.info("No `Memory learned` sections found in the selected footprints.");
+      return;
+    }
+    const filePath = path8.join(memoryDir(cwd), "conventions.md");
+    const alreadyPresent = existsSync6(filePath) ? existingEntryIds(await readFile3(filePath, "utf8")) : /* @__PURE__ */ new Set();
+    const fresh = candidates.filter((c) => !alreadyPresent.has(c.sourceId));
+    if (fresh.length === 0) {
+      out.info("All suggested entries are already present. Nothing to do.");
+      return;
+    }
+    out.plain("Suggested memory entries:");
+    for (const entry of fresh) {
+      out.plain(`  [${entry.sourceId}]`);
+      for (const line of entry.lines) out.plain(`    ${line}`);
+    }
+    const confirmed = opts.yes || isNonInteractive() ? true : await promptConfirm({
+      message: `Append ${fresh.length} entr${fresh.length === 1 ? "y" : "ies"} to conventions.md?`,
+      defaultValue: true
+    });
+    if (!confirmed) {
+      out.info("Aborted. Nothing written.");
+      return;
+    }
+    if (!existsSync6(filePath)) {
+      await writeFile2(filePath, CONVENTIONS_FRONTMATTER, "utf8");
+    }
+    const changed = await appendMemoryEntries(filePath, candidates);
+    if (changed) {
+      out.ok(`Appended ${fresh.length} memory entr${fresh.length === 1 ? "y" : "ies"}.`);
+    } else {
+      out.info("No new entries appended (already present).");
+    }
+  });
+}
+
+// src/commands/search.ts
+function collect4(value, previous = []) {
+  return [...previous, value];
+}
+function registerSearchCommand(program) {
+  program.command("search <query>").description("Search footprints and memory").option("--json", "Output JSON").option("--files <path>", "Filter to docs touching this file (repeatable)", collect4, []).option("--tag <tag>", "Filter to docs carrying this tag (repeatable)", collect4, []).option("--limit <n>", "Maximum number of results").option("--exclude-superseded", "Drop superseded/deprecated footprints").option("--no-auto-index", "Do not auto-(re)build a stale/missing index").action(async (query, opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    const config = await requireConfig(cwd);
+    await ensureFreshIndex(cwd, opts.autoIndex !== false);
+    const limit = opts.limit ? Number(opts.limit) : config.search.default_limit;
+    const results = await search(query, {
+      cwd,
+      limit: Number.isFinite(limit) ? limit : config.search.default_limit,
+      files: opts.files && opts.files.length > 0 ? opts.files : void 0,
+      tags: opts.tag && opts.tag.length > 0 ? opts.tag : void 0,
+      excludeSuperseded: opts.excludeSuperseded
+    });
+    if (opts.json) {
+      out.plain(JSON.stringify(results, null, 2));
+      return;
+    }
+    out.plain(renderSearchResults(results));
+  });
+}
+
+// src/commands/show.ts
+import pc4 from "picocolors";
+function registerShowCommand(program) {
+  program.command("show <id>").description("Show one footprint").option("--json", "Output the parsed footprint as JSON").option("--path", "Print only the footprint file path").action(async (id, opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    await requireConfig(cwd);
+    const fp = await findFootprintById(cwd, id);
+    if (!fp) throw new CliError(`Footprint not found: ${id}`);
+    if (opts.path) {
+      out.plain(fp.filePath);
+      return;
+    }
+    if (opts.json) {
+      out.plain(
+        JSON.stringify(
+          {
+            id: fp.frontmatter.id,
+            title: fp.title,
+            filePath: fp.filePath,
+            frontmatter: fp.frontmatter,
+            sections: fp.sections
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const fm = fp.frontmatter;
+    const lines = [
+      pc4.bold(fp.title || fm.id),
+      `${pc4.dim("id:")}        ${fm.id}`,
+      `${pc4.dim("status:")}    ${fm.status}`,
+      `${pc4.dim("work_type:")} ${fm.work_type}`,
+      `${pc4.dim("actor:")}     ${fm.actor}`
+    ];
+    if (fm.requester) lines.push(`${pc4.dim("requester:")} ${fm.requester}`);
+    if (fm.agent_model) lines.push(`${pc4.dim("model:")}     ${fm.agent_model}`);
+    lines.push(`${pc4.dim("created:")}   ${fm.created_at}`);
+    if (fm.tags && fm.tags.length > 0)
+      lines.push(`${pc4.dim("tags:")}      ${fm.tags.join(", ")}`);
+    if (fm.files_touched && fm.files_touched.length > 0) {
+      lines.push(`${pc4.dim("files:")}     ${fm.files_touched.join(", ")}`);
+    }
+    lines.push(`${pc4.dim("path:")}      ${fp.filePath}`);
+    lines.push("");
+    lines.push(fp.body.trim());
+    out.plain(lines.join("\n"));
+  });
+}
+
+// src/commands/supersede.ts
+function registerSupersedeCommand(program) {
+  program.command("supersede <old-id>").description("Mark an old footprint as superseded by a new one").requiredOption("--by <new-id>", "Id of the footprint that replaces the old one").action(async (oldId, opts, command) => {
+    const cwd = resolveCwd(command.parent?.opts());
+    await requireConfig(cwd);
+    try {
+      await supersedeFootprint(cwd, oldId, opts.by);
+    } catch (err) {
+      if (err instanceof NotFoundError) throw new CliError(err.message);
+      throw err;
+    }
+    await buildIndex(cwd);
+    out.ok(`${oldId} superseded by ${opts.by}. Index rebuilt.`);
+  });
+}
+
+// src/index.ts
+function buildProgram() {
+  const program = new Command();
+  program.name("substrata").description("Shared project memory for AI engineering agents").version("0.1.0").option("--cwd <dir>", "Run as if invoked from this directory").enablePositionalOptions();
+  program.exitOverride();
+  registerInitCommand(program);
+  registerAddCommand(program);
+  registerSearchCommand(program);
+  registerContextCommand(program);
+  registerIndexCommand(program);
+  registerListCommand(program);
+  registerShowCommand(program);
+  registerDoctorCommand(program);
+  registerSupersedeCommand(program);
+  registerMemoryUpdateCommand(program);
+  registerHookCommand(program);
+  registerMcpCommand(program);
+  return program;
+}
+function reportError(err) {
+  if (err instanceof CliError) {
+    out.err(err.message);
+    return err.exitCode;
+  }
+  if (err instanceof PromptCancelledError) {
+    out.info("Cancelled.");
+    return 1;
+  }
+  const e = err;
+  if (e && typeof e.code === "string" && e.code.startsWith("commander.")) {
+    if (e.code === "commander.helpDisplayed" || e.code === "commander.version") return 0;
+    if (e.message) out.err(e.message);
+    return typeof e.exitCode === "number" ? e.exitCode : 1;
+  }
+  out.err(`Unexpected error: ${err?.message ?? String(err)}`);
+  process.stderr.write(`${pc5.dim("This is a bug \u2014 please file an issue.")}
+`);
+  return 2;
+}
+async function runCli(argv) {
+  const program = buildProgram();
+  try {
+    await program.parseAsync(argv);
+    return Number(process.exitCode ?? 0);
+  } catch (err) {
+    return reportError(err);
+  }
+}
+
+export {
+  buildProgram,
+  runCli
+};
+//# sourceMappingURL=chunk-5LCVXNHI.js.map