@sightmap/sightmap 0.4.0 → 0.5.0

package/dist/cli/index.js

@@ -1498,8 +1498,8 @@ 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 { resolve as resolve22 } from "path";
+import { mkdir as mkdir4, readFile as readFile13, rm, writeFile as writeFile7 } from "fs/promises";
 import { tmpdir } from "os";
 import * as clack2 from "@clack/prompts";
 
@@ -1625,9 +1625,220 @@ async function detectSightmapDir(cwd) {
   return { present: true, viewCount: yamls.length };
 }
 
+// src/cli/init/detect/workspaces.ts
+import { readFile as readFile6, readdir as readdir5, stat as stat3 } from "fs/promises";
+import { resolve as resolve15, relative as relative6 } from "path";
+import { parse as parseYaml } from "yaml";
+async function exists3(p) {
+  try {
+    await stat3(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readWorkspacePatterns(root) {
+  const patterns = [];
+  const pnpmWs = resolve15(root, "pnpm-workspace.yaml");
+  if (await exists3(pnpmWs)) {
+    try {
+      const parsed = parseYaml(await readFile6(pnpmWs, "utf8"));
+      const list = parsed && Array.isArray(parsed.packages) ? parsed.packages : [];
+      for (const p of list) {
+        if (typeof p === "string") patterns.push(p);
+      }
+    } catch {
+    }
+  }
+  const pkgJson = resolve15(root, "package.json");
+  if (await exists3(pkgJson)) {
+    try {
+      const pkg = JSON.parse(await readFile6(pkgJson, "utf8"));
+      const ws = pkg.workspaces;
+      if (Array.isArray(ws)) patterns.push(...ws);
+      else if (ws && Array.isArray(ws.packages)) patterns.push(...ws.packages);
+    } catch {
+    }
+  }
+  return patterns;
+}
+async function expandPattern(root, pattern) {
+  const trimmed = pattern.replace(/^\.\//, "").replace(/\/$/, "");
+  if (trimmed.startsWith("!")) return [];
+  if (trimmed.includes("**")) return expandDoubleStar(root, trimmed);
+  const segments = trimmed.split("/");
+  return expandSegments(root, segments, 0, root);
+}
+async function expandSegments(root, segs, idx, current) {
+  if (idx >= segs.length) {
+    if (await isPackageDir(current)) return [current];
+    return [];
+  }
+  const seg = segs[idx];
+  if (seg === void 0) return [];
+  if (seg === "*") {
+    let entries = [];
+    try {
+      entries = await readdir5(current);
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const name of entries) {
+      if (name.startsWith(".")) continue;
+      const child = resolve15(current, name);
+      let s;
+      try {
+        s = await stat3(child);
+      } catch {
+        continue;
+      }
+      if (!s.isDirectory()) continue;
+      out.push(...await expandSegments(root, segs, idx + 1, child));
+    }
+    return out;
+  }
+  return expandSegments(root, segs, idx + 1, resolve15(current, seg));
+}
+async function expandDoubleStar(root, pattern) {
+  const prefix = (pattern.split("**")[0] ?? "").replace(/\/$/, "");
+  const base = prefix ? resolve15(root, prefix) : root;
+  const out = [];
+  await walk2(base, 0, 5, out);
+  return out;
+}
+async function walk2(dir, depth, maxDepth, out) {
+  if (depth > maxDepth) return;
+  if (await isPackageDir(dir)) out.push(dir);
+  let entries = [];
+  try {
+    entries = await readdir5(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (name.startsWith(".") || name === "node_modules") continue;
+    const child = resolve15(dir, name);
+    let s;
+    try {
+      s = await stat3(child);
+    } catch {
+      continue;
+    }
+    if (s.isDirectory()) await walk2(child, depth + 1, maxDepth, out);
+  }
+}
+async function isPackageDir(dir) {
+  return exists3(resolve15(dir, "package.json"));
+}
+async function enumerateWorkspaces(opts) {
+  const { root } = opts;
+  const patterns = await readWorkspacePatterns(root);
+  if (patterns.length === 0) return [];
+  const dirs = /* @__PURE__ */ new Set();
+  for (const pat of patterns) {
+    for (const d of await expandPattern(root, pat)) dirs.add(d);
+  }
+  const result = [];
+  for (const dir of dirs) {
+    if (dir === root) continue;
+    const framework = await detectFramework(dir);
+    result.push({ dir, relPath: relative6(root, dir) || ".", framework });
+  }
+  result.sort((a, b) => {
+    const ak = a.framework === "unknown" ? 1 : 0;
+    const bk = b.framework === "unknown" ? 1 : 0;
+    if (ak !== bk) return ak - bk;
+    return a.relPath.localeCompare(b.relPath);
+  });
+  return result;
+}
+
 // src/cli/init/tui.ts
 import * as clack from "@clack/prompts";
 import pc from "picocolors";
+
+// src/cli/init/framework-setup/provider-snippet.ts
+import { relative as relative7 } from "path";
+var IMPORT_LINE = `import { SightmapProvider } from '@sightmap/react';`;
+function renderProviderSnippet(opts) {
+  const relPath = relative7(opts.cwd, opts.entryAbsPath) || opts.entryAbsPath;
+  switch (opts.framework) {
+    case "react-vite":
+    case "react-cra":
+      return {
+        relPath,
+        importLine: IMPORT_LINE,
+        instruction: "Wrap your render root with <SightmapProvider>:",
+        example: `ReactDOM.createRoot(document.getElementById('root')!).render(
+  <SightmapProvider>
+    <App />
+  </SightmapProvider>,
+);`
+      };
+    case "next-app":
+      return {
+        relPath,
+        importLine: IMPORT_LINE,
+        instruction: "Wrap the layout's {children} with <SightmapProvider>:",
+        example: `export default function RootLayout({ children }) {
+  return (
+    <html>
+      <body>
+        <SightmapProvider>{children}</SightmapProvider>
+      </body>
+    </html>
+  );
+}`
+      };
+    case "next-pages":
+      return {
+        relPath,
+        importLine: IMPORT_LINE,
+        instruction: "Wrap <Component {...pageProps} /> with <SightmapProvider>:",
+        example: `export default function App({ Component, pageProps }) {
+  return (
+    <SightmapProvider>
+      <Component {...pageProps} />
+    </SightmapProvider>
+  );
+}`
+      };
+    case "react-router-7":
+      return {
+        relPath,
+        importLine: IMPORT_LINE,
+        instruction: "Wrap the default export's returned JSX with <SightmapProvider>:",
+        example: `export default function Root() {
+  return (
+    <SightmapProvider>
+      <Outlet />
+    </SightmapProvider>
+  );
+}`
+      };
+    case "unknown":
+      return {
+        relPath,
+        importLine: IMPORT_LINE,
+        instruction: "Wrap your application's root component with <SightmapProvider>.",
+        example: `<SightmapProvider>{/* your app */}</SightmapProvider>`
+      };
+  }
+}
+function formatSnippet(snippet) {
+  return [
+    `In ${snippet.relPath}:`,
+    "",
+    `  ${snippet.importLine}`,
+    "",
+    snippet.instruction,
+    "",
+    ...snippet.example.split("\n").map((l) => `  ${l}`)
+  ].join("\n");
+}
+
+// src/cli/init/tui.ts
 var FRAMEWORK_LABELS = {
   "react-vite": "React (Vite)",
   "react-cra": "React (CRA)",
@@ -1642,11 +1853,23 @@ var HOST_LABELS = {
   cursor: "Cursor",
   opencode: "OpenCode"
 };
+function row(label, value) {
+  return `${pc.cyan(label)} ${pc.white(value)}`;
+}
 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";
+  const fw = row("Framework:", FRAMEWORK_LABELS[d.framework]);
+  const hosts = row(
+    "Coding agents:",
+    d.hosts.length > 0 ? d.hosts.map((h) => HOST_LABELS[h]).join(", ") : "none detected"
+  );
+  const vendor = row(
+    "Browser MCP:",
+    d.sightmapAwareVendor ? "Sightmap-aware vendor detected" : "none detected"
+  );
+  const dir = row(
+    ".sightmap/:",
+    d.sightmapDir.present ? `present (${d.sightmapDir.viewCount ?? 0} views)` : "not present"
+  );
   return [fw, hosts, vendor, dir];
 }
 function intro2() {
@@ -1656,7 +1879,49 @@ function outro2(message) {
   clack.outro(pc.green(message));
 }
 function showDetection(d) {
-  clack.note(formatDetectionSummary(d).join("\n"), pc.dim("Detected"));
+  clack.log.message(
+    [pc.bold("Detected"), "", ...formatDetectionSummary(d)].join("\n"),
+    { symbol: pc.cyan("\u25C7") }
+  );
+}
+function showPluginInstructions(hosts) {
+  const lines = [pc.bold("Next: run these to finish setup"), ""];
+  for (let i = 0; i < hosts.length; i++) {
+    const h = hosts[i];
+    lines.push(...pluginSection(h));
+    if (i < hosts.length - 1) lines.push("");
+  }
+  lines.push("", pc.dim("Then restart your agent."));
+  clack.log.message(lines.join("\n"), { symbol: pc.cyan("\u25C7") });
+}
+function pluginSection(host) {
+  switch (host) {
+    case "claude-code":
+      return [
+        pc.cyan("Claude Code"),
+        pc.white("  /plugin marketplace add sightmap/plugin"),
+        pc.white("  /plugin install sightmap@sightmap-marketplace")
+      ];
+    case "codex":
+      return [
+        pc.cyan("Codex"),
+        pc.white("  codex plugin marketplace add sightmap/plugin"),
+        pc.white("  codex plugin install sightmap@sightmap-marketplace")
+      ];
+    case "cursor":
+      return [
+        pc.cyan("Cursor"),
+        pc.white("  /plugin add sightmap/plugin"),
+        pc.dim("  (in the Cursor command palette)")
+      ];
+    case "opencode":
+      return [
+        pc.cyan("OpenCode"),
+        pc.white("  Add to opencode.json plugin array:"),
+        pc.white('    "plugin": ["sightmap@git+https://github.com/sightmap/plugin"]'),
+        pc.dim("  Then restart OpenCode.")
+      ];
+  }
 }
 async function selectInstallPath(suggestion = "plugin") {
   return clack.select({
@@ -1676,6 +1941,40 @@ async function selectInstallPath(suggestion = "plugin") {
     ]
   });
 }
+async function selectWorkspace(workspaces) {
+  const options = workspaces.map((w) => ({
+    value: w,
+    label: w.relPath,
+    hint: w.framework === "unknown" ? pc.dim("no framework") : FRAMEWORK_LABELS[w.framework]
+  }));
+  return clack.select({
+    message: "Multiple workspaces found. Which one should we set up?",
+    options,
+    initialValue: workspaces[0]
+  });
+}
+async function selectProviderAction(entryRelPath) {
+  const options = [
+    { value: "auto", label: "Wrap automatically", hint: "Edit the file in place via codemod." },
+    { value: "snippet", label: "Show me the snippet to paste", hint: "Print the exact lines; I'll add them myself." },
+    { value: "skip", label: "Skip", hint: "Already done, or I'll handle it later." }
+  ];
+  return clack.select({
+    message: `Add <SightmapProvider> to ${entryRelPath}?`,
+    initialValue: "auto",
+    options
+  });
+}
+function showProviderSnippet(snippet, note) {
+  const header = pc.bold("Add <SightmapProvider> manually");
+  const body = formatSnippet(snippet);
+  const trailer = note ? `
+
+${pc.dim(note)}` : "";
+  clack.log.message(`${header}
+
+${body}${trailer}`, { symbol: pc.cyan("\u25C7") });
+}
 async function selectHosts(detected, defaults) {
   const options = ["claude-code", "codex", "cursor", "opencode"].map((h) => ({
     value: h,
@@ -1690,18 +1989,18 @@ async function selectHosts(detected, defaults) {
 }
 
 // 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";
+import { readFile as readFile7, writeFile as writeFile2, access as access5 } from "fs/promises";
+import { resolve as resolve16 } from "path";
 async function readJsonIfExists2(path) {
   try {
     await access5(path);
-    return JSON.parse(await readFile6(path, "utf8"));
+    return JSON.parse(await readFile7(path, "utf8"));
   } catch {
     return null;
   }
 }
 async function writeClaudeCodeMcp(opts) {
-  const path = resolve15(opts.cwd, ".mcp.json");
+  const path = resolve16(opts.cwd, ".mcp.json");
   const existing = await readJsonIfExists2(path) ?? {};
   const servers = existing.mcpServers ?? {};
   const next = {
@@ -1715,14 +2014,14 @@ async function writeClaudeCodeMcp(opts) {
 }
 
 // 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";
+import { readFile as readFile8, writeFile as writeFile3, access as access6, mkdir } from "fs/promises";
+import { resolve as resolve17, dirname as dirname2 } from "path";
 async function writeCursorMcp(opts) {
-  const path = resolve16(opts.cwd, ".cursor/mcp.json");
+  const path = resolve17(opts.cwd, ".cursor/mcp.json");
   let existing = {};
   try {
     await access6(path);
-    existing = JSON.parse(await readFile7(path, "utf8"));
+    existing = JSON.parse(await readFile8(path, "utf8"));
   } catch {
     await mkdir(dirname2(path), { recursive: true });
   }
@@ -1735,14 +2034,14 @@ async function writeCursorMcp(opts) {
 }
 
 // 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";
+import { readFile as readFile9, writeFile as writeFile4, access as access7 } from "fs/promises";
+import { resolve as resolve18 } from "path";
 async function writeOpenCodeMcp(opts) {
-  const path = resolve17(opts.cwd, "opencode.json");
+  const path = resolve18(opts.cwd, "opencode.json");
   let existing = {};
   try {
     await access7(path);
-    existing = JSON.parse(await readFile8(path, "utf8"));
+    existing = JSON.parse(await readFile9(path, "utf8"));
   } catch {
   }
   const mcp = existing.mcp ?? {};
@@ -1754,14 +2053,14 @@ async function writeOpenCodeMcp(opts) {
 }
 
 // src/cli/init/mcp-config/codex.ts
-import { readFile as readFile9, writeFile as writeFile5, access as access8, mkdir as mkdir2 } from "fs/promises";
+import { readFile as readFile10, 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"));
+    existing = parse2(await readFile10(opts.configPath, "utf8"));
   } catch {
     await mkdir2(dirname3(opts.configPath), { recursive: true });
   }
@@ -1778,13 +2077,13 @@ async function writeCodexMcp(opts) {
 
 // src/cli/init/tarball.ts
 import pacote from "pacote";
-import { readFile as readFile10 } from "fs/promises";
-import { resolve as resolve18 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { resolve as resolve19 } 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"));
+  const manifestPath = resolve19(opts.destDir, ".claude-plugin/plugin.json");
+  const manifest = JSON.parse(await readFile11(manifestPath, "utf8"));
   if (!manifest.compatibleMcpVersion) {
     throw new Error("Plugin tarball missing 'compatibleMcpVersion' in plugin.json");
   }
@@ -1796,49 +2095,139 @@ async function fetchPluginTarball(opts) {
 }
 
 // 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";
+import { chmod, cp, mkdir as mkdir3, readFile as readFile12, readdir as readdir6, stat as stat4, writeFile as writeFile6, access as access9 } from "fs/promises";
+import { resolve as resolve20 } from "path";
+
+// src/cli/init/settings-merge.ts
+var PLUGIN_ROOT_TOKEN = /\$\{CLAUDE_PLUGIN_ROOT\}/g;
+function rewriteHookCommands(hooks, replacement) {
+  const out = {};
+  for (const [event, groups] of Object.entries(hooks)) {
+    out[event] = groups.map((g) => ({
+      ...g.matcher !== void 0 ? { matcher: g.matcher } : {},
+      hooks: g.hooks.map((h) => ({
+        ...h,
+        command: h.command.replace(PLUGIN_ROOT_TOKEN, replacement)
+      }))
+    }));
+  }
+  return out;
+}
+function mergeHooksIntoSettings(existing, incoming) {
+  const merged = { ...existing };
+  const mergedHooks = { ...existing.hooks ?? {} };
+  for (const [event, incomingGroups] of Object.entries(incoming)) {
+    const existingGroups = mergedHooks[event] ?? [];
+    const combined = [...existingGroups];
+    for (const g of incomingGroups) {
+      if (!hasGroup(combined, g)) combined.push(g);
+    }
+    mergedHooks[event] = combined;
+  }
+  merged.hooks = mergedHooks;
+  return merged;
+}
+function hasGroup(groups, candidate) {
+  return groups.some(
+    (g) => (g.matcher ?? "") === (candidate.matcher ?? "") && g.hooks.length === candidate.hooks.length && g.hooks.every((h, i) => h.command === candidate.hooks[i]?.command)
+  );
+}
+
+// src/cli/init/skills-copy.ts
 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 });
+  await cp(resolve20(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 });
+    await cp(resolve20(opts.tarballDir, "agents"), targets.agents, { recursive: true });
+  }
+  if (targets.bin) {
+    await mkdir3(targets.bin, { recursive: true });
+    await cp(resolve20(opts.tarballDir, "bin"), targets.bin, { recursive: true });
+    await chmodShellScripts(targets.bin);
+  }
+  if (targets.settingsJson && targets.bin && targets.binEnvPath) {
+    await installHooksIntoSettings({
+      tarballDir: opts.tarballDir,
+      settingsPath: targets.settingsJson,
+      binEnvPath: targets.binEnvPath
+    });
+  } else if (targets.hooksJson) {
+    await installLegacyHooksJson({
+      tarballDir: opts.tarballDir,
+      dstPath: targets.hooksJson,
+      binEnvPath: targets.binEnvPath ?? `\${CLAUDE_PROJECT_DIR}/.claude/sightmap`
+    });
   }
-  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"));
+}
+async function installHooksIntoSettings(opts) {
+  const incomingRaw = JSON.parse(
+    await readFile12(resolve20(opts.tarballDir, "hooks/hooks.json"), "utf8")
+  );
+  const incoming = incomingRaw.hooks ?? {};
+  const rewritten = rewriteHookCommands(incoming, opts.binEnvPath);
+  let existing = {};
+  try {
+    await access9(opts.settingsPath);
+    existing = JSON.parse(await readFile12(opts.settingsPath, "utf8"));
+  } catch {
+  }
+  const merged = mergeHooksIntoSettings(existing, rewritten);
+  await mkdir3(resolve20(opts.settingsPath, ".."), { recursive: true });
+  await writeFile6(opts.settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+}
+async function installLegacyHooksJson(opts) {
+  const srcRaw = JSON.parse(
+    await readFile12(resolve20(opts.tarballDir, "hooks/hooks.json"), "utf8")
+  );
+  const rewritten = rewriteHookCommands(srcRaw.hooks ?? {}, opts.binEnvPath);
+  let merged = { hooks: rewritten };
+  try {
+    await access9(opts.dstPath);
+    const existing = JSON.parse(await readFile12(opts.dstPath, "utf8"));
+    merged = { hooks: { ...existing.hooks ?? {}, ...rewritten } };
+  } catch {
+  }
+  await mkdir3(resolve20(opts.dstPath, ".."), { recursive: true });
+  await writeFile6(opts.dstPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+}
+async function chmodShellScripts(dir) {
+  const entries = await readdir6(dir);
+  for (const name of entries) {
+    const p = resolve20(dir, name);
+    const s = await stat4(p);
+    if (s.isDirectory()) {
+      await chmodShellScripts(p);
+    } else if (name.endsWith(".sh")) {
+      await chmod(p, 493);
     }
-    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")
+        skills: resolve20(projectDir, ".claude/skills/sightmap"),
+        agents: resolve20(projectDir, ".claude/agents"),
+        bin: resolve20(projectDir, ".claude/sightmap/bin"),
+        // Stand-in for CLAUDE_PLUGIN_ROOT — tarball commands are written as
+        // ${CLAUDE_PLUGIN_ROOT}/bin/X.sh, so we replace the plugin root, not the bin dir.
+        binEnvPath: "${CLAUDE_PROJECT_DIR}/.claude/sightmap",
+        settingsJson: resolve20(projectDir, ".claude/settings.json")
       };
     case "codex":
       return {
-        skills: resolve19(projectDir, ".codex/skills/sightmap"),
-        agents: resolve19(projectDir, ".codex/agents"),
-        hooksJson: resolve19(projectDir, ".codex/hooks.json")
+        skills: resolve20(projectDir, ".codex/skills/sightmap"),
+        agents: resolve20(projectDir, ".codex/agents"),
+        bin: resolve20(projectDir, ".codex/sightmap/bin"),
+        binEnvPath: "${CLAUDE_PROJECT_DIR}/.codex/sightmap",
+        hooksJson: resolve20(projectDir, ".codex/hooks.json")
       };
     case "cursor":
-      return { skills: resolve19(projectDir, ".cursor/rules/sightmap") };
+      return { skills: resolve20(projectDir, ".cursor/rules/sightmap") };
     case "opencode":
-      return { skills: resolve19(projectDir, ".opencode/plugins/sightmap") };
+      return { skills: resolve20(projectDir, ".opencode/plugins/sightmap") };
   }
 }
 
@@ -1864,24 +2253,10 @@ function buildSightmapMcpServerDef(opts) {
   };
 }
 
-// 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) {
+import { dirname as dirname4, resolve as resolve21 } from "path";
+async function exists4(p) {
   try {
     await access10(p);
     return true;
@@ -1889,10 +2264,21 @@ async function exists3(p) {
     return false;
   }
 }
+var SIGNALS = [
+  { file: "pnpm-lock.yaml", pm: "pnpm" },
+  { file: "pnpm-workspace.yaml", pm: "pnpm" },
+  { file: "yarn.lock", pm: "yarn" }
+];
 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";
+  let dir = resolve21(cwd);
+  while (true) {
+    for (const { file, pm } of SIGNALS) {
+      if (await exists4(resolve21(dir, file))) return pm;
+    }
+    const parent = dirname4(dir);
+    if (parent === dir) return "npm";
+    dir = parent;
+  }
 }
 
 // src/cli/init/framework-setup/install-adapter.ts
@@ -1925,7 +2311,7 @@ function buildCodegenCommand(opts) {
   if (!REACT_FRAMEWORKS.includes(opts.framework)) return null;
   return {
     command: opts.packageManager,
-    args: [...EXEC_VERB[opts.packageManager], "sightmap-react", "gen"]
+    args: [...EXEC_VERB[opts.packageManager], "sightmap-react", "gen", "--router=auto"]
   };
 }
 async function runCodegen(cwd, cmd) {
@@ -1948,43 +2334,109 @@ var babelParser = {
     });
   }
 };
-function wrapWithSightmapProvider(source) {
+function wrapWithSightmapProvider(source, opts = {}) {
   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;
+  const wrap = (inner) => b.jsxElement(
+    b.jsxOpeningElement(b.jsxIdentifier("SightmapProvider"), [], false),
+    b.jsxClosingElement(b.jsxIdentifier("SightmapProvider")),
+    [stripPrintMetadata(inner)]
+  );
+  let wrapped = false;
+  let reason;
   recast.types.visit(ast, {
     visitCallExpression(path) {
+      if (wrapped) return false;
       const callee = path.node.callee;
       if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "render") {
-        renderCall = path.node;
-        renderArgIndex = 0;
+        const arg = path.node.arguments[0];
+        if (!arg) {
+          reason = "render() called with no args";
+          return false;
+        }
+        path.node.arguments[0] = wrap(arg);
+        wrapped = true;
         return false;
       }
       this.traverse(path);
     }
   });
-  if (!renderCall) {
-    return { code: source, changed: false, reason: "no .render() call found" };
+  if (!wrapped && opts.framework === "react-router-7") {
+    wrapped = tryWrapDefaultExport(ast, wrap);
+    if (!wrapped) reason = "no default export returning JSX found in app/root.tsx";
+  }
+  if (!wrapped) {
+    return { code: source, changed: false, reason: 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 };
+  insertImportAfterHeaderComments(ast, importDecl);
+  return { code: recast.print(ast, { quote: "single" }).code, changed: true };
+}
+function insertImportAfterHeaderComments(ast, importDecl) {
+  const body = ast.program.body;
+  const firstStmt = body[0];
+  if (firstStmt) {
+    const newImp = importDecl;
+    if (Array.isArray(firstStmt.leadingComments) && firstStmt.leadingComments.length > 0) {
+      newImp.leadingComments = firstStmt.leadingComments;
+      firstStmt.leadingComments = [];
+    }
+    if (Array.isArray(firstStmt.comments) && firstStmt.comments.length > 0) {
+      newImp.comments = firstStmt.comments;
+      firstStmt.comments = [];
+    }
+  }
+  body.unshift(importDecl);
+}
+function stripPrintMetadata(node) {
+  const n = node;
+  if (n && typeof n === "object") {
+    try {
+      n.original = void 0;
+    } catch {
+    }
+    try {
+      n.loc = void 0;
+    } catch {
+    }
+    if (n.extra) n.extra.parenthesized = false;
+  }
+  return node;
+}
+function tryWrapDefaultExport(ast, wrap) {
+  let done = false;
+  recast.types.visit(ast, {
+    visitExportDefaultDeclaration(path) {
+      if (done) return false;
+      const decl = path.node.declaration;
+      const body = decl.body;
+      if ((decl.type === "FunctionDeclaration" || decl.type === "ArrowFunctionExpression" || decl.type === "FunctionExpression") && body && body.type === "BlockStatement" && Array.isArray(body.body)) {
+        for (const stmt of body.body) {
+          if (stmt.type === "ReturnStatement" && stmt.argument) {
+            const arg = stmt.argument;
+            if (arg.type === "JSXElement" || arg.type === "JSXFragment") {
+              stmt.argument = wrap(stmt.argument);
+              done = true;
+              return false;
+            }
+          }
+        }
+      }
+      if (decl.type === "ArrowFunctionExpression" && body && (body.type === "JSXElement" || body.type === "JSXFragment")) {
+        decl.body = wrap(body);
+        done = true;
+        return false;
+      }
+      return false;
+    }
+  });
+  return done;
 }
 
 // src/cli/init/existing-corpus.ts
@@ -2008,7 +2460,7 @@ function formatExistingCorpusReport(input) {
 var REACT_FRAMEWORKS2 = ["react-vite", "react-cra", "next-app", "next-pages", "react-router-7"];
 async function runInit(opts) {
   intro2();
-  const detect = {
+  let detect = {
     framework: await detectFramework(opts.cwd),
     hosts: await detectHarnesses(opts.cwd),
     sightmapAwareVendor: false,
@@ -2016,6 +2468,20 @@ async function runInit(opts) {
   };
   detect.sightmapAwareVendor = await detectSightmapAwareVendor(opts.cwd, detect.hosts);
   showDetection(detect);
+  if (detect.framework === "unknown" && !detect.sightmapDir.present) {
+    const chosen = await maybePickWorkspace(opts);
+    if (typeof chosen === "symbol") return 1;
+    if (chosen) {
+      opts = { ...opts, cwd: chosen.dir };
+      clack2.log.info(`Targeting workspace: ${chosen.relPath}`);
+      detect = {
+        framework: await detectFramework(opts.cwd),
+        hosts: detect.hosts,
+        sightmapAwareVendor: detect.sightmapAwareVendor,
+        sightmapDir: await detectSightmapDir(opts.cwd)
+      };
+    }
+  }
   if (detect.sightmapDir.present) {
     await runExistingCorpusFlow(opts.cwd, detect.sightmapDir.viewCount ?? 0);
   } else {
@@ -2037,11 +2503,11 @@ async function runInit(opts) {
   }
   const withBrowser = resolveBrowserBundle(opts, detect);
   if (installPath === "plugin") {
-    clack2.note(renderPluginInstructions(hosts), "Next");
+    showPluginInstructions(hosts);
     outro2("Run those, then restart your agent.");
     return 0;
   }
-  const tarballDir = resolve21(tmpdir(), `sightmap-plugin-${Date.now()}`);
+  const tarballDir = resolve22(tmpdir(), `sightmap-plugin-${Date.now()}`);
   await mkdir4(tarballDir, { recursive: true });
   try {
     const tar = await fetchPluginTarball({ destDir: tarballDir, version: "latest" });
@@ -2064,9 +2530,9 @@ async function runInit(opts) {
 }
 async function runFreshFrameworkSetup(opts, detect) {
   if (!REACT_FRAMEWORKS2.includes(detect.framework)) {
-    await mkdir4(resolve21(opts.cwd, ".sightmap"), { recursive: true });
+    await mkdir4(resolve22(opts.cwd, ".sightmap"), { recursive: true });
     await writeFile7(
-      resolve21(opts.cwd, ".sightmap/app.yaml"),
+      resolve22(opts.cwd, ".sightmap/app.yaml"),
       `version: 1
 views: []
 `,
@@ -2080,20 +2546,7 @@ views: []
   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.");
-    }
+    await runProviderStep(opts, detect);
   }
   if (!opts.noCodegen) {
     const cmd = buildCodegenCommand({ framework: detect.framework, packageManager: pm });
@@ -2104,6 +2557,50 @@ views: []
     }
   }
 }
+async function runProviderStep(opts, detect) {
+  const entry = await findAppEntry(opts.cwd, detect.framework);
+  if (!entry) {
+    const snippet = renderProviderSnippet({
+      framework: detect.framework,
+      cwd: opts.cwd,
+      entryAbsPath: "your app's root component file"
+    });
+    showProviderSnippet(snippet, "We couldn't locate the entry file \u2014 drop these lines into your app's root.");
+    return;
+  }
+  const source = await readFile13(entry, "utf8");
+  const result = wrapWithSightmapProvider(source, { framework: detect.framework });
+  if (!result.changed) {
+    const snippet = renderProviderSnippet({
+      framework: detect.framework,
+      cwd: opts.cwd,
+      entryAbsPath: entry
+    });
+    const note = result.reason ? `Codemod skipped: ${result.reason}.` : void 0;
+    showProviderSnippet(snippet, note);
+    return;
+  }
+  if (opts.yes) {
+    await writeFile7(entry, result.code, "utf8");
+    return;
+  }
+  const entryRel = relativePath(opts.cwd, entry);
+  const choice = await selectProviderAction(entryRel);
+  if (choice === "auto") {
+    await writeFile7(entry, result.code, "utf8");
+  } else if (choice === "snippet") {
+    const snippet = renderProviderSnippet({
+      framework: detect.framework,
+      cwd: opts.cwd,
+      entryAbsPath: entry
+    });
+    showProviderSnippet(snippet);
+  }
+}
+function relativePath(cwd, abs) {
+  if (abs.startsWith(cwd + "/")) return abs.slice(cwd.length + 1);
+  return abs;
+}
 async function findAppEntry(cwd, framework) {
   const candidates = {
     "react-vite": ["src/main.tsx", "src/main.jsx", "src/index.tsx", "src/index.jsx"],
@@ -2114,28 +2611,25 @@ async function findAppEntry(cwd, framework) {
     unknown: []
   };
   for (const rel of candidates[framework]) {
-    const abs = resolve21(cwd, rel);
+    const abs = resolve22(cwd, rel);
     try {
-      await readFile12(abs, "utf8");
+      await readFile13(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"}`);
+  const header = `${viewCount} view${viewCount === 1 ? "" : "s"}`;
+  const body = formatExistingCorpusReport({ viewCount, diagnostics: [] });
+  clack2.log.message(`${header}
+
+${body}`);
 }
 async function resolveHosts(opts, detect) {
   if (opts.hosts) {
@@ -2159,6 +2653,20 @@ function resolveBrowserBundle(opts, detect) {
   if (opts.curateOnly) return false;
   return !detect.sightmapAwareVendor;
 }
+async function maybePickWorkspace(opts) {
+  const all = await enumerateWorkspaces({ root: opts.cwd });
+  if (all.length === 0) return null;
+  const withFramework = all.filter((w) => w.framework !== "unknown");
+  if (withFramework.length === 0) return null;
+  if (opts.yes) {
+    if (withFramework.length === 1) return withFramework[0];
+    clack2.log.warn(
+      `Found ${withFramework.length} workspaces with a framework. Re-run from one of them, or without -y to pick interactively.`
+    );
+    return null;
+  }
+  return selectWorkspace(withFramework);
+}
 async function writeMcpForHost(host, cwd, serverDef) {
   const common = { cwd, serverName: "sightmap", serverDef };
   if (host === "claude-code") return writeClaudeCodeMcp(common);
@@ -2166,7 +2674,7 @@ async function writeMcpForHost(host, cwd, serverDef) {
   if (host === "opencode") return writeOpenCodeMcp(common);
   if (host === "codex") {
     return writeCodexMcp({
-      configPath: resolve21(process.env.HOME ?? cwd, ".codex/config.toml"),
+      configPath: resolve22(process.env.HOME ?? cwd, ".codex/config.toml"),
       serverName: "sightmap",
       serverDef
     });