@inspecto-dev/cli 0.2.0-alpha.5 → 0.3.0-alpha.1

package/dist/chunk-FZS2TLXQ.js

@@ -0,0 +1,3140 @@
+// src/utils/logger.ts
+import pc from "picocolors";
+var log = {
+  /** Section header */
+  header(text) {
+    console.log();
+    console.log(`  ${pc.bold(pc.cyan("\u2726"))} ${pc.bold(text)}`);
+    console.log();
+  },
+  /** Info item (used for actionable but not fully successful states) */
+  info(text) {
+    console.log(`  ${pc.blue("\u2139")} ${text}`);
+  },
+  success(text) {
+    console.log(`  ${pc.green("\u2714")} ${text}`);
+  },
+  /** Warning item */
+  warn(text) {
+    console.log(`  ${pc.yellow("\u26A0")} ${text}`);
+  },
+  /** Error item */
+  error(text) {
+    console.log(`  ${pc.red("\u2718")} ${text}`);
+  },
+  /** Indented hint line */
+  hint(text) {
+    console.log(`    ${pc.dim("\u2192")} ${text}`);
+  },
+  /** Blank line */
+  blank() {
+    console.log();
+  },
+  /** Final ready message */
+  ready(text) {
+    console.log();
+    console.log(`  ${pc.bold(pc.green("\u26A1"))} ${pc.bold(text)}`);
+    console.log();
+  },
+  /** Code block for manual instructions */
+  codeBlock(lines) {
+    console.log();
+    console.log(`  ${pc.dim("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510")}`);
+    for (const line of lines) {
+      console.log(`  ${pc.dim("\u2502")} ${line.padEnd(48)}${pc.dim("\u2502")}`);
+    }
+    console.log(`  ${pc.dim("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518")}`);
+    console.log();
+  },
+  /** Copy-friendly code block without box characters */
+  copyableCodeBlock(lines) {
+    console.log();
+    for (const line of lines) {
+      console.log(`      ${line}`);
+    }
+    console.log();
+  },
+  /** Dry-run prefix */
+  dryRun(text) {
+    console.log(`  ${pc.blue("[dry-run]")} ${text}`);
+  }
+};
+
+// src/utils/output.ts
+function writeCommandOutput(result, json, renderText) {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return result;
+  }
+  renderText(result);
+  return result;
+}
+function reportCommandError(error, options = {}) {
+  const message2 = error instanceof Error ? error.message : String(error);
+  const stack = error instanceof Error ? error.stack : void 0;
+  if (options.json) {
+    const payload = {
+      status: "error",
+      error: {
+        message: message2,
+        ...options.debug && stack ? { stack } : {}
+      }
+    };
+    console.error(JSON.stringify(payload, null, 2));
+    return;
+  }
+  log.error(message2);
+  if (options.debug && stack) {
+    console.error(stack);
+  }
+}
+
+// src/onboarding/apply.ts
+import path5 from "path";
+import ora from "ora";
+
+// src/detect/package-manager.ts
+import path2 from "path";
+
+// src/utils/fs.ts
+import fs from "fs/promises";
+import path from "path";
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFile(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function writeFile(filePath, content) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function removeDir(dirPath) {
+  try {
+    await fs.rm(dirPath, { recursive: true, force: true });
+  } catch {
+  }
+}
+async function readJSON(filePath) {
+  const text = await readFile(filePath);
+  if (text === null) return null;
+  if (text.trim() === "") return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function writeJSON(filePath, data) {
+  await writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+
+// src/detect/package-manager.ts
+async function detectPackageManager(root) {
+  const checks = [
+    ["bun.lockb", "bun"],
+    ["bun.lock", "bun"],
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["package-lock.json", "npm"]
+  ];
+  const results = await Promise.all(
+    checks.map(async ([file, pm]) => {
+      const isExist = await exists(path2.join(root, file));
+      return { isExist, pm };
+    })
+  );
+  for (const result of results) {
+    if (result.isExist) {
+      return result.pm;
+    }
+  }
+  return "npm";
+}
+function getInstallCommand(pm, pkg) {
+  switch (pm) {
+    case "bun":
+      return `bun add -D ${pkg}`;
+    case "pnpm":
+      return `pnpm add -D ${pkg}`;
+    case "yarn":
+      return `yarn add -D ${pkg}`;
+    case "npm":
+      return `npm install -D ${pkg}`;
+  }
+}
+function getUninstallCommand(pm, pkg) {
+  switch (pm) {
+    case "bun":
+      return `bun remove ${pkg}`;
+    case "pnpm":
+      return `pnpm remove ${pkg}`;
+    case "yarn":
+      return `yarn remove ${pkg}`;
+    case "npm":
+      return `npm uninstall ${pkg}`;
+  }
+}
+
+// src/inject/ast-injector.ts
+import path3 from "path";
+import { loadFile, writeFile as writeAstFile } from "magicast";
+
+// src/inject/strategies/vite.ts
+import { addVitePlugin } from "magicast/helpers";
+var ViteStrategy = class {
+  name = "Vite";
+  supports(tool) {
+    return tool === "vite";
+  }
+  inject({ mod, detection }) {
+    addVitePlugin(mod, {
+      from: "@inspecto-dev/plugin",
+      constructor: "inspecto",
+      imported: "vitePlugin"
+    });
+  }
+  getManualInstructions(detection, reason) {
+    return [
+      `import { vitePlugin as inspecto } from '@inspecto-dev/plugin'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  process.env.NODE_ENV !== 'production' && inspecto(),`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`
+    ];
+  }
+};
+
+// src/inject/strategies/webpack.ts
+var WebpackStrategy = class {
+  name = "Webpack";
+  supports(tool) {
+    return tool === "webpack";
+  }
+  inject(options) {
+    throw new Error("Webpack requires manual plugin configuration");
+  }
+  getManualInstructions(detection, reason) {
+    const importPkg = detection.isLegacyWebpack ? "@inspecto-dev/plugin/legacy/webpack4" : "@inspecto-dev/plugin";
+    const pluginName = detection.isLegacyWebpack ? "webpack4Plugin" : "webpackPlugin";
+    const pluginCall = detection.isLegacyWebpack ? `process.env.NODE_ENV !== 'production' && inspecto({
+      pathType: 'absolute',
+      escapeTags: ['Transition', 'AnimatePresence'],
+    })` : `process.env.NODE_ENV !== 'production' && inspecto()`;
+    return [
+      `import { ${pluginName} as inspecto } from '${importPkg}'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  ${pluginCall},`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`
+    ];
+  }
+};
+
+// src/inject/strategies/rspack.ts
+var RspackStrategy = class {
+  name = "Rspack";
+  supports(tool) {
+    return tool === "rspack";
+  }
+  inject(options) {
+    throw new Error("Rspack requires manual plugin configuration");
+  }
+  getManualInstructions(detection, reason) {
+    const importPkg = detection.isLegacyRspack ? "@inspecto-dev/plugin/legacy/rspack" : "@inspecto-dev/plugin";
+    const pluginCall = detection.isLegacyRspack ? `process.env.NODE_ENV !== 'production' && inspecto({
+      pathType: 'absolute',
+      escapeTags: ['Transition', 'AnimatePresence'],
+    })` : `process.env.NODE_ENV !== 'production' && inspecto()`;
+    return [
+      `import { rspackPlugin as inspecto } from '${importPkg}'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  ${pluginCall},`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`
+    ];
+  }
+};
+
+// src/inject/strategies/rsbuild.ts
+var RsbuildStrategy = class {
+  name = "Rsbuild";
+  supports(tool) {
+    return tool === "rsbuild";
+  }
+  inject(options) {
+    throw new Error("Rsbuild requires manual plugin configuration due to nested structure");
+  }
+  getManualInstructions(detection, reason) {
+    return [
+      `import { rspackPlugin as inspecto } from '@inspecto-dev/plugin'`,
+      "",
+      "// Add to tools.rspack:",
+      `tools: {`,
+      `  rspack: {`,
+      `    plugins: [`,
+      `      process.env.NODE_ENV !== 'production' && inspecto(),`,
+      `    ]`,
+      `  }`,
+      `}`
+    ];
+  }
+};
+
+// src/inject/strategies/esbuild.ts
+var EsbuildStrategy = class {
+  name = "esbuild";
+  supports(tool) {
+    return tool === "esbuild";
+  }
+  inject(options) {
+    throw new Error("Esbuild requires manual plugin configuration");
+  }
+  getManualInstructions(detection, reason) {
+    return [
+      `1. Update your esbuild config (${detection.configPath}):`,
+      `import { esbuildPlugin as inspecto } from '@inspecto-dev/plugin'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  process.env.NODE_ENV !== 'production' && inspecto(),`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`,
+      "",
+      "2. Initialize the client in your app entry (e.g., main.js / index.js):",
+      `import { mountInspector } from '@inspecto-dev/core'`,
+      "",
+      "// Call this before your app renders",
+      `if (process.env.NODE_ENV !== 'production') {`,
+      `  mountInspector()`,
+      `}`
+    ];
+  }
+};
+
+// src/inject/strategies/rollup.ts
+var RollupStrategy = class {
+  name = "Rollup";
+  supports(tool) {
+    return tool === "rollup";
+  }
+  inject(options) {
+    throw new Error("Rollup requires manual plugin configuration");
+  }
+  getManualInstructions(detection, reason) {
+    return [
+      `1. Update your rollup config (${detection.configPath}):`,
+      `import { rollupPlugin as inspecto } from '@inspecto-dev/plugin'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  process.env.NODE_ENV !== 'production' && inspecto(),`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`,
+      "",
+      "2. Initialize the client in your app entry (e.g., main.js / index.js):",
+      `import { mountInspector } from '@inspecto-dev/core'`,
+      "",
+      "// Call this before your app renders",
+      `if (process.env.NODE_ENV !== 'production') {`,
+      `  mountInspector()`,
+      `}`
+    ];
+  }
+};
+
+// src/inject/strategies/index.ts
+var STRATEGIES = [
+  new ViteStrategy(),
+  new WebpackStrategy(),
+  new RspackStrategy(),
+  new RsbuildStrategy(),
+  new EsbuildStrategy(),
+  new RollupStrategy()
+];
+
+// src/inject/ast-injector.ts
+function printManualInstructions(strategy, detection, reason, quiet = false) {
+  if (quiet) return;
+  log.warn(`Could not automatically configure ${detection.configPath}`);
+  log.hint(`(reason: ${reason})`);
+  log.blank();
+  log.hint("Please add the following manually:");
+  if (strategy) {
+    const instructions = strategy.getManualInstructions(detection, reason);
+    log.copyableCodeBlock(instructions);
+  } else {
+    log.error(`Unsupported build tool: ${detection.tool}`);
+  }
+}
+function isAlreadyInjected(content) {
+  const normalized = content.replace(/\s+/g, " ");
+  const importPlugin = /import\s+(.+?)\s+from\s+['"]@inspecto-dev\/plugin['"]/g;
+  const requirePlugin = /require\(['"]@inspecto-dev\/plugin['"]\)/;
+  const legacyImport = /import\s+.*ai-dev-inspector/.test(normalized);
+  const legacyRequire = /require\(['"]ai-dev-inspector['"]\)/.test(normalized);
+  if (legacyImport || legacyRequire || requirePlugin.test(normalized)) return true;
+  let match;
+  importPlugin.lastIndex = 0;
+  while (match = importPlugin.exec(normalized)) {
+    const importClause = match[1] || "";
+    if (/inspecto/.test(importClause) || /vitePlugin/.test(importClause)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function injectPlugin(root, detection, dryRun, quiet = false) {
+  const configPath = path3.join(root, detection.configPath);
+  const mutations = [];
+  const strategy = STRATEGIES.find((s) => s.supports(detection.tool));
+  const content = await readFile(configPath);
+  if (!content) {
+    printManualInstructions(strategy, detection, "config file not readable", quiet);
+    return { success: false, mutations, failureReason: "config file not readable" };
+  }
+  if (isAlreadyInjected(content)) {
+    if (!quiet) {
+      log.success(`Plugin already configured in ${detection.configPath} (skipped)`);
+    }
+    mutations.push({
+      type: "file_modified",
+      path: detection.configPath,
+      description: "Previously configured inspecto() plugin"
+    });
+    return { success: true, mutations };
+  }
+  if (!strategy) {
+    printManualInstructions(
+      strategy,
+      detection,
+      `No injection strategy found for ${detection.tool}`,
+      quiet
+    );
+    return { success: false, mutations, failureReason: "No strategy found" };
+  }
+  if (dryRun) {
+    if (!quiet) {
+      log.dryRun(`Would automatically configure plugin in ${detection.configPath}`);
+    }
+    return { success: true, mutations: [] };
+  }
+  try {
+    const mod = await loadFile(configPath);
+    strategy.inject({
+      mod,
+      detection
+    });
+    await writeAstFile(mod, configPath);
+    mutations.push({
+      type: "file_modified",
+      path: detection.configPath,
+      description: "Automatically configured inspecto() plugin"
+    });
+    if (!quiet) {
+      log.success(`Configured plugin in ${detection.configPath}`);
+    }
+    return { success: true, mutations };
+  } catch (err) {
+    printManualInstructions(
+      strategy,
+      detection,
+      `Automatic configuration unavailable: ${err instanceof Error ? err.message : String(err)}`,
+      quiet
+    );
+    return {
+      success: false,
+      mutations,
+      failureReason: "Automatic configuration unavailable"
+    };
+  }
+}
+
+// src/utils/exec.ts
+import { execFile, exec as execCb } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var execAsync = promisify(execCb);
+async function run(command, args, cwd) {
+  const result = await execFileAsync(command, args, {
+    cwd,
+    timeout: 6e4,
+    env: { ...process.env }
+  });
+  return { stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+async function shell(command, cwd) {
+  const result = await execAsync(command, {
+    cwd,
+    timeout: 6e4,
+    env: { ...process.env }
+  });
+  return { stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+async function which(bin) {
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    await run(cmd, [bin]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/inject/extension.ts
+var EXTENSION_ID = "inspecto.inspecto";
+var VSCODE_PATHS = {
+  darwin: [
+    "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
+    "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code-insiders",
+    `${process.env.HOME}/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code`
+  ],
+  linux: ["/usr/bin/code", "/usr/share/code/bin/code", "/snap/bin/code", "/usr/bin/code-insiders"],
+  win32: [
+    `${process.env.LOCALAPPDATA}\\Programs\\Microsoft VS Code\\bin\\code.cmd`,
+    `${process.env.LOCALAPPDATA}\\Programs\\Microsoft VS Code Insiders\\bin\\code-insiders.cmd`,
+    `${process.env.PROGRAMFILES}\\Microsoft VS Code\\bin\\code.cmd`
+  ]
+};
+async function findVSCodeBinary() {
+  const platform = process.platform;
+  const candidates = VSCODE_PATHS[platform] || [];
+  for (const candidate of candidates) {
+    if (await exists(candidate)) {
+      return candidate;
+    }
+  }
+  if (await which("code-insiders")) {
+    return "code-insiders";
+  }
+  return null;
+}
+async function tryOpenURI(uri) {
+  try {
+    const platform = process.platform;
+    if (platform === "win32") {
+      await shell(`cmd /c start "" "${uri}"`);
+    } else {
+      const openCmd = platform === "darwin" ? "open" : "xdg-open";
+      await shell(`${openCmd} "${uri}"`);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installExtension(dryRun, ide, quiet = false) {
+  if (dryRun) {
+    if (!quiet) {
+      log.dryRun("Would attempt to install VS Code extension");
+    }
+    return null;
+  }
+  const isVSCode = !ide || ide === "vscode";
+  if (isVSCode) {
+    if (await which("code")) {
+      try {
+        await run("code", ["--install-extension", EXTENSION_ID]);
+        if (!quiet) {
+          log.success("VS Code extension installed via CLI");
+        }
+        return { type: "extension_installed", id: EXTENSION_ID };
+      } catch {
+      }
+    }
+    const codePath = await findVSCodeBinary();
+    if (codePath) {
+      try {
+        await run(codePath, ["--install-extension", EXTENSION_ID]);
+        if (!quiet) {
+          log.success("VS Code extension installed via binary path");
+          log.info(
+            'Tip: Add "code" to your PATH to help Inspecto detect other AI tools in the future'
+          );
+        }
+        return { type: "extension_installed", id: EXTENSION_ID };
+      } catch {
+      }
+    }
+    const uri = `vscode:extension/${EXTENSION_ID}`;
+    if (await tryOpenURI(uri)) {
+      if (!quiet) {
+        log.warn("Opened extension page in VS Code");
+        log.hint('Please click "Install" in the opened VS Code window to complete setup.');
+      }
+      return { type: "extension_installed", id: EXTENSION_ID, manual_action_required: true };
+    }
+    if (!quiet) {
+      log.warn("Could not auto-install VS Code extension");
+      log.hint("Please install it manually to enable Inspector features:");
+      log.hint("  1. Open VS Code");
+      log.hint("  2. Press Ctrl+Shift+X (or Cmd+Shift+X)");
+      log.hint('  3. Search for "Inspecto"');
+      log.hint(`  Or visit: https://marketplace.visualstudio.com/items?itemName=${EXTENSION_ID}`);
+    }
+    return null;
+  }
+  if (!quiet) {
+    log.warn(`Could not auto-install extension for ${ide}`);
+    log.hint("Please install it manually to enable Inspector features:");
+    log.hint(
+      "  1. Download the latest .vsix file (Open VSX: https://open-vsx.org/extension/inspecto/inspecto)"
+    );
+    log.hint(`  2. Open ${ide}`);
+    log.hint("  3. Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P)");
+    log.hint('  4. Type and select "Extensions: Install from VSIX..."');
+    log.hint("  5. Select the downloaded .vsix file");
+  }
+  return null;
+}
+async function isExtensionInstalled() {
+  try {
+    if (await which("code")) {
+      const { stdout } = await run("code", ["--list-extensions"]);
+      return stdout.toLowerCase().includes(EXTENSION_ID);
+    }
+    const codePath = await findVSCodeBinary();
+    if (codePath) {
+      const { stdout } = await run(codePath, ["--list-extensions"]);
+      return stdout.toLowerCase().includes(EXTENSION_ID);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// src/inject/gitignore.ts
+import path4 from "path";
+var DEFAULT_RULES = [".inspecto/install.lock", ".inspecto/cache.json", ".inspecto/*.local.json"];
+var SHARED_RULES = [".inspecto/install.lock", ".inspecto/cache.json", ".inspecto/*.local.json"];
+async function updateGitignore(root, shared, dryRun, quiet = false) {
+  const gitignorePath = path4.join(root, ".gitignore");
+  let content = await readFile(gitignorePath) ?? "";
+  const desiredRules = shared ? SHARED_RULES : DEFAULT_RULES;
+  const hasGlobalRule = content.match(/^\.inspecto\/\s*$/m) !== null;
+  if (hasGlobalRule) {
+    content = content.replace(/^\.inspecto\/\s*$/gm, SHARED_RULES.join("\n"));
+    if (!dryRun) {
+      await writeFile(gitignorePath, content);
+    }
+    if (!quiet) {
+      log.success("Updated .gitignore: .inspecto/ is no longer fully ignored");
+    }
+    return;
+  }
+  const missingRules = desiredRules.filter((rule) => !content.includes(rule));
+  if (missingRules.length === 0) {
+    return;
+  }
+  const section = "\n# Inspecto\n" + missingRules.join("\n") + "\n";
+  content = content.trimEnd() + "\n" + section;
+  if (dryRun) {
+    if (!quiet) {
+      log.dryRun(`Would update .gitignore with: ${missingRules.join(", ")}`);
+    }
+  } else {
+    await writeFile(gitignorePath, content);
+    if (!quiet) {
+      log.success("Updated .gitignore");
+    }
+  }
+}
+async function cleanGitignore(root) {
+  const gitignorePath = path4.join(root, ".gitignore");
+  const content = await readFile(gitignorePath);
+  if (!content) return;
+  const cleaned = content.replace(/^# Inspecto\s*$/m, "").replace(/^\.inspecto\/?\s*$/gm, "").replace(/^\.inspecto\/install\.lock\s*$/gm, "").replace(/^\.inspecto\/cache\.json\s*$/gm, "").replace(/^\.inspecto\/\*\.local\.json\s*$/gm, "").replace(/\n{3,}/g, "\n\n");
+  await writeFile(gitignorePath, cleaned);
+}
+
+// src/onboarding/apply.ts
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function resolveRuntimePackages() {
+  const devRepo = process.env.INSPECTO_DEV_REPO;
+  if (!devRepo) {
+    return {
+      installSpec: "@inspecto-dev/plugin @inspecto-dev/core",
+      installedDependencyNames: ["@inspecto-dev/plugin", "@inspecto-dev/core"]
+    };
+  }
+  const normalizedRepo = path5.resolve(devRepo);
+  return {
+    installSpec: [
+      shellQuote(path5.join(normalizedRepo, "packages/plugin")),
+      shellQuote(path5.join(normalizedRepo, "packages/core"))
+    ].join(" "),
+    installedDependencyNames: ["@inspecto-dev/plugin", "@inspecto-dev/core"]
+  };
+}
+function resultStatus(nextSteps) {
+  return nextSteps.length > 0 ? "warning" : "ok";
+}
+function manualPlanSteps(plan2) {
+  return [
+    ...plan2.blockers.map((blocker) => blocker.message),
+    ...plan2.actions.filter((action) => action.type === "manual_step").map((action) => action.description)
+  ];
+}
+async function applyOnboardingPlan(input) {
+  return applyOnboardingPlanInternal(input);
+}
+function createReporter(quiet = false) {
+  if (quiet) {
+    return {
+      warn() {
+      },
+      success() {
+      },
+      error() {
+      },
+      hint() {
+      },
+      dryRun() {
+      }
+    };
+  }
+  return {
+    warn(text) {
+      log.warn(text);
+    },
+    success(text) {
+      log.success(text);
+    },
+    error(text) {
+      log.error(text);
+    },
+    hint(text) {
+      log.hint(text);
+    },
+    dryRun(text) {
+      log.dryRun(text);
+    }
+  };
+}
+function createSpinner(text, quiet = false) {
+  if (quiet) {
+    return {
+      start() {
+      },
+      succeed() {
+      },
+      fail() {
+      }
+    };
+  }
+  const spinner = ora(text);
+  return {
+    start() {
+      spinner.start();
+    },
+    succeed(successText) {
+      spinner.succeed(successText);
+    },
+    fail(failureText) {
+      spinner.fail(failureText);
+    }
+  };
+}
+async function applyOnboardingPlanInternal(input) {
+  const reporter = createReporter(input.options.quiet);
+  if (input.plan && input.plan.strategy !== "supported" && !input.allowManualPlanApply) {
+    return {
+      status: input.plan.status,
+      mutations: [],
+      postInstall: {
+        installFailed: false,
+        injectionFailed: false,
+        manualExtensionInstallNeeded: false,
+        nextSteps: manualPlanSteps(input.plan)
+      }
+    };
+  }
+  const mutations = [];
+  const settingsDir = path5.join(input.projectRoot, ".inspecto");
+  const settingsFileName = input.options.shared ? "settings.json" : "settings.local.json";
+  const promptsFileName = input.options.shared ? "prompts.json" : "prompts.local.json";
+  const settingsPath = path5.join(settingsDir, settingsFileName);
+  const promptsPath = path5.join(settingsDir, promptsFileName);
+  const runtimePackages = resolveRuntimePackages();
+  const installCmd = getInstallCommand(input.packageManager, runtimePackages.installSpec);
+  const nextSteps = [];
+  let installFailed = false;
+  if (input.options.skipInstall) {
+    reporter.warn("Skipping dependency installation (--skip-install)");
+  } else if (input.options.dryRun) {
+    reporter.dryRun(`Would run: ${installCmd}`);
+  } else {
+    const spinner = createSpinner(
+      `Installing devDependencies via: ${installCmd}`,
+      input.options.quiet
+    );
+    try {
+      spinner.start();
+      await shell(installCmd, input.projectRoot);
+      spinner.succeed("Dependencies installed successfully");
+      reporter.success("Installed @inspecto-dev/plugin and @inspecto-dev/core as devDependencies");
+      for (const name of runtimePackages.installedDependencyNames) {
+        mutations.push({ type: "dependency_added", name, dev: true });
+      }
+    } catch (error) {
+      spinner.fail("Dependency installation failed");
+      installFailed = true;
+      reporter.error(`Failed to install dependency: ${error?.message || "Unknown error"}`);
+      reporter.hint(`Run manually in ${input.projectRoot}: ${installCmd}`);
+      reporter.hint(
+        "Setup will continue without dependencies, but Inspecto may not run until installation succeeds."
+      );
+    }
+  }
+  let injectionFailed = Boolean(input.injectionSkippedRequiresManualConfig);
+  for (const target of input.supportedBuildTargets) {
+    const result = await injectPlugin(
+      input.repoRoot,
+      target,
+      input.options.dryRun,
+      input.options.quiet ?? false
+    );
+    if (result.success) {
+      mutations.push(...result.mutations);
+    } else {
+      injectionFailed = true;
+    }
+  }
+  if (await exists(settingsPath)) {
+    const existingSettings = await readJSON(settingsPath);
+    if (existingSettings === null) {
+      reporter.warn(`.inspecto/${settingsFileName} exists but contains invalid JSON`);
+      reporter.hint("Please fix the syntax errors manually, or delete it and re-run init");
+      nextSteps.push(`Fix .inspecto/${settingsFileName} or delete it and rerun Inspecto setup.`);
+    } else {
+      reporter.success(`.inspecto/${settingsFileName} already exists (skipped)`);
+    }
+  } else {
+    const defaultSettings = {};
+    if (input.selectedIDE?.supported) {
+      defaultSettings.ide = input.selectedIDE.ide.toLowerCase() === "vscode" ? "vscode" : input.selectedIDE.ide.toLowerCase();
+    }
+    if (input.providerDefault) {
+      defaultSettings["provider.default"] = input.providerDefault;
+    }
+    if (input.options.dryRun) {
+      reporter.dryRun(`Would create .inspecto/${settingsFileName}`);
+    } else {
+      await writeJSON(settingsPath, defaultSettings);
+      reporter.success(`Created .inspecto/${settingsFileName}`);
+      mutations.push({ type: "file_created", path: `.inspecto/${settingsFileName}` });
+    }
+  }
+  if (await exists(promptsPath)) {
+    reporter.success(`.inspecto/${promptsFileName} already exists (skipped)`);
+  } else if (input.options.dryRun) {
+    reporter.dryRun(`Would create .inspecto/${promptsFileName}`);
+  } else {
+    await writeJSON(promptsPath, []);
+    reporter.success(`Created .inspecto/${promptsFileName}`);
+    mutations.push({ type: "file_created", path: `.inspecto/${promptsFileName}` });
+  }
+  if (!input.options.dryRun) {
+    await updateGitignore(
+      input.projectRoot,
+      input.options.shared,
+      input.options.dryRun,
+      input.options.quiet ?? false
+    );
+    mutations.push({
+      type: "file_modified",
+      path: ".gitignore",
+      description: "Appended .inspecto/ ignore rules"
+    });
+  } else {
+    reporter.dryRun("Would update .gitignore");
+  }
+  if (!input.options.dryRun && mutations.length > 0) {
+    const lock = {
+      version: "1.0.0",
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      mutations
+    };
+    await writeJSON(path5.join(settingsDir, "install.lock"), lock);
+  }
+  const shouldInstallExt = !input.options.noExtension && (!input.selectedIDE || input.selectedIDE.supported);
+  let manualExtensionInstallNeeded = false;
+  if (input.options.noExtension) {
+    reporter.warn("Skipping IDE extension (--no-extension)");
+  } else if (shouldInstallExt) {
+    const extMutation = await installExtension(
+      input.options.dryRun,
+      input.selectedIDE?.ide,
+      input.options.quiet ?? false
+    );
+    if (extMutation && !input.options.dryRun) {
+      mutations.push(extMutation);
+      if (extMutation.manual_action_required) {
+        manualExtensionInstallNeeded = true;
+      }
+      const lockPath = path5.join(settingsDir, "install.lock");
+      const lock = await readJSON(lockPath);
+      if (lock) {
+        lock.mutations = mutations;
+        await writeJSON(lockPath, lock);
+      }
+    } else if (extMutation === null && !input.options.dryRun) {
+      manualExtensionInstallNeeded = true;
+    }
+  }
+  if (!input.options.dryRun) {
+    if (installFailed) {
+      nextSteps.push(`Install dependencies manually in ${input.projectRoot}: ${installCmd}`);
+    }
+    if (injectionFailed) {
+      nextSteps.push(
+        "Plugin injection skipped. Follow manual instructions printed above to update your config."
+      );
+    }
+    if (manualExtensionInstallNeeded) {
+      nextSteps.push("Install the Inspecto IDE extension manually");
+    }
+    if (input.manualConfigRequiredFor === "Nuxt") {
+      nextSteps.push(
+        "Nuxt detected\u2014please follow the Nuxt instructions printed above to finish setup."
+      );
+    } else if (input.manualConfigRequiredFor === "Next.js") {
+      nextSteps.push(
+        "Next.js detected\u2014please follow the Next.js instructions printed above to finish setup."
+      );
+    }
+  }
+  return {
+    status: resultStatus(nextSteps),
+    mutations,
+    postInstall: {
+      installFailed,
+      injectionFailed,
+      manualExtensionInstallNeeded,
+      nextSteps
+    }
+  };
+}
+
+// src/detect/build-tool.ts
+import path6 from "path";
+import fs2 from "fs/promises";
+import { createRequire } from "module";
+function isPackageResolvable(pkgName, root) {
+  try {
+    const require2 = createRequire(path6.join(root, "package.json"));
+    try {
+      require2.resolve(`${pkgName}/package.json`, { paths: [root] });
+      return true;
+    } catch {
+      require2.resolve(pkgName, { paths: [root] });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+async function getResolvedPackageVersion(pkgName, root) {
+  try {
+    const require2 = createRequire(path6.join(root, "package.json"));
+    const pkgJsonPath = require2.resolve(`${pkgName}/package.json`, { paths: [root] });
+    const pkg = await readJSON(pkgJsonPath);
+    return pkg?.version || null;
+  } catch {
+    return null;
+  }
+}
+var SUPPORTED_PATTERNS = [
+  {
+    tool: "vite",
+    files: [
+      "vite.config.ts",
+      "vite.config.js",
+      "vite.config.mts",
+      "vite.config.mjs",
+      "vite.config.cjs",
+      "vite.config.cts"
+    ],
+    label: "Vite"
+  },
+  {
+    tool: "rspack",
+    files: ["rspack.config.js", "rspack.config.ts", "rspack.config.mjs"],
+    label: "Rspack"
+  },
+  {
+    tool: "rsbuild",
+    files: ["rsbuild.config.js", "rsbuild.config.ts", "rsbuild.config.mjs"],
+    label: "Rsbuild"
+  },
+  {
+    tool: "webpack",
+    files: ["webpack.config.js", "webpack.config.ts", "webpack.config.mjs", "webpack.config.cjs"],
+    label: "Webpack"
+  },
+  {
+    tool: "esbuild",
+    files: ["esbuild.config.js", "esbuild.config.ts", "esbuild.config.mjs", "build.js", "build.ts"],
+    label: "esbuild"
+  },
+  {
+    tool: "rollup",
+    files: ["rollup.config.js", "rollup.config.ts", "rollup.config.mjs"],
+    label: "Rollup"
+  }
+];
+var UNSUPPORTED_META = [
+  { name: "Next.js", dep: "next", files: ["next.config.mjs", "next.config.js", "next.config.ts"] },
+  { name: "Nuxt", dep: "nuxt", files: ["nuxt.config.ts", "nuxt.config.js"] },
+  { name: "Remix", dep: "@remix-run/dev", files: ["remix.config.js", "remix.config.ts"] },
+  { name: "Astro", dep: "astro", files: ["astro.config.mjs", "astro.config.ts"] },
+  { name: "SvelteKit", dep: "@sveltejs/kit", files: ["svelte.config.js", "svelte.config.ts"] }
+];
+function normalizeRelativePath(root, filePath) {
+  const relative = path6.relative(root, filePath);
+  const normalized = relative.split(path6.sep).join("/");
+  return normalized || path6.basename(filePath);
+}
+function createTargets(root, packagePaths) {
+  if (!packagePaths || packagePaths.length === 0) {
+    return [{ packagePath: "", absolutePath: root }];
+  }
+  return packagePaths.map((pkg) => ({
+    packagePath: pkg,
+    absolutePath: pkg ? path6.join(root, pkg) : root
+  }));
+}
+async function getWorkspacePackagePatterns(root) {
+  const pkg = await readJSON(
+    path6.join(root, "package.json")
+  );
+  const workspaces = pkg?.workspaces;
+  if (Array.isArray(workspaces)) {
+    return workspaces;
+  }
+  if (workspaces && Array.isArray(workspaces.packages)) {
+    return workspaces.packages;
+  }
+  const pnpmWorkspace = await readFile(path6.join(root, "pnpm-workspace.yaml"));
+  if (!pnpmWorkspace) {
+    return [];
+  }
+  const patterns = [];
+  for (const line of pnpmWorkspace.split("\n")) {
+    const match = line.match(/^\s*-\s*['"]?([^'"]+)['"]?\s*$/);
+    if (match?.[1]) {
+      patterns.push(match[1]);
+    }
+  }
+  return patterns;
+}
+async function expandWorkspacePattern(root, pattern) {
+  const normalized = pattern.replace(/\\/g, "/").replace(/\/$/, "");
+  if (!normalized || normalized.startsWith("!")) {
+    return [];
+  }
+  if (!normalized.includes("*")) {
+    return await exists(path6.join(root, normalized)) ? [normalized] : [];
+  }
+  const starIndex = normalized.indexOf("*");
+  const baseDir = normalized.slice(0, starIndex).replace(/\/$/, "");
+  const suffix = normalized.slice(starIndex + 1);
+  if (suffix && suffix !== "") {
+    return [];
+  }
+  const absoluteBaseDir = path6.join(root, baseDir);
+  if (!await exists(absoluteBaseDir)) {
+    return [];
+  }
+  try {
+    const entries = await fs2.readdir(absoluteBaseDir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => path6.posix.join(baseDir, entry.name));
+  } catch {
+    return [];
+  }
+}
+async function detectWorkspaceTargets(root) {
+  const patterns = await getWorkspacePackagePatterns(root);
+  if (patterns.length === 0) {
+    return [];
+  }
+  const packagePaths = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const expanded = await expandWorkspacePattern(root, pattern);
+    for (const packagePath of expanded) {
+      packagePaths.add(packagePath);
+    }
+  }
+  return Array.from(packagePaths).map((packagePath) => ({
+    packagePath,
+    absolutePath: path6.join(root, packagePath)
+  }));
+}
+async function detectBuildTools(root, packagePaths) {
+  const supported = [];
+  const unsupported = /* @__PURE__ */ new Set();
+  const explicitTargets = createTargets(root, packagePaths);
+  const workspaceTargets = !packagePaths || packagePaths.length === 0 ? await detectWorkspaceTargets(root) : [];
+  const targets = workspaceTargets.length > 0 ? workspaceTargets : explicitTargets;
+  for (const target of targets) {
+    const pkg = await readJSON(path6.join(target.absolutePath, "package.json"));
+    const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+    const scripts = pkg?.scripts || {};
+    const supportedChecks = SUPPORTED_PATTERNS.map(
+      (pattern) => detectPattern({
+        pattern,
+        workspaceRoot: root,
+        targetRoot: target.absolutePath,
+        packagePath: target.packagePath,
+        allDeps,
+        scripts
+      })
+    );
+    const supportedResults = await Promise.all(supportedChecks);
+    for (const result of supportedResults) {
+      if (result) {
+        supported.push(result);
+      }
+    }
+    const unsupportedChecks = UNSUPPORTED_META.map(async (meta) => {
+      if (!(meta.dep in allDeps)) return null;
+      for (const file of meta.files) {
+        if (await exists(path6.join(target.absolutePath, file))) {
+          return meta.name;
+        }
+      }
+      return null;
+    });
+    const unsupportedResults = await Promise.all(unsupportedChecks);
+    for (const result of unsupportedResults) {
+      if (result) {
+        unsupported.add(result);
+      }
+    }
+  }
+  return { supported, unsupported: Array.from(unsupported) };
+}
+async function detectPattern({
+  pattern,
+  workspaceRoot,
+  targetRoot,
+  packagePath,
+  allDeps,
+  scripts
+}) {
+  let hasDep;
+  let resolvedVersion = null;
+  if (pattern.tool === "rspack") {
+    const depName = allDeps["@rspack/cli"] ? "@rspack/cli" : "@rspack/core";
+    hasDep = !!allDeps["@rspack/cli"] || !!allDeps["@rspack/core"] || isPackageResolvable("@rspack/core", targetRoot);
+    if (hasDep) {
+      resolvedVersion = allDeps[depName] || await getResolvedPackageVersion("@rspack/core", targetRoot);
+    }
+  } else if (pattern.tool === "webpack") {
+    const depName = allDeps["webpack"] ? "webpack" : "webpack-cli";
+    hasDep = !!allDeps["webpack"] || !!allDeps["webpack-cli"] || isPackageResolvable("webpack", targetRoot);
+    if (hasDep) {
+      resolvedVersion = allDeps[depName] || await getResolvedPackageVersion("webpack", targetRoot);
+    }
+  } else if (pattern.tool === "rsbuild") {
+    hasDep = !!allDeps["@rsbuild/core"] || isPackageResolvable("@rsbuild/core", targetRoot);
+  } else {
+    hasDep = !!allDeps[pattern.tool] || isPackageResolvable(pattern.tool, targetRoot);
+  }
+  let detectedFile = "";
+  let inferredFromScripts = false;
+  if (pattern.tool === "esbuild" && !hasDep) {
+    return null;
+  }
+  for (const file of pattern.files) {
+    if (await exists(path6.join(targetRoot, file))) {
+      detectedFile = file;
+      break;
+    }
+  }
+  if (hasDep && !detectedFile && (pattern.tool === "esbuild" || pattern.tool === "rollup" || pattern.tool === "webpack" || pattern.tool === "rspack" || pattern.tool === "rsbuild")) {
+    for (const cmd of Object.values(scripts)) {
+      if (cmd.includes("node ")) {
+        const match = cmd.match(/node\s+([^\s]+\.(js|mjs|cjs|ts))/);
+        if (match && match[1]) {
+          if (await exists(path6.join(targetRoot, match[1]))) {
+            if (cmd.includes(pattern.tool) || match[1].includes(pattern.tool)) {
+              detectedFile = match[1];
+              break;
+            }
+          }
+        }
+      } else if (cmd.includes(`${pattern.tool} `)) {
+        if (pattern.tool === "webpack" || pattern.tool === "rspack") {
+          const configMatch = cmd.match(/--config\s+([^\s]+)/);
+          if (configMatch && configMatch[1]) {
+            if (await exists(path6.join(targetRoot, configMatch[1]))) {
+              detectedFile = configMatch[1];
+              break;
+            }
+          }
+        }
+        if (!detectedFile) {
+          inferredFromScripts = true;
+          detectedFile = "package.json (scripts)";
+          break;
+        }
+      }
+    }
+  }
+  if (!detectedFile) {
+    if (hasDep && (pattern.tool === "rollup" || pattern.tool === "webpack" || pattern.tool === "rspack" || pattern.tool === "esbuild")) {
+      return {
+        tool: pattern.tool,
+        configPath: "package.json (dependency)",
+        label: `${pattern.label} (detected via dependency)`,
+        packagePath: packagePath || void 0
+      };
+    }
+    return null;
+  }
+  let isLegacyRspack = false;
+  let isLegacyWebpack = false;
+  if (pattern.tool === "rspack") {
+    const version = resolvedVersion;
+    if (version && (version.includes("0.3.") || version.includes("0.2.") || version.includes("0.1."))) {
+      isLegacyRspack = true;
+    }
+  } else if (pattern.tool === "webpack") {
+    const version = resolvedVersion;
+    if (version && version.includes("^4") || version?.startsWith("4.")) {
+      isLegacyWebpack = true;
+    }
+  }
+  const absoluteConfig = path6.join(targetRoot, detectedFile);
+  const relativeConfig = normalizeRelativePath(workspaceRoot, absoluteConfig);
+  return {
+    tool: pattern.tool,
+    configPath: relativeConfig,
+    label: `${pattern.label} (${relativeConfig})${isLegacyRspack ? " [Legacy]" : ""}${isLegacyWebpack ? " [Webpack 4]" : ""}${inferredFromScripts ? " [Scripts Detected]" : ""}`,
+    isLegacyRspack,
+    isLegacyWebpack,
+    packagePath: packagePath || void 0
+  };
+}
+function resolveInjectionTarget(detections) {
+  if (detections.length === 0) return null;
+  if (detections.length === 1) return detections[0];
+  return "ambiguous";
+}
+
+// src/detect/framework.ts
+import path7 from "path";
+import { createRequire as createRequire2 } from "module";
+var META_FRAMEWORK_MAP = {
+  next: "react",
+  nuxt: "vue",
+  "@remix-run/react": "react",
+  "@remix-run/dev": "react",
+  "@vue/nuxt": "vue",
+  "vite-plugin-vue": "vue",
+  "@vitejs/plugin-vue": "vue",
+  "@vitejs/plugin-react": "react",
+  "@vitejs/plugin-react-swc": "react"
+};
+var SUPPORTED_FRAMEWORKS = [
+  { framework: "react", deps: ["react", "react-dom"] },
+  { framework: "vue", deps: ["vue"] }
+];
+var UNSUPPORTED_FRAMEWORKS = [
+  { name: "Solid", dep: "solid-js" },
+  { name: "Svelte", dep: "svelte" },
+  { name: "Angular", dep: "@angular/core" },
+  { name: "Preact", dep: "preact" },
+  { name: "Lit", dep: "lit" }
+];
+function isPackageResolvable2(pkgName, root) {
+  try {
+    const require2 = createRequire2(path7.join(root, "package.json"));
+    try {
+      require2.resolve(`${pkgName}/package.json`, { paths: [root] });
+      return true;
+    } catch {
+      require2.resolve(pkgName, { paths: [root] });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+async function detectFrameworks(root) {
+  const pkg = await readJSON(path7.join(root, "package.json"));
+  const allDeps = {
+    ...pkg?.dependencies || {},
+    ...pkg?.devDependencies || {},
+    ...pkg?.peerDependencies || {}
+  };
+  const supportedSet = /* @__PURE__ */ new Set();
+  const unsupported = [];
+  const isTest = root.includes("/mock/root");
+  for (const [metaPkg, framework] of Object.entries(META_FRAMEWORK_MAP)) {
+    if (metaPkg in allDeps || !isTest && isPackageResolvable2(metaPkg, root)) {
+      supportedSet.add(framework);
+    }
+  }
+  for (const { framework, deps } of SUPPORTED_FRAMEWORKS) {
+    if (supportedSet.has(framework)) continue;
+    for (const dep of deps) {
+      if (dep in allDeps || !isTest && isPackageResolvable2(dep, root)) {
+        supportedSet.add(framework);
+        break;
+      }
+    }
+  }
+  for (const fw of UNSUPPORTED_FRAMEWORKS) {
+    if (fw.dep in allDeps || !isTest && isPackageResolvable2(fw.dep, root)) {
+      unsupported.push(fw);
+    }
+  }
+  return {
+    supported: Array.from(supportedSet),
+    unsupported
+  };
+}
+
+// src/detect/ide.ts
+import path8 from "path";
+var SUPPORTED_IDE = "vscode";
+async function detectIDE(root) {
+  const detected = /* @__PURE__ */ new Map();
+  if (process.env.CURSOR_TRACE_DIR || process.env.CURSOR_CHANNEL) {
+    detected.set("Cursor", { ide: "cursor", supported: true });
+  }
+  if (process.env.TRAE_APP_DIR || process.env.__CFBundleIdentifier === "com.byteocean.trae" || process.env.COCO_IDE_PLUGIN_TYPE === "Trae" || process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes("trae")) {
+    detected.set("Trae", { ide: "trae", supported: true });
+  }
+  if (process.env.ZED_TERM) {
+    detected.set("Zed", { ide: "Zed", supported: false });
+  }
+  if (process.env.WINDSURF_APP_DIR || process.env.WINDSURF_CHANNEL || process.env.__CFBundleIdentifier === "com.codeium.windsurf" || process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes("windsurf")) {
+    detected.set("Windsurf", { ide: "Windsurf", supported: false });
+  }
+  const [hasTrae, hasCursor, hasVscode, hasIdea] = await Promise.all([
+    exists(path8.join(root, ".trae")),
+    exists(path8.join(root, ".cursor")),
+    exists(path8.join(root, ".vscode")),
+    exists(path8.join(root, ".idea"))
+  ]);
+  if (hasTrae && !detected.has("Trae")) {
+    detected.set("Trae", { ide: "trae", supported: true });
+  }
+  if (hasCursor && !detected.has("Cursor")) {
+    detected.set("Cursor", { ide: "cursor", supported: true });
+  }
+  if (hasVscode && !detected.has("vscode")) {
+    detected.set("vscode", { ide: SUPPORTED_IDE, supported: true });
+  }
+  if (hasIdea && !detected.has("JetBrains IDE")) {
+    detected.set("JetBrains IDE", { ide: "JetBrains IDE", supported: false });
+  }
+  if (detected.size === 0 && process.env.TERM_PROGRAM === "vscode") {
+    detected.set("vscode", { ide: SUPPORTED_IDE, supported: true });
+  }
+  return {
+    detected: Array.from(detected.values())
+  };
+}
+
+// src/detect/provider.ts
+import path9 from "path";
+var KNOWN_CLI_TOOLS = [
+  { id: "claude-code", bin: "claude", label: "Claude Code", supported: true },
+  { id: "coco", bin: "coco", label: "Trae CLI (Coco)", supported: true },
+  { id: "codex", bin: "codex", label: "Codex CLI", supported: true },
+  { id: "gemini", bin: "gemini", label: "Gemini CLI", supported: true }
+];
+var KNOWN_IDE_PLUGINS = [
+  { id: "claude-code", extId: "anthropic.claude-code", label: "Claude Code", supported: true },
+  { id: "copilot", extId: "github.copilot", label: "GitHub Copilot", supported: true },
+  { id: "codex", extId: "openai.chatgpt", label: "Codex (ChatGPT)", supported: true },
+  { id: "gemini", extId: "google.geminicodeassist", label: "Gemini Code Assist", supported: true }
+];
+async function detectProviders(root) {
+  const detectedMap = /* @__PURE__ */ new Map();
+  const cliChecks = KNOWN_CLI_TOOLS.map(async (tool) => {
+    if (await which(tool.bin)) {
+      detectedMap.set(tool.id, {
+        id: tool.id,
+        label: tool.label,
+        supported: tool.supported,
+        providerModes: ["cli"],
+        preferredMode: "cli"
+      });
+    }
+  });
+  await Promise.all(cliChecks);
+  const extensionsJsonPath = path9.join(root, ".vscode", "extensions.json");
+  let recommendedExts = [];
+  if (await exists(extensionsJsonPath)) {
+    try {
+      const extData = await readJSON(extensionsJsonPath);
+      if (extData && Array.isArray(extData.recommendations)) {
+        recommendedExts = extData.recommendations.map((e) => e.toLowerCase());
+      }
+    } catch {
+    }
+  }
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  const globalExtDir = path9.join(homeDir, ".vscode", "extensions");
+  const globalExtExists = await exists(globalExtDir);
+  let installedExtensionFolders = [];
+  if (globalExtExists) {
+    try {
+      const { readdir } = await import("fs/promises");
+      installedExtensionFolders = await readdir(globalExtDir);
+      const obsoletePath = path9.join(globalExtDir, ".obsolete");
+      if (await exists(obsoletePath)) {
+        try {
+          const obsoleteData = await readJSON(obsoletePath);
+          if (obsoleteData) {
+            const obsoleteKeys = Object.keys(obsoleteData);
+            installedExtensionFolders = installedExtensionFolders.filter((folder) => {
+              return !obsoleteKeys.includes(folder);
+            });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  for (const plugin of KNOWN_IDE_PLUGINS) {
+    let isInstalled = false;
+    if (recommendedExts.includes(plugin.extId.toLowerCase())) {
+      isInstalled = true;
+    } else if (installedExtensionFolders.some((f) => {
+      const lower = f.toLowerCase();
+      return lower === plugin.extId.toLowerCase() || lower.startsWith(plugin.extId.toLowerCase() + "-");
+    })) {
+      isInstalled = true;
+    }
+    if (isInstalled) {
+      const existing = detectedMap.get(plugin.id);
+      if (existing) {
+        existing.providerModes.push("extension");
+        existing.preferredMode = "extension";
+      } else {
+        detectedMap.set(plugin.id, {
+          id: plugin.id,
+          label: plugin.label,
+          supported: plugin.supported,
+          providerModes: ["extension"],
+          preferredMode: "extension"
+        });
+      }
+    }
+  }
+  return { detected: Array.from(detectedMap.values()) };
+}
+
+// src/onboarding/context.ts
+async function buildOnboardingContext(root) {
+  const [packageManager, buildTools, frameworks, ides, providers] = await Promise.all([
+    detectPackageManager(root),
+    detectBuildTools(root),
+    detectFrameworks(root),
+    detectIDE(root),
+    detectProviders(root)
+  ]);
+  return {
+    root,
+    packageManager,
+    buildTools: {
+      supported: buildTools.supported,
+      unsupported: buildTools.unsupported
+    },
+    frameworks: {
+      supported: frameworks.supported,
+      unsupported: frameworks.unsupported.map((item) => item.name)
+    },
+    ides: ides.detected.map(({ ide, supported }) => ({ ide, supported })),
+    providers: providers.detected.map(({ id, label, supported, preferredMode }) => ({
+      id,
+      label,
+      supported,
+      preferredMode
+    }))
+  };
+}
+
+// src/onboarding/planner.ts
+function message(code, message2) {
+  return { code, message: message2 };
+}
+function uniqueMessages(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  return messages.filter((item) => {
+    const key = `${item.code}:${item.message}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function detectionStatus(warnings, blockers) {
+  if (blockers.length > 0) return "blocked";
+  if (warnings.length > 0) return "warning";
+  return "ok";
+}
+function planStatus(warnings, blockers) {
+  if (blockers.length > 0) return "blocked";
+  if (warnings.length > 0) return "warning";
+  return "ok";
+}
+function supportedIde(context) {
+  return context.ides.find((ide) => ide.supported)?.ide;
+}
+function supportedProvider(context) {
+  return context.providers.find((provider) => provider.supported)?.id;
+}
+function buildToolBlockers(context) {
+  if (context.buildTools.unsupported.length > 0) {
+    return [
+      message(
+        "unsupported-build-tool",
+        `Detected unsupported build tool(s): ${context.buildTools.unsupported.join(", ")}`
+      )
+    ];
+  }
+  if (context.buildTools.supported.length > 0) {
+    if (context.buildTools.supported.length === 1) {
+      return [];
+    }
+    const targets = context.buildTools.supported.map((target) => target.packagePath ?? target.configPath).join(", ");
+    return [
+      message(
+        "multiple-supported-build-targets",
+        `Multiple supported build targets detected: ${targets}. Run inspecto apply from a single app/package root until explicit target selection is available.`
+      )
+    ];
+  }
+  return [message("missing-build-tool", "No supported build tool detected")];
+}
+function frameworkBlockers(context) {
+  if (context.frameworks.supported.length > 0) {
+    return [];
+  }
+  if (context.frameworks.unsupported.length > 0) {
+    return [
+      message(
+        "unsupported-framework",
+        `Detected unsupported framework(s): ${context.frameworks.unsupported.join(", ")}`
+      )
+    ];
+  }
+  return [message("missing-framework", "No supported frontend framework detected")];
+}
+function unsupportedEnvironmentWarnings(context) {
+  const warnings = [];
+  if (context.frameworks.unsupported.length > 0 && context.frameworks.supported.length > 0) {
+    warnings.push(
+      message(
+        "unsupported-framework-present",
+        `Unsupported framework(s) also detected: ${context.frameworks.unsupported.join(", ")}`
+      )
+    );
+  }
+  const unsupportedIdes = context.ides.filter((ide) => !ide.supported).map((ide) => ide.ide);
+  if (unsupportedIdes.length > 0) {
+    warnings.push(
+      message("unsupported-ide", `Unsupported IDE(s) detected: ${unsupportedIdes.join(", ")}`)
+    );
+  }
+  const unsupportedProviders = context.providers.filter((provider) => !provider.supported).map((provider) => provider.label);
+  if (unsupportedProviders.length > 0) {
+    warnings.push(
+      message(
+        "unsupported-provider",
+        `Unsupported provider(s) detected: ${unsupportedProviders.join(", ")}`
+      )
+    );
+  }
+  return warnings;
+}
+function manualBuildToolActions(context) {
+  if (context.buildTools.unsupported.length > 0) {
+    return [
+      {
+        type: "manual_step",
+        target: context.buildTools.unsupported.join(", "),
+        description: "Inspecto cannot auto-configure this build stack yet. Follow the manual setup guide for the detected framework or build tool."
+      }
+    ];
+  }
+  if (context.buildTools.supported.length > 1) {
+    const targets = context.buildTools.supported.map((target) => target.packagePath ?? target.configPath).join(", ");
+    return [
+      {
+        type: "manual_step",
+        target: targets,
+        description: "Run inspecto apply from the target app/package root. Root-level apply is blocked when multiple supported targets are detected."
+      }
+    ];
+  }
+  return [
+    {
+      type: "manual_step",
+      target: context.root,
+      description: "No supported build tool was detected. Add a supported build config before trying Inspecto again."
+    }
+  ];
+}
+function manualFrameworkActions(context) {
+  if (context.frameworks.unsupported.length > 0) {
+    return [
+      {
+        type: "manual_step",
+        target: context.frameworks.unsupported.join(", "),
+        description: "Inspecto cannot auto-configure this framework yet. Follow the manual setup guide for the detected framework."
+      }
+    ];
+  }
+  return [
+    {
+      type: "manual_step",
+      target: context.root,
+      description: "No supported frontend framework was detected. Add a supported React or Vue app before trying Inspecto again."
+    }
+  ];
+}
+async function createDetectionResult(root) {
+  const context = await buildOnboardingContext(root);
+  const warnings = uniqueMessages([...unsupportedEnvironmentWarnings(context)]);
+  const buildToolResult = buildToolBlockers(context);
+  const frameworkResult = frameworkBlockers(context);
+  const blockers = uniqueMessages([...buildToolResult, ...frameworkResult]);
+  return {
+    status: detectionStatus(warnings, blockers),
+    warnings,
+    blockers,
+    project: {
+      root: context.root,
+      packageManager: context.packageManager
+    },
+    environment: {
+      frameworks: context.frameworks.supported,
+      unsupportedFrameworks: context.frameworks.unsupported,
+      buildTools: context.buildTools.supported,
+      unsupportedBuildTools: context.buildTools.unsupported,
+      ides: context.ides,
+      providers: context.providers
+    }
+  };
+}
+function createPlanResult(context) {
+  const warnings = uniqueMessages(unsupportedEnvironmentWarnings(context));
+  const blockers = uniqueMessages([...buildToolBlockers(context), ...frameworkBlockers(context)]);
+  const actions = [];
+  let strategy = "supported";
+  if (blockers.length > 0) {
+    strategy = "manual";
+    if (context.buildTools.unsupported.length > 0 || context.buildTools.supported.length === 0 || context.buildTools.supported.length > 1) {
+      actions.push(...manualBuildToolActions(context));
+    }
+    if (frameworkBlockers(context).length > 0) {
+      actions.push(...manualFrameworkActions(context));
+    }
+  } else {
+    actions.push({
+      type: "install_dependency",
+      target: "@inspecto-dev/plugin @inspecto-dev/core",
+      description: `Install the Inspecto runtime packages with ${context.packageManager}.`
+    });
+    for (const buildTool of context.buildTools.supported) {
+      actions.push({
+        type: "modify_file",
+        target: buildTool.configPath,
+        description: `Inject the Inspecto plugin into ${buildTool.label}.`
+      });
+    }
+    const ide2 = supportedIde(context);
+    if (ide2 === "vscode") {
+      actions.push({
+        type: "install_extension",
+        target: "vscode",
+        description: "Install the Inspecto VS Code extension."
+      });
+    }
+  }
+  const defaults = {
+    shared: false,
+    extension: supportedIde(context) === "vscode"
+  };
+  const provider = supportedProvider(context);
+  if (provider) {
+    defaults.provider = provider;
+  }
+  const ide = supportedIde(context);
+  if (ide) {
+    defaults.ide = ide;
+  }
+  return {
+    status: planStatus(warnings, blockers),
+    warnings,
+    blockers,
+    strategy,
+    actions,
+    defaults
+  };
+}
+function planManualFollowUp(result) {
+  return result.actions.filter((action) => action.type === "manual_step").map((action) => action.description);
+}
+
+// src/commands/apply.ts
+function getProviderDefault(providerId, preferredMode) {
+  if (!providerId) return void 0;
+  const mode = preferredMode ?? (providerId === "coco" ? "cli" : "extension");
+  return `${providerId}.${mode}`;
+}
+function statusRank(status) {
+  switch (status) {
+    case "error":
+      return 3;
+    case "blocked":
+      return 2;
+    case "warning":
+      return 1;
+    case "ok":
+    default:
+      return 0;
+  }
+}
+function mergeStatus(planStatus2, applyStatus) {
+  return statusRank(planStatus2) >= statusRank(applyStatus) ? planStatus2 : applyStatus;
+}
+function printApplyResult(result) {
+  const manualSteps = result.postInstall.nextSteps.filter(
+    (step) => !result.plan.blockers.some((blocker) => blocker.message === step)
+  );
+  log.header("Inspecto Apply");
+  log.info(`Status: ${result.status}`);
+  log.info(`Strategy: ${result.plan.strategy}`);
+  for (const blocker of result.plan.blockers) {
+    log.error(blocker.message);
+  }
+  for (const warning of result.plan.warnings) {
+    log.warn(warning.message);
+  }
+  if (manualSteps.length > 0 || result.plan.blockers.length > 0) {
+    log.blank();
+    log.warn("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 Manual Steps Required \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    manualSteps.forEach((step) => log.error(step));
+    return;
+  }
+  if (result.plan.warnings.length > 0) {
+    return;
+  }
+  log.ready("Ready! Inspecto is set up.");
+  log.info("Next:");
+  log.hint("1. Start or restart your dev server.");
+  log.hint("2. Open your app in the browser.");
+  log.hint("3. Hold Alt + Click any element to inspect.");
+}
+async function apply(options = {}) {
+  const root = process.cwd();
+  const context = await buildOnboardingContext(root);
+  const plan2 = createPlanResult(context);
+  const selectedProvider = context.providers.find((provider) => provider.id === plan2.defaults.provider) ?? null;
+  const selectedIDE = context.ides.find((ide) => ide.ide === plan2.defaults.ide) ?? context.ides.find((ide) => ide.supported) ?? null;
+  const applyResult = await applyOnboardingPlan({
+    repoRoot: root,
+    projectRoot: root,
+    packageManager: context.packageManager,
+    supportedBuildTargets: context.buildTools.supported,
+    options: {
+      shared: options.shared ?? plan2.defaults.shared,
+      skipInstall: options.skipInstall ?? false,
+      dryRun: options.dryRun ?? false,
+      noExtension: options.noExtension ?? !plan2.defaults.extension,
+      quiet: options.json ?? false
+    },
+    selectedIDE,
+    providerDefault: getProviderDefault(plan2.defaults.provider, selectedProvider?.preferredMode),
+    plan: plan2
+  });
+  const result = {
+    ...applyResult,
+    status: mergeStatus(plan2.status, applyResult.status),
+    plan: plan2
+  };
+  return writeCommandOutput(result, options.json ?? false, printApplyResult);
+}
+
+// src/commands/detect.ts
+function printDetectionResult(result) {
+  const suppressedCodes = /* @__PURE__ */ new Set([
+    "unsupported-build-tool",
+    "unsupported-build-tool-present",
+    "unsupported-framework",
+    "unsupported-framework-present"
+  ]);
+  log.header("Inspecto Detect");
+  log.info(`Status: ${result.status}`);
+  log.info(`Root: ${result.project.root}`);
+  log.info(`Package manager: ${result.project.packageManager}`);
+  if (result.environment.frameworks.length > 0) {
+    log.success(`Supported frameworks: ${result.environment.frameworks.join(", ")}`);
+  }
+  if (result.environment.unsupportedFrameworks.length > 0) {
+    log.warn(`Unsupported frameworks: ${result.environment.unsupportedFrameworks.join(", ")}`);
+  }
+  if (result.environment.buildTools.length > 0) {
+    log.success(
+      `Supported build tools: ${result.environment.buildTools.map((tool) => tool.label).join(", ")}`
+    );
+  }
+  if (result.environment.unsupportedBuildTools.length > 0) {
+    log.warn(`Unsupported build tools: ${result.environment.unsupportedBuildTools.join(", ")}`);
+  }
+  const supportedIdes = result.environment.ides.filter((ide) => ide.supported).map((ide) => ide.ide);
+  if (supportedIdes.length > 0) {
+    log.success(`Supported IDEs: ${supportedIdes.join(", ")}`);
+  }
+  const supportedProviders = result.environment.providers.filter((provider) => provider.supported).map((provider) => provider.label);
+  if (supportedProviders.length > 0) {
+    log.success(`Supported providers: ${supportedProviders.join(", ")}`);
+  }
+  for (const blocker of result.blockers) {
+    if (suppressedCodes.has(blocker.code)) continue;
+    log.error(blocker.message);
+  }
+  for (const warning of result.warnings) {
+    if (suppressedCodes.has(warning.code)) continue;
+    log.warn(warning.message);
+  }
+}
+async function detect(json = false) {
+  const result = await createDetectionResult(process.cwd());
+  return writeCommandOutput(result, json, printDetectionResult);
+}
+
+// src/commands/init.ts
+import path10 from "path";
+
+// src/onboarding/target-resolution.ts
+function normalizePackagePath(packagePath) {
+  if (!packagePath || packagePath === ".") return "";
+  return packagePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+}
+function looksLikeAppPackage(packagePath) {
+  if (!packagePath) return true;
+  return /(^|\/)(app|apps|web|client|frontend|site)(\/|$)/i.test(packagePath);
+}
+function looksLikeAuxiliaryPackage(packagePath) {
+  return /(^|\/)(docs?|example|examples|playground|storybook|demo)(\/|$)/i.test(packagePath);
+}
+function buildCandidates(input) {
+  return input.buildTools.map((buildTool) => {
+    const packagePath = normalizePackagePath(buildTool.packagePath);
+    return {
+      packagePath,
+      configPath: buildTool.configPath,
+      buildTool: buildTool.tool,
+      frameworks: input.frameworkSupportByPackage[packagePath] ?? [],
+      automaticInjection: true
+    };
+  });
+}
+function rankCandidate(candidate) {
+  let score = 0;
+  if (candidate.frameworks.length > 0) score += 4;
+  if (candidate.automaticInjection) score += 2;
+  if (looksLikeAppPackage(candidate.packagePath)) score += 1;
+  if (looksLikeAuxiliaryPackage(candidate.packagePath)) score -= 2;
+  return score;
+}
+function rankCandidates(candidates) {
+  return candidates.map((candidate) => ({
+    candidate,
+    score: rankCandidate(candidate)
+  })).sort((left, right) => right.score - left.score);
+}
+function resolveOnboardingTarget(input) {
+  const candidates = buildCandidates(input);
+  if (candidates.length === 0) {
+    return {
+      status: "needs_selection",
+      candidates,
+      reason: "No supported targets were detected."
+    };
+  }
+  const explicitlySelected = normalizePackagePath(input.selectedPackagePath);
+  if (input.selectedPackagePath !== void 0) {
+    const selected = candidates.find((candidate) => candidate.packagePath === explicitlySelected);
+    if (selected) {
+      return {
+        status: "resolved",
+        selected,
+        candidates,
+        reason: `Using the explicitly selected target: ${selected.packagePath || "."}.`
+      };
+    }
+  }
+  if (candidates.length === 1) {
+    return {
+      status: "resolved",
+      selected: candidates[0],
+      candidates,
+      reason: "Only one supported target was detected."
+    };
+  }
+  const ranked = rankCandidates(candidates);
+  if (ranked.length > 1 && ranked[0].score === ranked[1].score) {
+    return {
+      status: "needs_selection",
+      candidates,
+      reason: "Multiple supported targets look equally plausible."
+    };
+  }
+  return {
+    status: "resolved",
+    selected: ranked[0].candidate,
+    candidates,
+    reason: `Preselected ${ranked[0].candidate.packagePath || "."} because it has the strongest supported app signal.`
+  };
+}
+
+// src/prompts.ts
+import prompts from "prompts";
+async function promptIDEChoice(detections) {
+  if (!process.stdin.isTTY) {
+    log.warn("Multiple IDEs detected but stdin is not interactive");
+    log.hint(`Using: ${detections[0].ide} (first match)`);
+    return detections[0];
+  }
+  const { choice } = await prompts({
+    type: "select",
+    name: "choice",
+    message: "Detected multiple IDEs, please choose one:",
+    choices: detections.map((d, i) => ({
+      title: `${d.ide} ${d.supported ? "(supported)" : "(unsupported/limited)"}`,
+      value: i
+    }))
+  });
+  if (choice === void 0) return null;
+  return detections[choice];
+}
+async function promptProviderChoice(detections) {
+  if (!process.stdin.isTTY) {
+    log.warn("Multiple AI tools detected but stdin is not interactive");
+    log.hint(`Using: ${detections[0].label} (first match)`);
+    return detections[0];
+  }
+  const { choice } = await prompts({
+    type: "select",
+    name: "choice",
+    message: "Detected multiple providers, please choose one:",
+    choices: detections.map((d, i) => {
+      const modeLabels = d.providerModes.map(
+        (mode) => mode === "extension" ? "VS Code Extension" : "Terminal CLI"
+      );
+      const modeStr = modeLabels.join(" & ");
+      return {
+        title: `${d.label} ${d.supported ? `(supported ${modeStr})` : "(unsupported/limited)"}`,
+        value: i
+      };
+    }).concat({ title: "Skip (configure later)", value: -1 })
+  });
+  if (choice === void 0 || choice === -1) return null;
+  return detections[choice];
+}
+async function promptConfigChoice(detections) {
+  if (!process.stdin.isTTY) {
+    log.warn("Multiple config files detected but stdin is not interactive");
+    log.hint(`Using: ${detections[0].label} (first match)`);
+    return detections[0];
+  }
+  const choices = detections.map((d, i) => ({
+    title: d.label,
+    value: i
+  }));
+  choices.push({
+    title: "Skip (I'll configure manually)",
+    value: -1
+  });
+  const { choice } = await prompts({
+    type: "select",
+    name: "choice",
+    message: "Detected multiple build tool configs, please choose one to inject:",
+    choices
+  });
+  if (choice === void 0 || choice === -1) return null;
+  return detections[choice];
+}
+async function promptMonorepoPackageChoice(detections) {
+  const uniquePackages = Array.from(
+    new Map(
+      detections.filter((d) => !!d.packagePath).map((d) => [d.packagePath, d])
+    ).values()
+  );
+  if (uniquePackages.length === 0) {
+    return null;
+  }
+  if (!process.stdin.isTTY) {
+    log.error("Monorepo root detected, but stdin is not interactive.");
+    log.hint(
+      "Re-run `inspecto init` inside a specific app directory, or pass --packages <app-path>."
+    );
+    return null;
+  }
+  const { choice } = await prompts({
+    type: "select",
+    name: "choice",
+    message: "Monorepo root detected. Choose the app to initialize:",
+    choices: uniquePackages.map((d, i) => ({
+      title: `${d.packagePath} (${d.tool})`,
+      description: d.configPath,
+      value: i
+    }))
+  });
+  if (choice === void 0) return null;
+  return uniquePackages[choice].packagePath;
+}
+async function promptUnsupportedFrameworkContinue() {
+  if (!process.stdin.isTTY) {
+    log.error("Unsupported framework detected in non-interactive environment.");
+    log.hint("Use --force to skip this check and continue anyway.");
+    return false;
+  }
+  const { confirm } = await prompts({
+    type: "confirm",
+    name: "confirm",
+    message: "Inspecto may not work properly. Do you want to continue anyway?",
+    initial: false
+  });
+  return !!confirm;
+}
+
+// src/instructions.ts
+function printNuxtManualInstructions() {
+  log.blank();
+  log.hint("Nuxt requires manual setup in the current version.");
+  log.hint("1. Update `nuxt.config.ts` to register the Inspecto Vite plugin:");
+  log.copyableCodeBlock([
+    "import { vitePlugin as inspecto } from '@inspecto-dev/plugin'",
+    "",
+    "export default defineNuxtConfig({",
+    "  vite: {",
+    "    plugins: [inspecto()],",
+    "  },",
+    "})"
+  ]);
+  log.hint("2. Create `plugins/inspecto.client.ts` to mount `@inspecto-dev/core` in development:");
+  log.copyableCodeBlock([
+    "export default defineNuxtPlugin(() => {",
+    "  if (import.meta.dev) {",
+    "    import('@inspecto-dev/core').then(({ mountInspector }) => {",
+    "      mountInspector()",
+    "    })",
+    "  }",
+    "})"
+  ]);
+  log.hint("3. Restart your Nuxt dev server after updating the config.");
+}
+function printNextJsManualInstructions() {
+  log.blank();
+  log.hint("Next.js requires manual setup in the current version.");
+  log.hint("1. Update `next.config.mjs` to register the Inspecto webpack plugin:");
+  log.copyableCodeBlock([
+    "import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'",
+    "",
+    "/** @type {import('next').NextConfig} */",
+    "const nextConfig = {",
+    "  webpack: (config, { dev, isServer }) => {",
+    "    if (dev && !isServer) {",
+    "      config.plugins.push(inspecto())",
+    "    }",
+    "    return config",
+    "  },",
+    "}",
+    "",
+    "export default nextConfig"
+  ]);
+  log.hint(
+    "2. Initialize `@inspecto-dev/core` from a client component such as `app/layout.tsx` or `pages/_app.tsx`:"
+  );
+  log.copyableCodeBlock([
+    "'use client'",
+    "",
+    "import { useEffect } from 'react'",
+    "",
+    "export default function RootLayout({ children }) {",
+    "  useEffect(() => {",
+    "    if (process.env.NODE_ENV !== 'production') {",
+    "      import('@inspecto-dev/core').then(({ mountInspector }) => {",
+    "        mountInspector({ serverUrl: 'http://127.0.0.1:5678' })",
+    "      })",
+    "    }",
+    "  }, [])",
+    "",
+    "  return <html><body>{children}</body></html>",
+    "}"
+  ]);
+  log.hint("3. Restart your Next.js dev server after updating the config.");
+}
+
+// src/commands/init.ts
+async function init(options) {
+  const repoRoot = process.cwd();
+  let projectRoot = repoRoot;
+  const mutations = [];
+  const normalizedPackages = normalizePackageList(options.packages);
+  const verifiedPackages = [];
+  for (const pkg of normalizedPackages) {
+    if (!pkg) {
+      verifiedPackages.push(pkg);
+      continue;
+    }
+    const absolutePath = path10.join(repoRoot, pkg);
+    if (await exists(absolutePath)) {
+      verifiedPackages.push(pkg);
+    } else {
+      log.warn(`Package path "${pkg}" not found (skipping)`);
+      log.hint("Ensure --packages values are relative to the project root");
+    }
+  }
+  if (normalizedPackages.length > 0 && verifiedPackages.length === 0) {
+    log.error("No valid packages found from --packages input");
+    return;
+  }
+  log.header("Inspecto Setup");
+  if (!await exists(path10.join(repoRoot, "package.json"))) {
+    log.error("No package.json found in current directory");
+    log.hint("Run this command from your project root");
+    return;
+  }
+  const pm = await detectPackageManager(repoRoot);
+  let buildResult = await detectBuildTools(
+    repoRoot,
+    verifiedPackages.length > 0 ? verifiedPackages : void 0
+  );
+  if (verifiedPackages.length === 0) {
+    const monorepoCandidates = buildResult.supported.filter((detection) => !!detection.packagePath);
+    if (monorepoCandidates.length > 0) {
+      const frameworkSupportByPackage = await detectFrameworkSupportByPackage(
+        repoRoot,
+        monorepoCandidates
+      );
+      const targetResolution = resolveOnboardingTarget({
+        repoRoot,
+        buildTools: monorepoCandidates,
+        frameworkSupportByPackage
+      });
+      if (targetResolution.status === "needs_selection") {
+        log.warn("Monorepo root detected with multiple candidate apps.");
+        const selectedPackage = await promptMonorepoPackageChoice(
+          monorepoCandidates.filter(
+            (detection) => targetResolution.candidates.some(
+              (candidate) => candidate.packagePath === (detection.packagePath ?? "")
+            )
+          )
+        );
+        if (!selectedPackage) {
+          log.hint("Run `inspecto init` inside the target app, or pass --packages <app-path>.");
+          return;
+        }
+        projectRoot = path10.join(repoRoot, selectedPackage);
+        buildResult = await detectBuildTools(repoRoot, [selectedPackage]);
+        log.info(`Continuing initialization in ${selectedPackage}`);
+      } else if (targetResolution.selected?.packagePath) {
+        const selectedPackage = targetResolution.selected.packagePath;
+        projectRoot = path10.join(repoRoot, selectedPackage);
+        buildResult = await detectBuildTools(repoRoot, [selectedPackage]);
+        log.warn(`Monorepo root detected. Using the only candidate app: ${selectedPackage}`);
+        log.hint("Run `inspecto init` inside that app next time to skip this prompt.");
+      }
+    }
+  }
+  const [frameworkResult, ideProbe, providerProbe] = await Promise.all([
+    detectFrameworks(projectRoot),
+    detectIDE(projectRoot),
+    detectProviders(projectRoot)
+  ]);
+  log.success(`Detected package manager: ${pm}`);
+  if (frameworkResult.supported.length > 0) {
+    const frameworks = frameworkResult.supported.join(", ");
+    log.success(`Detected framework: ${frameworks}`);
+    if (frameworkResult.unsupported.length > 0) {
+      log.hint(
+        `Other frameworks detected (${frameworkResult.unsupported.map((f) => f.name).join(", ")}) will be skipped in this setup.`
+      );
+    }
+  }
+  const isSupported = frameworkResult.supported.length > 0;
+  const hasUnsupported = frameworkResult.unsupported.length > 0;
+  if (!isSupported) {
+    if (hasUnsupported) {
+      const names = frameworkResult.unsupported.map((f) => f.name).join(", ");
+      log.warn(`Detected ${names} \u2014 not supported in v1 (React / Vue only)`);
+    } else {
+      log.warn("No frontend framework detected");
+      log.hint("Inspecto current version supports React and Vue projects");
+    }
+    if (!options.force) {
+      const shouldContinue = await promptUnsupportedFrameworkContinue();
+      if (!shouldContinue) {
+        log.warn("Initialization aborted.");
+        return;
+      }
+    } else {
+      log.warn("Continuing anyway (--force)");
+    }
+  } else if (hasUnsupported) {
+    const names = frameworkResult.unsupported.map((f) => f.name).join(", ");
+    log.hint(
+      `Note: Inspecto will be configured for ${frameworkResult.supported.join(", ")}. Other detected frameworks (${names}) will be ignored.`
+    );
+  }
+  let manualConfigRequiredFor = "";
+  if (verifiedPackages.length > 0 && buildResult.supported.length === 0) {
+    log.warn(
+      `No supported build configs detected for: ${verifiedPackages.map((pkg) => pkg ? pkg : ".").join(", ")}`
+    );
+    log.hint("Double-check the --packages values or run without the flag to scan the repo root");
+  }
+  if (buildResult.supported.length > 0) {
+    buildResult.supported.forEach((bt) => log.success(`Detected: ${bt.label}`));
+  }
+  if (buildResult.unsupported.length > 0) {
+    const names = buildResult.unsupported.join(", ");
+    manualConfigRequiredFor = buildResult.unsupported[0] || "";
+    log.warn(`Detected ${names} \u2014 automatic plugin injection is not supported in current version`);
+    log.hint("You can still manually configure it by modifying your configuration file");
+    if (buildResult.unsupported.includes("Next.js")) {
+      printNextJsManualInstructions();
+    }
+    if (buildResult.unsupported.includes("Nuxt")) {
+      printNuxtManualInstructions();
+    }
+  }
+  if (buildResult.supported.length === 0 && buildResult.unsupported.length === 0) {
+    log.warn("No recognized build tool detected");
+    log.hint("current version supports: Vite, Webpack, Rspack, esbuild, Rollup");
+    log.hint("Dependency will be installed but plugin injection will be skipped");
+    log.hint(
+      "Please refer to the manual setup guide: https://inspecto-dev.github.io/inspecto/guide/manual-installation"
+    );
+  }
+  let selectedIDE = null;
+  if (ideProbe.detected.length === 0) {
+    log.error("No IDE detected in current project");
+    log.hint("Please open this project in a supported IDE (like VS Code)");
+  } else if (ideProbe.detected.length === 1) {
+    selectedIDE = ideProbe.detected[0];
+  } else {
+    selectedIDE = await promptIDEChoice(ideProbe.detected);
+  }
+  if (selectedIDE) {
+    if (selectedIDE.supported) {
+      log.success(`Selected IDE: ${selectedIDE.ide}`);
+    } else {
+      log.warn(`Selected IDE: ${selectedIDE.ide}`);
+      log.hint(
+        `Note: Inspecto currently requires VS Code (or compatible forks) to function properly.`
+      );
+      log.hint(`Features may be severely limited or unavailable in ${selectedIDE.ide}.`);
+    }
+  }
+  let selectedProvider = null;
+  const explicitProvider = options.provider ? providerProbe.detected.find((provider) => provider.id === options.provider) ?? null : null;
+  if (!options.provider) {
+    if (providerProbe.detected.length === 0) {
+      log.warn("No supported AI tools detected");
+      log.hint("Inspecto works best with Claude Code, Trae CLI, or GitHub Copilot");
+    } else if (providerProbe.detected.length === 1) {
+      selectedProvider = providerProbe.detected[0];
+      if (selectedProvider.supported) {
+        log.success(`Detected AI tool: ${selectedProvider.label}`);
+      }
+    } else {
+      log.info("Multiple providers detected, waiting for your selection...");
+      selectedProvider = await promptProviderChoice(providerProbe.detected);
+      if (selectedProvider) {
+        log.success(`Selected provider: ${selectedProvider.label}`);
+      } else {
+        log.warn("No provider selected. You can set provider.default later in .inspecto/settings.");
+      }
+    }
+  }
+  let injectionSkippedRequiresManualConfig = false;
+  const supportedBuildTargets = [];
+  if (buildResult.supported.length > 0) {
+    if (verifiedPackages.length > 0) {
+      const targets = buildResult.supported.filter(
+        (detection) => matchesAnyPackage(detection, verifiedPackages)
+      );
+      const unmatchedPackages = verifiedPackages.filter(
+        (pkg) => !buildResult.supported.some((detection) => matchesPackage(detection, pkg))
+      );
+      if (unmatchedPackages.length > 0) {
+        log.warn(
+          `No supported build configs detected for: ${unmatchedPackages.map((pkg) => pkg ? pkg : ".").join(", ")}`
+        );
+        log.hint("Check the package paths or run without --packages to inspect the repo root");
+      }
+      if (targets.length === 0) {
+        injectionSkippedRequiresManualConfig = true;
+      }
+      supportedBuildTargets.push(...targets);
+    } else {
+      let target = resolveInjectionTarget(buildResult.supported);
+      if (target === "ambiguous") {
+        target = await promptConfigChoice(buildResult.supported);
+      }
+      if (target) {
+        supportedBuildTargets.push(target);
+      } else {
+        injectionSkippedRequiresManualConfig = true;
+        log.warn("Skipping plugin injection (manual configuration required)");
+      }
+    }
+  }
+  const providerDefault = options.provider ? `${options.provider}.${explicitProvider?.preferredMode ?? (options.provider === "coco" ? "cli" : "extension")}` : selectedProvider ? `${selectedProvider.id}.${selectedProvider.preferredMode === "cli" ? "cli" : "extension"}` : void 0;
+  const applyResult = await applyOnboardingPlan({
+    repoRoot,
+    projectRoot,
+    packageManager: pm,
+    supportedBuildTargets,
+    options: {
+      shared: options.shared,
+      skipInstall: options.skipInstall,
+      dryRun: options.dryRun,
+      noExtension: options.noExtension
+    },
+    selectedIDE,
+    providerDefault,
+    manualConfigRequiredFor,
+    injectionSkippedRequiresManualConfig,
+    allowManualPlanApply: true
+  });
+  mutations.push(...applyResult.mutations);
+  if (options.dryRun) {
+    log.blank();
+    log.warn("Dry run complete. No files were modified.");
+  } else {
+    log.blank();
+    if (applyResult.postInstall.nextSteps.length > 0) {
+      log.warn("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 Manual Steps Required \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      applyResult.postInstall.nextSteps.forEach((step) => log.error(step));
+      log.hint("Complete the items above.");
+      log.blank();
+    } else {
+      log.ready("Ready! Inspecto is set up.");
+      log.info("Next:");
+      log.hint("1. Start or restart your dev server.");
+      log.hint("2. Open your app in the browser.");
+      log.hint("3. Hold Alt + Click any element to inspect.");
+    }
+  }
+}
+function normalizePackageList(packages) {
+  if (!packages || packages.length === 0) return [];
+  const normalized = packages.map((pkg) => {
+    const trimmed = pkg.trim();
+    if (trimmed === "") return null;
+    if (trimmed === "." || trimmed === "./") return "";
+    return trimmed.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+  }).filter((value) => value !== null);
+  return Array.from(new Set(normalized));
+}
+function matchesPackage(detection, pkg) {
+  const configPath = detection.configPath.replace(/\\/g, "/");
+  if (!pkg) {
+    return !configPath.includes("/");
+  }
+  return configPath === pkg || configPath.startsWith(`${pkg}/`);
+}
+function matchesAnyPackage(detection, packages) {
+  if (packages.length === 0) return true;
+  return packages.some((pkg) => matchesPackage(detection, pkg));
+}
+async function detectFrameworkSupportByPackage(repoRoot, buildTools) {
+  const packagePaths = Array.from(
+    new Set(buildTools.map((buildTool) => buildTool.packagePath).filter((value) => !!value))
+  );
+  const supportByPackage = {};
+  await Promise.all(
+    packagePaths.map(async (packagePath) => {
+      const result = await detectFrameworks(path10.join(repoRoot, packagePath));
+      supportByPackage[packagePath] = result.supported;
+    })
+  );
+  return supportByPackage;
+}
+
+// src/commands/doctor.ts
+import path11 from "path";
+function createDiagnostic(code, status, message2, hints = [], details) {
+  return {
+    code,
+    status,
+    message: message2,
+    hints,
+    ...details ? { details } : {}
+  };
+}
+function doctorStatus(errors, warnings) {
+  if (errors > 0) return "blocked";
+  if (warnings > 0) return "warning";
+  return "ok";
+}
+function printDoctorResult(result) {
+  log.header("Inspecto Doctor");
+  for (const check of result.checks) {
+    if (check.status === "ok") {
+      log.success(check.message);
+    } else if (check.status === "warning") {
+      log.warn(check.message);
+    } else {
+      log.error(check.message);
+    }
+    for (const hint of check.hints) {
+      log.hint(hint);
+    }
+  }
+  log.blank();
+  if (result.summary.errors === 0 && result.summary.warnings === 0) {
+    log.success("All checks passed. Hold Alt + Click to start!");
+  } else {
+    const parts = [];
+    if (result.summary.errors > 0) parts.push(`${result.summary.errors} error(s)`);
+    if (result.summary.warnings > 0) parts.push(`${result.summary.warnings} warning(s)`);
+    console.log(
+      `  ${parts.join(", ")}. ${result.summary.errors > 0 ? "Fix the errors above to get started." : ""}`
+    );
+  }
+  log.blank();
+}
+async function collectDoctorResult(root = process.cwd()) {
+  const checks = [];
+  if (!await exists(path11.join(root, "package.json"))) {
+    const diagnostic = createDiagnostic("missing-package-json", "error", "No package.json found", [
+      "Run this command from your project root"
+    ]);
+    checks.push(diagnostic);
+    return {
+      status: "blocked",
+      summary: { errors: 1, warnings: 0 },
+      project: { root },
+      errors: [diagnostic],
+      warnings: [],
+      checks
+    };
+  }
+  const [ideProbe, frameworkResult, providerProbe, pm, buildResult, extInstalled] = await Promise.all([
+    detectIDE(root),
+    detectFrameworks(root),
+    detectProviders(root),
+    detectPackageManager(root),
+    detectBuildTools(root),
+    isExtensionInstalled()
+  ]);
+  if (ideProbe.detected.length === 0) {
+    checks.push(createDiagnostic("ide-not-detected", "warning", "IDE: not detected"));
+  } else {
+    const hasSupported = ideProbe.detected.some((d) => d.supported);
+    if (hasSupported) {
+      checks.push(
+        createDiagnostic(
+          "ide-supported",
+          "ok",
+          `IDE: ${ideProbe.detected.filter((d) => d.supported).map((d) => d.ide).join(", ")}`,
+          [],
+          {
+            detected: ideProbe.detected
+          }
+        )
+      );
+    } else {
+      const names = ideProbe.detected.map((d) => d.ide).join(", ");
+      checks.push(
+        createDiagnostic(
+          "ide-unsupported",
+          "warning",
+          `IDE: ${names} (not supported in v1, VS Code, Cursor, Trae only)`,
+          [],
+          {
+            detected: ideProbe.detected
+          }
+        )
+      );
+    }
+  }
+  if (frameworkResult.supported.length > 0) {
+    checks.push(
+      createDiagnostic(
+        "framework-supported",
+        "ok",
+        `Framework: ${frameworkResult.supported.join(", ")}`
+      )
+    );
+  } else if (frameworkResult.unsupported.length > 0) {
+    const names = frameworkResult.unsupported.map((f) => f.name).join(", ");
+    checks.push(
+      createDiagnostic(
+        "framework-unsupported",
+        "warning",
+        `Framework: ${names} (not supported in v1, React/Vue only)`
+      )
+    );
+  } else {
+    checks.push(
+      createDiagnostic(
+        "framework-not-detected",
+        "warning",
+        "Framework: not detected (React / Vue expected)"
+      )
+    );
+  }
+  if (providerProbe.detected.length === 0) {
+    checks.push(
+      createDiagnostic("provider-missing", "warning", "Provider: none detected", [
+        "Inspecto works best with Claude Code, Trae CLI, or GitHub Copilot"
+      ])
+    );
+  } else {
+    const aiNames = providerProbe.detected.map((d) => {
+      const modeLabels = d.providerModes.map(
+        (mode) => mode === "extension" ? "VS Code Extension" : "Terminal CLI"
+      );
+      return `${d.label} (${modeLabels.join(" & ")})`;
+    }).join(", ");
+    checks.push(createDiagnostic("provider-detected", "ok", `Provider: ${aiNames}`));
+  }
+  const pluginPath = path11.join(root, "node_modules", "@inspecto-dev", "plugin");
+  if (await exists(pluginPath)) {
+    const pkgJson = await readJSON(path11.join(pluginPath, "package.json"));
+    const version = pkgJson?.version ?? "unknown";
+    checks.push(
+      createDiagnostic("plugin-installed", "ok", `@inspecto-dev/plugin@${version} installed`, [], {
+        version
+      })
+    );
+  } else {
+    checks.push(
+      createDiagnostic("plugin-missing", "error", "@inspecto-dev/plugin not installed", [
+        `Fix: ${getInstallCommand(pm, "@inspecto-dev/plugin")}`
+      ])
+    );
+  }
+  if (buildResult.supported.length > 0) {
+    let injected = false;
+    for (const bt of buildResult.supported) {
+      const content = await readFile(path11.join(root, bt.configPath));
+      if (content && content.includes("@inspecto-dev/plugin")) {
+        checks.push(
+          createDiagnostic("plugin-configured", "ok", `Plugin configured in ${bt.configPath}`, [], {
+            configPath: bt.configPath,
+            buildTool: bt.tool
+          })
+        );
+        injected = true;
+        break;
+      }
+    }
+    if (!injected) {
+      checks.push(
+        createDiagnostic(
+          "plugin-not-configured",
+          "error",
+          "Plugin not configured in any build config",
+          ["Fix: npx @inspecto-dev/cli init"]
+        )
+      );
+    }
+  } else if (buildResult.unsupported.length > 0) {
+    const names = buildResult.unsupported.join(", ");
+    checks.push(
+      createDiagnostic(
+        `build-tool-unsupported`,
+        "warning",
+        `Build tool: ${names} (not supported in v1)`,
+        ["current version supports: Vite, Webpack, Rspack, esbuild, Rollup"]
+      )
+    );
+  } else {
+    checks.push(
+      createDiagnostic("build-tool-missing", "warning", "No recognized build config found")
+    );
+  }
+  if (extInstalled) {
+    checks.push(createDiagnostic("extension-installed", "ok", "VS Code extension detected"));
+  } else {
+    const hasVSCode = ideProbe.detected.some((d) => d.supported && d.ide === "vscode");
+    const hasSupportedNonVSCode = ideProbe.detected.some((d) => d.supported && d.ide !== "vscode");
+    if (hasSupportedNonVSCode && !hasVSCode) {
+      checks.push(
+        createDiagnostic(
+          "extension-not-applicable",
+          "warning",
+          "VS Code extension not applicable (non-VS Code IDE)"
+        )
+      );
+    } else {
+      checks.push(
+        createDiagnostic("extension-missing", "error", "VS Code extension not found", [
+          "Fix: code --install-extension inspecto.inspecto",
+          "Or: https://marketplace.visualstudio.com/items?itemName=inspecto.inspecto"
+        ])
+      );
+    }
+  }
+  const settingsJsonPath = path11.join(root, ".inspecto", "settings.json");
+  const settingsLocalPath = path11.join(root, ".inspecto", "settings.local.json");
+  const hasSettingsJson = await exists(settingsJsonPath);
+  const hasSettingsLocal = await exists(settingsLocalPath);
+  if (hasSettingsJson || hasSettingsLocal) {
+    const targetPath = hasSettingsLocal ? settingsLocalPath : settingsJsonPath;
+    const fileName = hasSettingsLocal ? "settings.local.json" : "settings.json";
+    const settings = await readJSON(targetPath);
+    if (settings) {
+      checks.push(createDiagnostic("settings-valid", "ok", `.inspecto/${fileName} valid`));
+    } else {
+      checks.push(
+        createDiagnostic(
+          "settings-invalid-json",
+          "error",
+          `.inspecto/${fileName} has invalid JSON`,
+          [
+            "Fix: Manually correct the syntax errors, or delete the file and re-run npx @inspecto-dev/cli init"
+          ],
+          {
+            fileName
+          }
+        )
+      );
+    }
+  } else {
+    checks.push(
+      createDiagnostic(
+        "settings-missing",
+        "warning",
+        "No .inspecto/settings.json or settings.local.json found (using defaults)",
+        ["Optional: npx @inspecto-dev/cli init"]
+      )
+    );
+  }
+  const gitignoreContent = await readFile(path11.join(root, ".gitignore"));
+  if (gitignoreContent) {
+    const hasLockIgnore = gitignoreContent.includes(".inspecto/install.lock") || gitignoreContent.includes(".inspecto/");
+    if (!hasLockIgnore) {
+      checks.push(
+        createDiagnostic(
+          "gitignore-missing-install-lock",
+          "warning",
+          ".inspecto/install.lock not in .gitignore",
+          ["install.lock contains local machine state and should not be committed"]
+        )
+      );
+    }
+  }
+  const errors = checks.filter((check) => check.status === "error");
+  const warnings = checks.filter((check) => check.status === "warning");
+  return {
+    status: doctorStatus(errors.length, warnings.length),
+    summary: {
+      errors: errors.length,
+      warnings: warnings.length
+    },
+    project: {
+      root,
+      packageManager: pm
+    },
+    errors,
+    warnings,
+    checks
+  };
+}
+async function doctor(options = {}) {
+  const json = typeof options === "boolean" ? options : options.json ?? false;
+  const result = await collectDoctorResult(process.cwd());
+  return writeCommandOutput(result, json, printDoctorResult);
+}
+
+// src/onboarding/session.ts
+import path12 from "path";
+function normalizePackagePath2(packagePath) {
+  if (!packagePath || packagePath === ".") return "";
+  return packagePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+}
+function getProviderDefault2(providerId, preferredMode) {
+  if (!providerId) return void 0;
+  const mode = preferredMode ?? (providerId === "coco" ? "cli" : "extension");
+  return `${providerId}.${mode}`;
+}
+function getVerificationCommand(packageManager) {
+  switch (packageManager) {
+    case "pnpm":
+      return "pnpm dev";
+    case "yarn":
+      return "yarn dev";
+    case "bun":
+      return "bun run dev";
+    case "npm":
+    default:
+      return "npm run dev";
+  }
+}
+async function buildVerification(projectRoot, packageManager) {
+  const packageJson = await readJSON(
+    path12.join(projectRoot, "package.json")
+  );
+  if (packageJson?.scripts?.dev) {
+    const devCommand = getVerificationCommand(packageManager);
+    return {
+      available: true,
+      devCommand,
+      message: `Start the local dev server with \`${devCommand}\` to verify Inspecto in the browser.`
+    };
+  }
+  return {
+    available: false,
+    message: "Start your normal local dev server command to verify Inspecto in the browser."
+  };
+}
+function buildIdeExtensionStatus(input) {
+  if (!input.required) {
+    return {
+      required: false,
+      installed: false,
+      manualRequired: false
+    };
+  }
+  return {
+    required: true,
+    installed: input.installed,
+    manualRequired: input.manualRequired,
+    installCommand: "code --install-extension inspecto.inspecto",
+    marketplaceUrl: "https://marketplace.visualstudio.com/items?itemName=inspecto.inspecto",
+    openVsxUrl: "https://open-vsx.org/extension/inspecto/inspecto"
+  };
+}
+async function detectFrameworkSupportByPackage2(repoRoot, context) {
+  const packagePaths = new Set(
+    context.buildTools.supported.map((item) => normalizePackagePath2(item.packagePath))
+  );
+  const supportByPackage = {};
+  await Promise.all(
+    Array.from(packagePaths).map(async (packagePath) => {
+      const frameworkResult = await detectFrameworks(
+        packagePath ? path12.join(repoRoot, packagePath) : repoRoot
+      );
+      supportByPackage[packagePath] = frameworkResult.supported;
+    })
+  );
+  return supportByPackage;
+}
+async function buildTargetedContext(rootContext, packagePath) {
+  const projectRoot = packagePath ? path12.join(rootContext.root, packagePath) : rootContext.root;
+  const [frameworks, ides, providers] = await Promise.all([
+    detectFrameworks(projectRoot),
+    detectIDE(projectRoot),
+    detectProviders(projectRoot)
+  ]);
+  return {
+    root: projectRoot,
+    packageManager: rootContext.packageManager,
+    buildTools: {
+      supported: rootContext.buildTools.supported.filter((item) => {
+        return normalizePackagePath2(item.packagePath) === packagePath;
+      }),
+      unsupported: []
+    },
+    frameworks: {
+      supported: frameworks.supported,
+      unsupported: frameworks.unsupported.map((item) => item.name)
+    },
+    ides: ides.detected.map(({ ide, supported }) => ({ ide, supported })),
+    providers: providers.detected.map(({ id, label, supported, preferredMode }) => ({
+      id,
+      label,
+      supported,
+      preferredMode
+    }))
+  };
+}
+function buildOnboardingSummary(plan2, projectRoot) {
+  const changes = plan2.actions.filter((action) => action.type !== "manual_step").map((action) => action.description);
+  const risks = [...plan2.warnings.map((item) => item.message)];
+  const manualFollowUp = planManualFollowUp(plan2);
+  let headline = `Inspecto is ready to onboard ${projectRoot}.`;
+  if (manualFollowUp.length > 0) {
+    headline = `Inspecto can partially onboard ${projectRoot}, but manual follow-up remains.`;
+  } else if (plan2.status === "blocked") {
+    headline = `Inspecto could not build an automatic onboarding path for ${projectRoot}.`;
+  }
+  return {
+    headline,
+    changes,
+    risks,
+    manualFollowUp
+  };
+}
+function buildConfirmation(plan2, summary, session, options) {
+  if (options.yes) {
+    return { required: false };
+  }
+  const reasons = [];
+  if (session.targetWasHeuristic) reasons.push("a monorepo target was preselected");
+  if (summary.manualFollowUp.length > 0) reasons.push("manual follow-up will remain after setup");
+  if (options.noExtension || options.skipInstall) reasons.push("non-core setup steps are being skipped");
+  if (session.supportedIdeCount > 1 || session.supportedProviderCount > 1) {
+    reasons.push("multiple IDE or provider choices are still relevant");
+  }
+  if (plan2.warnings.length > 0) reasons.push("the CLI detected non-blocking risk");
+  if (reasons.length === 0) {
+    return { required: false };
+  }
+  return {
+    required: true,
+    reason: reasons.join("; "),
+    question: "Proceed with Inspecto onboarding using the proposed default target and settings?"
+  };
+}
+function buildPreApplyResult(status, session) {
+  const diagnostics = session.summary.risks.length > 0 || session.summary.manualFollowUp.length > 0 || session.plan.blockers.length > 0 ? {
+    warnings: session.summary.risks,
+    errors: session.plan.blockers.map((item) => item.message),
+    nextSteps: session.summary.manualFollowUp
+  } : void 0;
+  return {
+    status,
+    target: session.target,
+    summary: session.summary,
+    confirmation: session.confirmation,
+    ideExtension: buildIdeExtensionStatus({
+      required: session.plan.defaults.extension,
+      installed: false,
+      manualRequired: session.plan.defaults.extension
+    }),
+    verification: session.verification,
+    diagnostics
+  };
+}
+function buildExecutionResult(session, applyResult) {
+  return {
+    changedFiles: Array.from(
+      new Set(applyResult.mutations.map((item) => item.path).filter((value) => !!value))
+    ),
+    installedDependencies: applyResult.mutations.map((item) => item.name).filter((value) => !!value),
+    selectedProviderDefault: session.providerDefault,
+    selectedIDE: session.selectedIDE?.ide,
+    mutations: applyResult.mutations
+  };
+}
+function buildExecutionDiagnostics(session, applyResult) {
+  const warnings = [...session.plan.warnings.map((item) => item.message)];
+  const errors = [];
+  if (applyResult.postInstall.installFailed) {
+    errors.push("Dependency installation failed during onboarding.");
+  }
+  if (applyResult.postInstall.injectionFailed) {
+    warnings.push("Automatic plugin injection did not finish cleanly.");
+  }
+  if (applyResult.postInstall.manualExtensionInstallNeeded) {
+    warnings.push("IDE extension installation still needs manual completion.");
+  }
+  if (warnings.length === 0 && errors.length === 0 && applyResult.postInstall.nextSteps.length === 0) {
+    return void 0;
+  }
+  return {
+    warnings,
+    errors,
+    nextSteps: applyResult.postInstall.nextSteps
+  };
+}
+async function resolveOnboardingSession(root, options = {}) {
+  const rootContext = await buildOnboardingContext(root);
+  const rootVerification = await buildVerification(root, rootContext.packageManager);
+  const frameworkSupportByPackage = await detectFrameworkSupportByPackage2(root, rootContext);
+  const target = resolveOnboardingTarget({
+    repoRoot: root,
+    buildTools: rootContext.buildTools.supported,
+    frameworkSupportByPackage,
+    selectedPackagePath: options.target
+  });
+  if (target.candidates.length === 0) {
+    const plan3 = createPlanResult(rootContext);
+    return {
+      status: "error",
+      target,
+      summary: buildOnboardingSummary(plan3, root),
+      confirmation: { required: false },
+      verification: rootVerification,
+      context: rootContext,
+      plan: plan3,
+      projectRoot: root
+    };
+  }
+  if (target.status === "needs_selection") {
+    const plan3 = createPlanResult(rootContext);
+    const summary2 = {
+      headline: "Inspecto found multiple plausible app targets and needs one selection.",
+      changes: [],
+      risks: [],
+      manualFollowUp: []
+    };
+    return {
+      status: "needs_target_selection",
+      target,
+      summary: summary2,
+      confirmation: { required: false },
+      verification: rootVerification,
+      context: rootContext,
+      plan: plan3,
+      projectRoot: root
+    };
+  }
+  const packagePath = normalizePackagePath2(target.selected?.packagePath);
+  const context = await buildTargetedContext(rootContext, packagePath);
+  const verification = await buildVerification(context.root, context.packageManager);
+  const plan2 = createPlanResult(context);
+  const summary = buildOnboardingSummary(plan2, context.root);
+  const confirmation = buildConfirmation(
+    plan2,
+    summary,
+    {
+      targetWasHeuristic: target.candidates.length > 1 && options.target === void 0,
+      supportedIdeCount: context.ides.filter((item) => item.supported).length,
+      supportedProviderCount: context.providers.filter((item) => item.supported).length
+    },
+    options
+  );
+  const selectedProvider = context.providers.find((provider) => provider.id === plan2.defaults.provider) ?? null;
+  const selectedIDE = context.ides.find((ide) => ide.ide === plan2.defaults.ide) ?? context.ides.find((ide) => ide.supported) ?? null;
+  let status = "success";
+  if (plan2.status === "blocked") {
+    status = "error";
+  } else if (confirmation.required) {
+    status = "needs_confirmation";
+  } else if (summary.manualFollowUp.length > 0 || plan2.warnings.length > 0) {
+    status = "partial_success";
+  }
+  return {
+    status,
+    target,
+    summary,
+    confirmation,
+    verification,
+    context,
+    plan: plan2,
+    projectRoot: context.root,
+    selectedIDE,
+    providerDefault: getProviderDefault2(plan2.defaults.provider, selectedProvider?.preferredMode)
+  };
+}
+async function applyResolvedOnboardingSession(session, options = {}) {
+  const verification = await buildVerification(session.projectRoot, session.context.packageManager);
+  const applyResult = await applyOnboardingPlan({
+    repoRoot: process.cwd(),
+    projectRoot: session.projectRoot,
+    packageManager: session.context.packageManager,
+    supportedBuildTargets: session.context.buildTools.supported,
+    options: {
+      shared: options.shared ?? session.plan.defaults.shared,
+      skipInstall: options.skipInstall ?? false,
+      dryRun: options.dryRun ?? false,
+      noExtension: options.noExtension ?? !session.plan.defaults.extension,
+      quiet: options.json ?? false
+    },
+    selectedIDE: session.selectedIDE,
+    providerDefault: session.providerDefault,
+    plan: session.plan
+  });
+  const diagnostics = buildExecutionDiagnostics(session, applyResult);
+  const status = applyResult.postInstall.installFailed && session.context.buildTools.supported.length === 0 ? "error" : diagnostics?.nextSteps.length || diagnostics?.errors.length || diagnostics?.warnings.length ? "partial_success" : "success";
+  return {
+    status,
+    target: session.target,
+    summary: session.summary,
+    confirmation: session.confirmation,
+    ideExtension: buildIdeExtensionStatus({
+      required: session.plan.defaults.extension,
+      installed: session.plan.defaults.extension && !applyResult.postInstall.manualExtensionInstallNeeded,
+      manualRequired: applyResult.postInstall.manualExtensionInstallNeeded
+    }),
+    verification,
+    result: buildExecutionResult(session, applyResult),
+    diagnostics
+  };
+}
+function buildDeferredOnboardResult(session) {
+  return buildPreApplyResult(session.status, session);
+}
+
+// src/commands/onboard.ts
+function printOnboardResult(result) {
+  log.header("Inspecto Onboard");
+  log.info(`Status: ${result.status}`);
+  log.info(result.summary.headline);
+  for (const change of result.summary.changes) {
+    log.hint(change);
+  }
+  for (const step of result.diagnostics?.nextSteps ?? []) {
+    log.warn(step);
+  }
+  if (result.confirmation.required && result.confirmation.question) {
+    log.warn(result.confirmation.question);
+  }
+}
+async function onboard(options = {}) {
+  const root = process.cwd();
+  const session = await resolveOnboardingSession(root, options);
+  if (session.status === "error" || session.status === "needs_target_selection" || session.status === "needs_confirmation") {
+    return writeCommandOutput(
+      buildDeferredOnboardResult(session),
+      options.json ?? false,
+      printOnboardResult
+    );
+  }
+  const result = await applyResolvedOnboardingSession(session, options);
+  return writeCommandOutput(result, options.json ?? false, printOnboardResult);
+}
+
+// src/commands/plan.ts
+function printPlanResult(result) {
+  log.header("Inspecto Plan");
+  log.info(`Status: ${result.status}`);
+  log.info(`Strategy: ${result.strategy}`);
+  if (result.defaults.provider) {
+    log.info(`Default provider: ${result.defaults.provider}`);
+  }
+  if (result.defaults.ide) {
+    log.info(`Default IDE: ${result.defaults.ide}`);
+  }
+  log.info(`Shared mode: ${result.defaults.shared ? "enabled" : "disabled"}`);
+  log.info(`Extension mode: ${result.defaults.extension ? "enabled" : "disabled"}`);
+  if (result.actions.length > 0) {
+    log.blank();
+    log.info("Actions:");
+    for (const action of result.actions) {
+      log.hint(`${action.type}: ${action.target} \u2014 ${action.description}`);
+    }
+  }
+  for (const blocker of result.blockers) {
+    log.error(blocker.message);
+  }
+  for (const warning of result.warnings) {
+    log.warn(warning.message);
+  }
+}
+async function plan(json = false) {
+  const context = await buildOnboardingContext(process.cwd());
+  const result = createPlanResult(context);
+  return writeCommandOutput(result, json, printPlanResult);
+}
+
+// src/commands/teardown.ts
+import path13 from "path";
+async function teardown() {
+  const root = process.cwd();
+  log.header("Inspecto Teardown");
+  const lockPath = path13.join(root, ".inspecto", "install.lock");
+  const lock = await readJSON(lockPath);
+  if (!lock) {
+    log.warn("No .inspecto/install.lock found. Running in best-effort mode.");
+    log.blank();
+    const pm = await detectPackageManager(root);
+    try {
+      const cmd = getUninstallCommand(pm, "@inspecto-dev/plugin");
+      await shell(cmd, root);
+      log.success("Removed @inspecto-dev/plugin from devDependencies");
+    } catch {
+      log.warn("Could not remove @inspecto-dev/plugin (may not be installed)");
+    }
+    if (await exists(path13.join(root, ".inspecto"))) {
+      await removeDir(path13.join(root, ".inspecto"));
+      log.success("Deleted .inspecto/ directory");
+    }
+    await cleanGitignore(root);
+    log.success("Cleaned .gitignore entries");
+    log.warn("Cannot restore build config auto-magically");
+    log.hint("Please manually remove the inspecto() plugin from your build config");
+    log.blank();
+    return;
+  }
+  log.success("Reading .inspecto/install.lock...");
+  log.blank();
+  for (const mutation of lock.mutations) {
+    switch (mutation.type) {
+      case "file_modified": {
+        if (!mutation.path) break;
+        if (mutation.path === ".gitignore") {
+          log.success("Cleaned .gitignore entries");
+        } else if (mutation.path) {
+          log.warn(`Cannot auto-restore ${mutation.path}`);
+          log.hint(`Please manually remove the inspecto plugin from ${mutation.path}`);
+        }
+        break;
+      }
+      case "file_created": {
+        break;
+      }
+      case "dependency_added": {
+        if (mutation.name) {
+          const pm = await detectPackageManager(root);
+          try {
+            const cmd = getUninstallCommand(pm, mutation.name);
+            await shell(cmd, root);
+            log.success(`Removed ${mutation.name} from devDependencies`);
+          } catch {
+            log.warn(`Could not remove ${mutation.name}`);
+          }
+        }
+        break;
+      }
+      case "extension_installed": {
+        if (mutation.id) {
+          log.warn(`VS Code extension not auto-uninstalled`);
+          log.hint(`Run: code --uninstall-extension ${mutation.id}`);
+        }
+        break;
+      }
+    }
+  }
+  await removeDir(path13.join(root, ".inspecto"));
+  log.success("Deleted .inspecto/ directory");
+  await cleanGitignore(root);
+  log.blank();
+  log.success("Done. All Inspecto traces removed.");
+  log.blank();
+}
+
+export {
+  exists,
+  writeFile,
+  log,
+  writeCommandOutput,
+  reportCommandError,
+  apply,
+  detect,
+  init,
+  collectDoctorResult,
+  doctor,
+  onboard,
+  plan,
+  teardown
+};