@sightmap/sightmap 0.3.1 → 0.4.0

package/dist/cli/index.js

@@ -1497,6 +1497,682 @@ async function processFile(absPath, relPath, opts, fileResults, diagnostics) {
   }
 }
 
+// src/cli/init/index.ts
+import { resolve as resolve21 } from "path";
+import { mkdir as mkdir4, readFile as readFile12, rm, writeFile as writeFile7 } from "fs/promises";
+import { tmpdir } from "os";
+import * as clack2 from "@clack/prompts";
+
+// src/cli/init/detect/framework.ts
+import { readFile as readFile4, access } from "fs/promises";
+import { resolve as resolve11 } from "path";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectFramework(cwd) {
+  const pkgPath = resolve11(cwd, "package.json");
+  if (!await exists(pkgPath)) return "unknown";
+  const pkg = JSON.parse(await readFile4(pkgPath, "utf8"));
+  const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  if (deps.next) {
+    if (await exists(resolve11(cwd, "app"))) return "next-app";
+    if (await exists(resolve11(cwd, "pages"))) return "next-pages";
+    return "next-app";
+  }
+  const rrVersion = deps["react-router"];
+  const rr7 = rrVersion ? /^[\^~>=<]*7\./.test(rrVersion) : false;
+  if (rr7 || await exists(resolve11(cwd, "react-router.config.ts"))) {
+    return "react-router-7";
+  }
+  if (deps.react) {
+    if (deps.vite || await exists(resolve11(cwd, "vite.config.ts")) || await exists(resolve11(cwd, "vite.config.js"))) {
+      return "react-vite";
+    }
+    if (deps["react-scripts"]) return "react-cra";
+  }
+  return "unknown";
+}
+
+// src/cli/init/detect/harness.ts
+import { access as access2 } from "fs/promises";
+import { resolve as resolve12 } from "path";
+async function exists2(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var HARNESS_ORDER = ["claude-code", "codex", "cursor", "opencode"];
+async function detectHarnesses(cwd) {
+  const out = [];
+  for (const h of HARNESS_ORDER) {
+    let found = false;
+    if (h === "claude-code") found = await exists2(resolve12(cwd, ".claude"));
+    else if (h === "cursor") found = await exists2(resolve12(cwd, ".cursor"));
+    else if (h === "codex") found = await exists2(resolve12(cwd, ".codex"));
+    else if (h === "opencode") found = await exists2(resolve12(cwd, "opencode.json"));
+    if (found) out.push(h);
+  }
+  return out;
+}
+
+// src/cli/init/detect/vendor.ts
+import { readFile as readFile5, access as access3 } from "fs/promises";
+import { resolve as resolve13 } from "path";
+
+// src/cli/init/vendor-allowlist.ts
+var KNOWN_SIGHTMAP_VENDORS = ["subtext"];
+function isKnownVendor(entry) {
+  const haystacks = [entry.name, entry.command, ...entry.args];
+  return KNOWN_SIGHTMAP_VENDORS.some(
+    (vendor) => haystacks.some((h) => h.toLowerCase().includes(vendor.toLowerCase()))
+  );
+}
+
+// src/cli/init/detect/vendor.ts
+async function readJsonIfExists(path) {
+  try {
+    await access3(path);
+    return JSON.parse(await readFile5(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function extractServers(parsed) {
+  if (!parsed || typeof parsed !== "object") return [];
+  const root = parsed;
+  const servers = root.mcpServers ?? {};
+  return Object.entries(servers).map(([name, def]) => ({
+    name,
+    command: def.command ?? "",
+    args: def.args ?? []
+  }));
+}
+async function detectSightmapAwareVendor(cwd, hosts) {
+  const candidates = [];
+  if (hosts.includes("claude-code")) candidates.push(resolve13(cwd, ".mcp.json"));
+  if (hosts.includes("cursor")) candidates.push(resolve13(cwd, ".cursor/mcp.json"));
+  if (hosts.includes("opencode")) candidates.push(resolve13(cwd, "opencode.json"));
+  for (const path of candidates) {
+    const parsed = await readJsonIfExists(path);
+    if (!parsed) continue;
+    for (const entry of extractServers(parsed)) {
+      if (isKnownVendor(entry)) return true;
+    }
+  }
+  return false;
+}
+
+// src/cli/init/detect/sightmap-dir.ts
+import { access as access4, readdir as readdir4 } from "fs/promises";
+import { resolve as resolve14 } from "path";
+async function detectSightmapDir(cwd) {
+  const dir = resolve14(cwd, ".sightmap");
+  try {
+    await access4(dir);
+  } catch {
+    return { present: false };
+  }
+  const entries = await readdir4(dir);
+  const yamls = entries.filter((e) => e.endsWith(".yaml") || e.endsWith(".yml"));
+  return { present: true, viewCount: yamls.length };
+}
+
+// src/cli/init/tui.ts
+import * as clack from "@clack/prompts";
+import pc from "picocolors";
+var FRAMEWORK_LABELS = {
+  "react-vite": "React (Vite)",
+  "react-cra": "React (CRA)",
+  "next-app": "Next.js (App Router)",
+  "next-pages": "Next.js (Pages Router)",
+  "react-router-7": "React Router 7",
+  unknown: "unknown"
+};
+var HOST_LABELS = {
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  cursor: "Cursor",
+  opencode: "OpenCode"
+};
+function formatDetectionSummary(d) {
+  const fw = `Framework: ${FRAMEWORK_LABELS[d.framework]}`;
+  const hosts = d.hosts.length > 0 ? `Coding agents: ${d.hosts.map((h) => HOST_LABELS[h]).join(", ")}` : "Coding agents: none detected";
+  const vendor = d.sightmapAwareVendor ? "Browser MCP: Sightmap-aware vendor detected" : "Browser MCP: none detected";
+  const dir = d.sightmapDir.present ? `.sightmap/: present (${d.sightmapDir.viewCount ?? 0} views)` : ".sightmap/: not present";
+  return [fw, hosts, vendor, dir];
+}
+function intro2() {
+  clack.intro(pc.cyan("\u25C6 Sightmap") + "  curate your view inventory");
+}
+function outro2(message) {
+  clack.outro(pc.green(message));
+}
+function showDetection(d) {
+  clack.note(formatDetectionSummary(d).join("\n"), pc.dim("Detected"));
+}
+async function selectInstallPath(suggestion = "plugin") {
+  return clack.select({
+    message: "How would you like to install Sightmap?",
+    initialValue: suggestion,
+    options: [
+      {
+        value: "plugin",
+        label: "Plugin (recommended)",
+        hint: "Two copy-paste commands per host. Skills, hooks, MCP \u2014 all together."
+      },
+      {
+        value: "manual",
+        label: "Manual",
+        hint: "Write MCP config + copy skills/hooks into this repo."
+      }
+    ]
+  });
+}
+async function selectHosts(detected, defaults) {
+  const options = ["claude-code", "codex", "cursor", "opencode"].map((h) => ({
+    value: h,
+    label: HOST_LABELS[h] + (detected.includes(h) ? pc.dim(" (detected)") : "")
+  }));
+  return clack.multiselect({
+    message: "Which hosts?",
+    options,
+    initialValues: defaults,
+    required: true
+  });
+}
+
+// src/cli/init/mcp-config/claude-code.ts
+import { readFile as readFile6, writeFile as writeFile2, access as access5 } from "fs/promises";
+import { resolve as resolve15 } from "path";
+async function readJsonIfExists2(path) {
+  try {
+    await access5(path);
+    return JSON.parse(await readFile6(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function writeClaudeCodeMcp(opts) {
+  const path = resolve15(opts.cwd, ".mcp.json");
+  const existing = await readJsonIfExists2(path) ?? {};
+  const servers = existing.mcpServers ?? {};
+  const next = {
+    ...existing,
+    mcpServers: {
+      ...servers,
+      [opts.serverName]: opts.serverDef
+    }
+  };
+  await writeFile2(path, JSON.stringify(next, null, 2) + "\n", "utf8");
+}
+
+// src/cli/init/mcp-config/cursor.ts
+import { readFile as readFile7, writeFile as writeFile3, access as access6, mkdir } from "fs/promises";
+import { resolve as resolve16, dirname as dirname2 } from "path";
+async function writeCursorMcp(opts) {
+  const path = resolve16(opts.cwd, ".cursor/mcp.json");
+  let existing = {};
+  try {
+    await access6(path);
+    existing = JSON.parse(await readFile7(path, "utf8"));
+  } catch {
+    await mkdir(dirname2(path), { recursive: true });
+  }
+  const servers = existing.mcpServers ?? {};
+  const next = {
+    ...existing,
+    mcpServers: { ...servers, [opts.serverName]: opts.serverDef }
+  };
+  await writeFile3(path, JSON.stringify(next, null, 2) + "\n", "utf8");
+}
+
+// src/cli/init/mcp-config/opencode.ts
+import { readFile as readFile8, writeFile as writeFile4, access as access7 } from "fs/promises";
+import { resolve as resolve17 } from "path";
+async function writeOpenCodeMcp(opts) {
+  const path = resolve17(opts.cwd, "opencode.json");
+  let existing = {};
+  try {
+    await access7(path);
+    existing = JSON.parse(await readFile8(path, "utf8"));
+  } catch {
+  }
+  const mcp = existing.mcp ?? {};
+  const next = {
+    ...existing,
+    mcp: { ...mcp, [opts.serverName]: opts.serverDef }
+  };
+  await writeFile4(path, JSON.stringify(next, null, 2) + "\n", "utf8");
+}
+
+// src/cli/init/mcp-config/codex.ts
+import { readFile as readFile9, writeFile as writeFile5, access as access8, mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+import { parse as parse2, stringify } from "smol-toml";
+async function writeCodexMcp(opts) {
+  let existing = {};
+  try {
+    await access8(opts.configPath);
+    existing = parse2(await readFile9(opts.configPath, "utf8"));
+  } catch {
+    await mkdir2(dirname3(opts.configPath), { recursive: true });
+  }
+  const servers = existing.mcp_servers ?? {};
+  const next = {
+    ...existing,
+    mcp_servers: {
+      ...servers,
+      [opts.serverName]: opts.serverDef
+    }
+  };
+  await writeFile5(opts.configPath, stringify(next), "utf8");
+}
+
+// src/cli/init/tarball.ts
+import pacote from "pacote";
+import { readFile as readFile10 } from "fs/promises";
+import { resolve as resolve18 } from "path";
+async function fetchPluginTarball(opts) {
+  const spec = `@sightmap/plugin@${opts.version}`;
+  await pacote.extract(spec, opts.destDir);
+  const manifestPath = resolve18(opts.destDir, ".claude-plugin/plugin.json");
+  const manifest = JSON.parse(await readFile10(manifestPath, "utf8"));
+  if (!manifest.compatibleMcpVersion) {
+    throw new Error("Plugin tarball missing 'compatibleMcpVersion' in plugin.json");
+  }
+  return {
+    destDir: opts.destDir,
+    compatibleMcpVersion: manifest.compatibleMcpVersion,
+    pluginVersion: manifest.version ?? "0.0.0"
+  };
+}
+
+// src/cli/init/skills-copy.ts
+import { cp, mkdir as mkdir3, readFile as readFile11, writeFile as writeFile6, access as access9 } from "fs/promises";
+import { resolve as resolve19 } from "path";
+async function copyPluginAssets(opts) {
+  const targets = resolveTargets(opts.host, opts.projectDir);
+  await mkdir3(targets.skills, { recursive: true });
+  await cp(resolve19(opts.tarballDir, "skills"), targets.skills, { recursive: true });
+  if (targets.agents) {
+    await mkdir3(targets.agents, { recursive: true });
+    await cp(resolve19(opts.tarballDir, "agents"), targets.agents, { recursive: true });
+  }
+  if (targets.hooksJson) {
+    const srcPath = resolve19(opts.tarballDir, "hooks/hooks.json");
+    const dstPath = targets.hooksJson;
+    let merged;
+    try {
+      await access9(dstPath);
+      const existing = JSON.parse(await readFile11(dstPath, "utf8"));
+      const incoming = JSON.parse(await readFile11(srcPath, "utf8"));
+      merged = { ...existing, ...incoming };
+    } catch {
+      merged = JSON.parse(await readFile11(srcPath, "utf8"));
+    }
+    await writeFile6(dstPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  }
+}
+function resolveTargets(host, projectDir) {
+  switch (host) {
+    case "claude-code":
+      return {
+        skills: resolve19(projectDir, ".claude/skills/sightmap"),
+        agents: resolve19(projectDir, ".claude/agents"),
+        hooksJson: resolve19(projectDir, ".claude/hooks.json")
+      };
+    case "codex":
+      return {
+        skills: resolve19(projectDir, ".codex/skills/sightmap"),
+        agents: resolve19(projectDir, ".codex/agents"),
+        hooksJson: resolve19(projectDir, ".codex/hooks.json")
+      };
+    case "cursor":
+      return { skills: resolve19(projectDir, ".cursor/rules/sightmap") };
+    case "opencode":
+      return { skills: resolve19(projectDir, ".opencode/plugins/sightmap") };
+  }
+}
+
+// src/cli/init/version-pin.ts
+function buildSightmapMcpServerDef(opts) {
+  const args = [
+    "-y",
+    `@sightmap/mcp@${opts.compatibleMcpVersion}`,
+    "--sightmap-dir",
+    opts.sightmapDir,
+    "--curate-root",
+    opts.curateRoot
+  ];
+  if (opts.withBrowser) {
+    args.push("--", "npx", "-y", "@playwright/mcp@latest");
+  } else {
+    args.push("--curate-only");
+  }
+  return {
+    command: "npx",
+    args,
+    env: { SIGHTMAP_PLUGIN_VERSION: opts.pluginVersion }
+  };
+}
+
+// src/cli/init/plugin-path.ts
+var SECTIONS = {
+  "claude-code": "Claude Code:\n  /plugin marketplace add sightmap/plugin\n  /plugin install sightmap@sightmap-marketplace",
+  codex: "Codex:\n  codex plugin marketplace add sightmap/plugin\n  codex plugin install sightmap@sightmap-marketplace",
+  cursor: "Cursor:\n  /plugin add sightmap/plugin\n  (in the Cursor command palette)",
+  opencode: 'OpenCode:\n  Add to opencode.json plugin array:\n    "plugin": ["sightmap@git+https://github.com/sightmap/plugin"]\n  Then restart OpenCode.'
+};
+function renderPluginInstructions(hosts) {
+  const head = "Run these to finish setup:\n";
+  const body = hosts.map((h) => SECTIONS[h]).join("\n\n");
+  const foot = "\n\nThen restart your agent.";
+  return head + "\n" + body + foot;
+}
+
+// src/cli/init/framework-setup/package-manager.ts
+import { access as access10 } from "fs/promises";
+import { resolve as resolve20 } from "path";
+async function exists3(p) {
+  try {
+    await access10(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectPackageManager(cwd) {
+  if (await exists3(resolve20(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (await exists3(resolve20(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+
+// src/cli/init/framework-setup/install-adapter.ts
+import { spawn } from "child_process";
+var ADD_VERB = {
+  pnpm: "add",
+  yarn: "add",
+  npm: "install"
+};
+async function installAdapter(opts) {
+  await new Promise((resolveP, reject) => {
+    const child = spawn(opts.packageManager, [ADD_VERB[opts.packageManager], opts.packageName], {
+      cwd: opts.cwd,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => code === 0 ? resolveP() : reject(new Error(`${opts.packageManager} exited with code ${code}`)));
+  });
+}
+
+// src/cli/init/framework-setup/codegen.ts
+import { spawn as spawn2 } from "child_process";
+var REACT_FRAMEWORKS = ["react-vite", "react-cra", "next-app", "next-pages", "react-router-7"];
+var EXEC_VERB = {
+  pnpm: ["exec"],
+  yarn: ["exec"],
+  npm: ["exec", "--"]
+};
+function buildCodegenCommand(opts) {
+  if (!REACT_FRAMEWORKS.includes(opts.framework)) return null;
+  return {
+    command: opts.packageManager,
+    args: [...EXEC_VERB[opts.packageManager], "sightmap-react", "gen"]
+  };
+}
+async function runCodegen(cwd, cmd) {
+  await new Promise((resolveP, reject) => {
+    const child = spawn2(cmd.command, cmd.args, { cwd, stdio: "inherit" });
+    child.on("error", reject);
+    child.on("exit", (code) => code === 0 ? resolveP() : reject(new Error(`codegen exited ${code}`)));
+  });
+}
+
+// src/cli/init/framework-setup/provider-codemod.ts
+import * as recast from "recast";
+import * as parser from "@babel/parser";
+var babelParser = {
+  parse(source) {
+    return parser.parse(source, {
+      sourceType: "module",
+      tokens: true,
+      plugins: ["jsx", "typescript"]
+    });
+  }
+};
+function wrapWithSightmapProvider(source) {
+  if (source.includes("SightmapProvider")) {
+    return { code: source, changed: false, reason: "SightmapProvider already present" };
+  }
+  const ast = recast.parse(source, { parser: babelParser });
+  const b = recast.types.builders;
+  let renderCall = null;
+  let renderArgIndex = -1;
+  recast.types.visit(ast, {
+    visitCallExpression(path) {
+      const callee = path.node.callee;
+      if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "render") {
+        renderCall = path.node;
+        renderArgIndex = 0;
+        return false;
+      }
+      this.traverse(path);
+    }
+  });
+  if (!renderCall) {
+    return { code: source, changed: false, reason: "no .render() call found" };
+  }
+  const arg = renderCall.arguments[renderArgIndex];
+  if (!arg) return { code: source, changed: false, reason: "render() called with no args" };
+  const wrapped = b.jsxElement(
+    b.jsxOpeningElement(b.jsxIdentifier("SightmapProvider"), [], false),
+    b.jsxClosingElement(b.jsxIdentifier("SightmapProvider")),
+    [arg]
+  );
+  renderCall.arguments[renderArgIndex] = wrapped;
+  const importDecl = b.importDeclaration(
+    [b.importSpecifier(b.identifier("SightmapProvider"), b.identifier("SightmapProvider"))],
+    b.stringLiteral("@sightmap/react")
+  );
+  ast.program.body.unshift(importDecl);
+  const output = recast.print(ast, { quote: "single" }).code;
+  return { code: output, changed: true };
+}
+
+// src/cli/init/existing-corpus.ts
+function formatExistingCorpusReport(input) {
+  const errors = input.diagnostics.filter((d) => d.severity === "error");
+  const warnings = input.diagnostics.filter((d) => d.severity === "warning");
+  const lines = [];
+  lines.push(`sightmap check passed (${input.viewCount} views, ${errors.length} schema errors)`);
+  if (warnings.length > 0) {
+    const byCode = /* @__PURE__ */ new Map();
+    for (const w of warnings) byCode.set(w.code, (byCode.get(w.code) ?? 0) + 1);
+    const emptyMemory = byCode.get("EMPTY_MEMORY") ?? 0;
+    if (emptyMemory > 0) {
+      lines.push(`${emptyMemory} views have empty memory blocks \u2014 run /sightmap audit for details`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/init/index.ts
+var REACT_FRAMEWORKS2 = ["react-vite", "react-cra", "next-app", "next-pages", "react-router-7"];
+async function runInit(opts) {
+  intro2();
+  const detect = {
+    framework: await detectFramework(opts.cwd),
+    hosts: await detectHarnesses(opts.cwd),
+    sightmapAwareVendor: false,
+    sightmapDir: await detectSightmapDir(opts.cwd)
+  };
+  detect.sightmapAwareVendor = await detectSightmapAwareVendor(opts.cwd, detect.hosts);
+  showDetection(detect);
+  if (detect.sightmapDir.present) {
+    await runExistingCorpusFlow(opts.cwd, detect.sightmapDir.viewCount ?? 0);
+  } else {
+    await runFreshFrameworkSetup(opts, detect);
+  }
+  let installPath = opts.installPath;
+  if (!installPath) {
+    if (opts.yes) installPath = "plugin";
+    else {
+      const choice = await selectInstallPath("plugin");
+      if (typeof choice === "symbol") return 1;
+      installPath = choice;
+    }
+  }
+  const hosts = await resolveHosts(opts, detect);
+  if (hosts.length === 0) {
+    outro2("No hosts selected \u2014 nothing to do.");
+    return 0;
+  }
+  const withBrowser = resolveBrowserBundle(opts, detect);
+  if (installPath === "plugin") {
+    clack2.note(renderPluginInstructions(hosts), "Next");
+    outro2("Run those, then restart your agent.");
+    return 0;
+  }
+  const tarballDir = resolve21(tmpdir(), `sightmap-plugin-${Date.now()}`);
+  await mkdir4(tarballDir, { recursive: true });
+  try {
+    const tar = await fetchPluginTarball({ destDir: tarballDir, version: "latest" });
+    const serverDef = buildSightmapMcpServerDef({
+      compatibleMcpVersion: tar.compatibleMcpVersion,
+      pluginVersion: tar.pluginVersion,
+      withBrowser,
+      sightmapDir: ".sightmap",
+      curateRoot: ".sightmap"
+    });
+    for (const h of hosts) {
+      await writeMcpForHost(h, opts.cwd, serverDef);
+      await copyPluginAssets({ tarballDir, projectDir: opts.cwd, host: h });
+    }
+  } finally {
+    await rm(tarballDir, { recursive: true, force: true });
+  }
+  outro2("Done. Restart your agent to pick up the new MCP.");
+  return 0;
+}
+async function runFreshFrameworkSetup(opts, detect) {
+  if (!REACT_FRAMEWORKS2.includes(detect.framework)) {
+    await mkdir4(resolve21(opts.cwd, ".sightmap"), { recursive: true });
+    await writeFile7(
+      resolve21(opts.cwd, ".sightmap/app.yaml"),
+      `version: 1
+views: []
+`,
+      "utf8"
+    );
+    return;
+  }
+  const pm = await detectPackageManager(opts.cwd);
+  const spinner2 = clack2.spinner();
+  spinner2.start(`Installing @sightmap/react via ${pm}`);
+  await installAdapter({ cwd: opts.cwd, packageManager: pm, packageName: "@sightmap/react" });
+  spinner2.stop("Installed @sightmap/react");
+  if (!opts.noProvider) {
+    const entry = await findAppEntry(opts.cwd, detect.framework);
+    if (entry) {
+      const source = await readFile12(entry, "utf8");
+      const result = wrapWithSightmapProvider(source);
+      if (result.changed) {
+        if (opts.yes || await confirmCodemod(entry)) {
+          await writeFile7(entry, result.code, "utf8");
+        }
+      } else if (result.reason) {
+        clack2.log.warn(`SightmapProvider codemod skipped: ${result.reason}. Add manually to ${entry}.`);
+      }
+    } else {
+      clack2.log.warn("Could not locate an app entry file. Add <SightmapProvider> manually.");
+    }
+  }
+  if (!opts.noCodegen) {
+    const cmd = buildCodegenCommand({ framework: detect.framework, packageManager: pm });
+    if (cmd) {
+      spinner2.start("Running sightmap-react gen");
+      await runCodegen(opts.cwd, cmd);
+      spinner2.stop("Scaffolded .sightmap/");
+    }
+  }
+}
+async function findAppEntry(cwd, framework) {
+  const candidates = {
+    "react-vite": ["src/main.tsx", "src/main.jsx", "src/index.tsx", "src/index.jsx"],
+    "react-cra": ["src/index.tsx", "src/index.jsx"],
+    "next-app": ["app/layout.tsx", "app/layout.jsx"],
+    "next-pages": ["pages/_app.tsx", "pages/_app.jsx"],
+    "react-router-7": ["app/root.tsx", "app/root.jsx", "src/root.tsx"],
+    unknown: []
+  };
+  for (const rel of candidates[framework]) {
+    const abs = resolve21(cwd, rel);
+    try {
+      await readFile12(abs, "utf8");
+      return abs;
+    } catch {
+    }
+  }
+  return null;
+}
+async function confirmCodemod(entry) {
+  const choice = await clack2.confirm({
+    message: `Wrap ${entry} with <SightmapProvider>?`,
+    initialValue: true
+  });
+  return typeof choice === "boolean" ? choice : false;
+}
+async function runExistingCorpusFlow(cwd, viewCount) {
+  const spinner2 = clack2.spinner();
+  spinner2.start("Auditing existing corpus...");
+  await runLint({ path: ".sightmap", cwd, json: false, strict: false });
+  spinner2.stop("Audit complete");
+  clack2.note(formatExistingCorpusReport({ viewCount, diagnostics: [] }), `${viewCount} view${viewCount === 1 ? "" : "s"}`);
+}
+async function resolveHosts(opts, detect) {
+  if (opts.hosts) {
+    const valid = /* @__PURE__ */ new Set(["claude-code", "codex", "cursor", "opencode"]);
+    const invalid = opts.hosts.filter((h) => !valid.has(h));
+    if (invalid.length > 0) {
+      throw new Error(
+        `Unknown host(s): ${invalid.join(", ")}. Valid: claude-code, codex, cursor, opencode`
+      );
+    }
+    return opts.hosts;
+  }
+  if (opts.yes) return detect.hosts.length > 0 ? detect.hosts : ["claude-code"];
+  const defaults = detect.hosts.length > 0 ? detect.hosts : ["claude-code"];
+  const choice = await selectHosts(detect.hosts, defaults);
+  if (typeof choice === "symbol") return [];
+  return choice;
+}
+function resolveBrowserBundle(opts, detect) {
+  if (opts.withBrowser) return true;
+  if (opts.curateOnly) return false;
+  return !detect.sightmapAwareVendor;
+}
+async function writeMcpForHost(host, cwd, serverDef) {
+  const common = { cwd, serverName: "sightmap", serverDef };
+  if (host === "claude-code") return writeClaudeCodeMcp(common);
+  if (host === "cursor") return writeCursorMcp(common);
+  if (host === "opencode") return writeOpenCodeMcp(common);
+  if (host === "codex") {
+    return writeCodexMcp({
+      configPath: resolve21(process.env.HOME ?? cwd, ".codex/config.toml"),
+      serverName: "sightmap",
+      serverDef
+    });
+  }
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("sightmap").description("CLI for the Sightmap spec \u2014 validate, lint, match, explain.").version("0.1.0");
@@ -1590,6 +2266,20 @@ program.command("fmt [path]").description("Canonicalize .sightmap/*.yaml files (
     process.exit(code);
   }
 );
+program.command("init").description("Initialize Sightmap in this project (detects framework + coding agent, writes config).").option("--yes", "accept all defaults (non-interactive)").option("--plugin", "force plugin install path").option("--manual", "force manual install path").option("--host <names>", "comma-separated hosts: claude-code,codex,cursor,opencode").option("--with-browser", "force bundled Playwright + browser tools").option("--curate-only", "force curation-only (skip browser tools)").option("--no-codegen", "skip sightmap-react gen").option("--no-provider", "skip <SightmapProvider> codemod").action(async (opts) => {
+  const code = await runInit({
+    cwd: program.opts().cwd,
+    yes: opts.yes === true,
+    ...opts.plugin ? { installPath: "plugin" } : {},
+    ...opts.manual ? { installPath: "manual" } : {},
+    ...opts.host !== void 0 ? { hosts: opts.host.split(",").map((s) => s.trim()) } : {},
+    ...opts.withBrowser ? { withBrowser: true } : {},
+    ...opts.curateOnly ? { curateOnly: true } : {},
+    ...opts.codegen === false ? { noCodegen: true } : {},
+    ...opts.provider === false ? { noProvider: true } : {}
+  });
+  process.exit(code);
+});
 program.parseAsync(process.argv).catch((err) => {
   process.stderr.write(`fatal: ${err instanceof Error ? err.message : String(err)}
 `);