@inspecto-dev/cli 0.2.0-alpha.0

package/dist/chunk-4RR7PTRN.js

@@ -0,0 +1,1306 @@
+// 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();
+  },
+  /** Dry-run prefix */
+  dryRun(text) {
+    console.log(`  ${pc.blue("[dry-run]")} ${text}`);
+  }
+};
+
+// src/commands/init.ts
+import path9 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 copyFile(src, dest) {
+  await fs.copyFile(src, dest);
+}
+async function removeFile(filePath) {
+  try {
+    await fs.unlink(filePath);
+  } catch {
+  }
+}
+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) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function writeJSON(filePath, data) {
+  await writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+
+// 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/detect/package-manager.ts
+import path2 from "path";
+async function detectPackageManager(root) {
+  const checks = [
+    ["bun.lockb", "bun"],
+    ["bun.lock", "bun"],
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["package-lock.json", "npm"]
+  ];
+  for (const [file, pm] of checks) {
+    if (await exists(path2.join(root, file))) {
+      return 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/detect/build-tool.ts
+import path3 from "path";
+var SUPPORTED_PATTERNS = [
+  {
+    tool: "vite",
+    files: ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"],
+    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"],
+    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"] }
+];
+async function detectBuildTools(root) {
+  const supported = [];
+  const unsupported = [];
+  const pkg = await readJSON(path3.join(root, "package.json"));
+  const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  for (const pattern of SUPPORTED_PATTERNS) {
+    for (const file of pattern.files) {
+      if (await exists(path3.join(root, file))) {
+        let isLegacyRspack = false;
+        if (pattern.tool === "rspack") {
+          const version = allDeps["@rspack/cli"] || allDeps["@rspack/core"];
+          if (version && (version.includes("0.3.") || version.includes("0.2.") || version.includes("0.1."))) {
+            isLegacyRspack = true;
+          }
+        }
+        supported.push({
+          tool: pattern.tool,
+          configPath: file,
+          label: `${pattern.label} (${file})${isLegacyRspack ? " [Legacy]" : ""}`,
+          isLegacyRspack
+        });
+        break;
+      }
+    }
+  }
+  for (const meta of UNSUPPORTED_META) {
+    if (!(meta.dep in allDeps)) continue;
+    for (const file of meta.files) {
+      if (await exists(path3.join(root, file))) {
+        unsupported.push(meta.name);
+        break;
+      }
+    }
+  }
+  return { supported, unsupported };
+}
+function resolveInjectionTarget(detections) {
+  if (detections.length === 0) return null;
+  if (detections.length === 1) return detections[0];
+  return "ambiguous";
+}
+
+// src/detect/framework.ts
+import path4 from "path";
+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" }
+];
+async function detectFrameworks(root) {
+  const pkg = await readJSON(path4.join(root, "package.json"));
+  if (!pkg) return { supported: [], unsupported: [] };
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const supported = [];
+  for (const { framework, deps } of SUPPORTED_FRAMEWORKS) {
+    if (deps.some((dep) => dep in allDeps)) {
+      supported.push(framework);
+    }
+  }
+  const unsupported = [];
+  for (const fw of UNSUPPORTED_FRAMEWORKS) {
+    if (fw.dep in allDeps) {
+      unsupported.push(fw);
+    }
+  }
+  return { supported, unsupported };
+}
+
+// src/detect/ide.ts
+import path5 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: false });
+  }
+  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: false });
+  }
+  if (process.env.ZED_TERM) {
+    detected.set("Zed", { ide: "Zed", supported: false });
+  }
+  if (process.env.TERM_PROGRAM === "vscode") {
+    if (!detected.has("Trae") && !detected.has("Cursor")) {
+      detected.set("vscode", { ide: SUPPORTED_IDE, supported: true });
+    }
+  }
+  if (await exists(path5.join(root, ".trae"))) {
+    detected.set("Trae", { ide: "Trae", supported: false });
+  }
+  if (await exists(path5.join(root, ".cursor"))) {
+    detected.set("Cursor", { ide: "Cursor", supported: false });
+  }
+  if (await exists(path5.join(root, ".vscode"))) {
+    if (!detected.has("vscode")) {
+      detected.set("vscode", { ide: SUPPORTED_IDE, supported: true });
+    }
+  }
+  if (await exists(path5.join(root, ".idea"))) {
+    detected.set("JetBrains IDE", { ide: "JetBrains IDE", supported: false });
+  }
+  return {
+    detected: Array.from(detected.values())
+  };
+}
+
+// src/detect/ai-tool.ts
+import path6 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: "github-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 detectAITools(root) {
+  const detectedMap = /* @__PURE__ */ new Map();
+  for (const tool of KNOWN_CLI_TOOLS) {
+    if (await which(tool.bin)) {
+      detectedMap.set(tool.id, {
+        id: tool.id,
+        label: tool.label,
+        supported: tool.supported,
+        toolModes: ["cli"],
+        preferredMode: "cli"
+      });
+    }
+  }
+  const extensionsJsonPath = path6.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 = path6.join(homeDir, ".vscode", "extensions");
+  const globalExtExists = await exists(globalExtDir);
+  for (const plugin of KNOWN_IDE_PLUGINS) {
+    let isInstalled = false;
+    if (recommendedExts.includes(plugin.extId.toLowerCase())) {
+      isInstalled = true;
+    } else if (globalExtExists) {
+      try {
+        const { readdir } = await import("fs/promises");
+        const folders = await readdir(globalExtDir);
+        if (folders.some((f) => {
+          const lower = f.toLowerCase();
+          return lower === plugin.extId.toLowerCase() || lower.startsWith(plugin.extId.toLowerCase() + "-");
+        })) {
+          isInstalled = true;
+        }
+      } catch {
+      }
+    }
+    if (isInstalled) {
+      const existing = detectedMap.get(plugin.id);
+      if (existing) {
+        existing.toolModes.push("plugin");
+        existing.preferredMode = "plugin";
+      } else {
+        detectedMap.set(plugin.id, {
+          id: plugin.id,
+          label: plugin.label,
+          supported: plugin.supported,
+          toolModes: ["plugin"],
+          preferredMode: "plugin"
+        });
+      }
+    }
+  }
+  return { detected: Array.from(detectedMap.values()) };
+}
+
+// src/inject/ast-injector.ts
+import path7 from "path";
+var IMPORT_MAP = {
+  vite: `import { vitePlugin as inspecto } from '@inspecto-dev/plugin'`,
+  webpack: `import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'`,
+  rspack: `import { rspackPlugin as inspecto } from '@inspecto-dev/plugin'`,
+  rsbuild: `import { rspackPlugin as inspecto } from '@inspecto-dev/plugin'`,
+  esbuild: `import { esbuildPlugin as inspecto } from '@inspecto-dev/plugin'`,
+  rollup: `import { rollupPlugin as inspecto } from '@inspecto-dev/plugin'`
+};
+function getImportStatement(tool, isLegacyRspack) {
+  if (tool === "rspack" && isLegacyRspack) {
+    return `import { rspackPlugin as inspecto } from '@inspecto-dev/plugin/legacy/rspack'`;
+  }
+  return IMPORT_MAP[tool];
+}
+function getPluginExpression(isLegacyRspack) {
+  if (isLegacyRspack) {
+    return `process.env.NODE_ENV !== 'production' && inspecto({
+      pathType: 'absolute',
+      escapeTags: ['Transition', 'AnimatePresence'],
+    }) as any`;
+  }
+  return `process.env.NODE_ENV !== 'production' && inspecto()`;
+}
+function printManualInstructions(tool, configPath, reason, isLegacyRspack) {
+  const isRsbuild = tool === "rsbuild";
+  log.warn(`Could not safely auto-inject into ${configPath}`);
+  log.hint(`(reason: ${reason})`);
+  log.blank();
+  log.hint("Please add the following manually:");
+  if (isRsbuild) {
+    log.codeBlock([
+      getImportStatement(tool, isLegacyRspack),
+      "",
+      "// Add to tools.rspack:",
+      `tools: {`,
+      `  rspack: {`,
+      `    plugins: [`,
+      `      ${getPluginExpression(isLegacyRspack)},`,
+      `    ]`,
+      `  }`,
+      `}`
+    ]);
+  } else {
+    log.codeBlock([
+      getImportStatement(tool, isLegacyRspack),
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  ${getPluginExpression(isLegacyRspack)},`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`
+    ]);
+  }
+}
+function isAlreadyInjected(content) {
+  return content.includes("@inspecto-dev/plugin") || content.includes("inspecto()") || content.includes("aiDevInspector");
+}
+function injectImport(content, importStmt) {
+  const importRegex = /^import\s.+$/gm;
+  let lastImportEnd = 0;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const lineEnd = content.indexOf("\n", match.index);
+    if (lineEnd > lastImportEnd) {
+      lastImportEnd = lineEnd;
+    }
+  }
+  if (lastImportEnd === 0) {
+    const requireRegex = /^(?:const|let|var)\s.+=\s*require\(.+\).*$/gm;
+    while ((match = requireRegex.exec(content)) !== null) {
+      const lineEnd = content.indexOf("\n", match.index);
+      if (lineEnd > lastImportEnd) {
+        lastImportEnd = lineEnd;
+      }
+    }
+  }
+  if (lastImportEnd > 0) {
+    return content.slice(0, lastImportEnd) + "\n" + importStmt + content.slice(lastImportEnd);
+  }
+  return importStmt + "\n\n" + content;
+}
+function injectIntoPluginsArray(content, detection) {
+  const tool = detection.tool;
+  if (tool === "rsbuild") {
+    if (!content.includes("tools:") && !content.includes("rspack:")) {
+      const exportRegex = /(export default defineConfig\(\{)/;
+      const match2 = exportRegex.exec(content);
+      if (match2) {
+        const insertPos2 = match2.index + match2[0].length;
+        const pluginExpr2 = `
+  tools: {
+    rspack: {
+      plugins: [
+        ${getPluginExpression(detection.isLegacyRspack)}
+      ]
+    }
+  },`;
+        return content.slice(0, insertPos2) + pluginExpr2 + content.slice(insertPos2);
+      }
+    }
+    return null;
+  }
+  const pluginsRegex = /(plugins\s*:\s*\[)/;
+  const match = pluginsRegex.exec(content);
+  if (!match) return null;
+  const insertPos = match.index + match[0].length;
+  const pluginExpr = `
+    ${getPluginExpression(detection.isLegacyRspack)},`;
+  return content.slice(0, insertPos) + pluginExpr + content.slice(insertPos);
+}
+function validateBrackets(content) {
+  const openBraces = (content.match(/\{/g) || []).length;
+  const closeBraces = (content.match(/\}/g) || []).length;
+  const openBrackets = (content.match(/\[/g) || []).length;
+  const closeBrackets = (content.match(/\]/g) || []).length;
+  return Math.abs(openBraces - closeBraces) <= 1 && Math.abs(openBrackets - closeBrackets) <= 1;
+}
+async function injectPlugin(root, detection, dryRun) {
+  const configPath = path7.join(root, detection.configPath);
+  const backupPath = configPath + ".bak";
+  const mutations = [];
+  const content = await readFile(configPath);
+  if (!content) {
+    printManualInstructions(
+      detection.tool,
+      detection.configPath,
+      "config file not readable",
+      detection.isLegacyRspack
+    );
+    return { success: false, mutations, failureReason: "config file not readable" };
+  }
+  if (isAlreadyInjected(content)) {
+    log.success(`Plugin already injected in ${detection.configPath} (skipped)`);
+    if (await exists(backupPath)) {
+      mutations.push({
+        type: "file_modified",
+        path: detection.configPath,
+        backup: detection.configPath + ".bak",
+        description: "Previously injected inspecto() plugin"
+      });
+    } else {
+      mutations.push({
+        type: "file_modified",
+        path: detection.configPath,
+        description: "Previously injected inspecto() plugin (no backup)"
+      });
+    }
+    return { success: true, mutations };
+  }
+  if (!dryRun) {
+    await copyFile(configPath, backupPath);
+    mutations.push({
+      type: "file_modified",
+      path: detection.configPath,
+      backup: detection.configPath + ".bak",
+      description: "Injected inspecto() plugin"
+    });
+  }
+  log.success(`Backed up ${detection.configPath} \u2192 ${detection.configPath}.bak`);
+  const injected = injectIntoPluginsArray(content, detection);
+  if (!injected) {
+    printManualInstructions(
+      detection.tool,
+      detection.configPath,
+      "could not locate plugins array \u2014 file may use dynamic config, function wrapper, or non-standard export",
+      detection.isLegacyRspack
+    );
+    return {
+      success: false,
+      mutations,
+      failureReason: "could not locate plugins array"
+    };
+  }
+  const importStmt = getImportStatement(detection.tool, detection.isLegacyRspack);
+  const modifiedContent = injectImport(injected, importStmt);
+  if (!validateBrackets(modifiedContent)) {
+    log.error("Syntax validation failed after injection");
+    if (!dryRun) {
+      await copyFile(backupPath, configPath);
+      log.success(`Restored ${detection.configPath} from backup`);
+    }
+    printManualInstructions(
+      detection.tool,
+      detection.configPath,
+      "injection produced unbalanced brackets",
+      detection.isLegacyRspack
+    );
+    return {
+      success: false,
+      mutations: [],
+      // Rolled back
+      failureReason: "injection produced invalid syntax"
+    };
+  }
+  if (dryRun) {
+    log.dryRun(`Would inject plugin into ${detection.configPath}`);
+  } else {
+    await writeFile(configPath, modifiedContent);
+    log.success(`Injected plugin into ${detection.configPath}`);
+  }
+  return { success: true, mutations };
+}
+
+// src/inject/gitignore.ts
+import path8 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) {
+  const gitignorePath = path8.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);
+    }
+    log.success("Updated .gitignore: .inspecto/settings.json is now trackable");
+    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) {
+    log.dryRun(`Would update .gitignore with: ${missingRules.join(", ")}`);
+  } else {
+    await writeFile(gitignorePath, content);
+    log.success("Updated .gitignore");
+  }
+}
+async function cleanGitignore(root) {
+  const gitignorePath = path8.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/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;
+    const openCmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+    await shell(`${openCmd} "${uri}"`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installExtension(dryRun) {
+  if (dryRun) {
+    log.dryRun("Would attempt to install VS Code extension");
+    return null;
+  }
+  if (await which("code")) {
+    try {
+      await run("code", ["--install-extension", EXTENSION_ID]);
+      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]);
+      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)) {
+    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 };
+  }
+  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;
+}
+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/commands/init.ts
+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];
+  }
+  console.log();
+  console.log("  ? Detected multiple IDEs:");
+  detections.forEach((d, i) => {
+    const status = d.supported ? " (supported)" : " (unsupported/limited)";
+    console.log(`      ${i + 1}. ${d.ide}${status}`);
+  });
+  console.log();
+  return new Promise((resolve) => {
+    process.stdout.write("  > Your choice: ");
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    const onData = (data) => {
+      const choice = parseInt(String(data).trim(), 10);
+      process.stdin.off("data", onData);
+      process.stdin.pause();
+      if (choice >= 1 && choice <= detections.length) {
+        resolve(detections[choice - 1]);
+      } else {
+        resolve(null);
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function promptAIToolChoice(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];
+  }
+  console.log();
+  console.log("  ? Detected multiple AI tools:");
+  detections.forEach((d, i) => {
+    const modeLabels = d.toolModes.map(
+      (mode) => mode === "plugin" ? "VS Code Extension" : "Terminal CLI"
+    );
+    const modeStr = modeLabels.join(" & ");
+    const status = d.supported ? ` (supported ${modeStr})` : ` (unsupported/limited)`;
+    console.log(`      ${i + 1}. ${d.label}${status}`);
+  });
+  console.log();
+  return new Promise((resolve) => {
+    process.stdout.write("  > Your choice: ");
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    const onData = (data) => {
+      const choice = parseInt(String(data).trim(), 10);
+      process.stdin.off("data", onData);
+      process.stdin.pause();
+      if (choice >= 1 && choice <= detections.length) {
+        resolve(detections[choice - 1]);
+      } else {
+        resolve(null);
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+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];
+  }
+  console.log();
+  console.log("  ? Detected multiple build tool configs:");
+  detections.forEach((d, i) => {
+    console.log(`      ${i + 1}. ${d.label}`);
+  });
+  console.log(`      ${detections.length + 1}. Skip (I'll configure manually)`);
+  console.log();
+  return new Promise((resolve) => {
+    process.stdout.write("  > Your choice: ");
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    const onData = (data) => {
+      const choice = parseInt(String(data).trim(), 10);
+      process.stdin.off("data", onData);
+      process.stdin.pause();
+      if (choice >= 1 && choice <= detections.length) {
+        resolve(detections[choice - 1]);
+      } else {
+        resolve(null);
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function init(options) {
+  const root = process.cwd();
+  const mutations = [];
+  log.header("Inspecto Setup");
+  if (!await exists(path9.join(root, "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(root);
+  log.success(`Detected package manager: ${pm}`);
+  const frameworkResult = await detectFrameworks(root);
+  if (frameworkResult.supported.length > 0) {
+    log.success(`Detected framework: ${frameworkResult.supported.join(", ")}`);
+  }
+  if (frameworkResult.unsupported.length > 0) {
+    const names = frameworkResult.unsupported.map((f) => f.name).join(", ");
+    log.warn(`Detected ${names} \u2014 not supported in v1 (React / Vue only)`);
+    log.hint("Inspecto may still work but is not tested for this framework");
+  }
+  if (frameworkResult.supported.length === 0 && frameworkResult.unsupported.length === 0) {
+    log.warn("No frontend framework detected");
+    log.hint("Inspecto v1 supports React and Vue projects");
+  }
+  const buildResult = await detectBuildTools(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(", ");
+    log.warn(`Detected ${names} \u2014 not supported in v1`);
+    log.hint("v1 supports: Vite, Webpack, Rspack, esbuild, Rollup");
+    log.hint("Meta-framework support (Next.js, Nuxt, etc.) is planned for v2");
+  }
+  if (buildResult.supported.length === 0 && buildResult.unsupported.length === 0) {
+    log.warn("No recognized build tool detected");
+    log.hint("v1 supports: Vite, Webpack, Rspack, esbuild, Rollup");
+    log.hint("Dependency will be installed but plugin injection will be skipped");
+  }
+  const ideProbe = await detectIDE(root);
+  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}.`);
+    }
+  }
+  const aiToolProbe = await detectAITools(root);
+  let selectedAITool = null;
+  if (!options.prefer) {
+    if (aiToolProbe.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 (aiToolProbe.detected.length === 1) {
+      selectedAITool = aiToolProbe.detected[0];
+      if (selectedAITool.supported) {
+        log.success(`Detected AI tool: ${selectedAITool.label}`);
+      }
+    } else {
+      selectedAITool = await promptAIToolChoice(aiToolProbe.detected);
+      if (selectedAITool) {
+        log.success(`Selected AI tool: ${selectedAITool.label}`);
+      }
+    }
+  }
+  let installFailed = false;
+  if (options.skipInstall) {
+    log.warn("Skipping dependency installation (--skip-install)");
+  } else {
+    const installCmd = getInstallCommand(pm, "@inspecto-dev/plugin");
+    if (options.dryRun) {
+      log.dryRun(`Would run: ${installCmd}`);
+    } else {
+      try {
+        const result = await shell(installCmd, root);
+        if (result.stderr && result.stderr.toLowerCase().includes("error")) {
+          throw new Error(result.stderr);
+        }
+        log.success("Installed @inspecto-dev/plugin as devDependency");
+        mutations.push({
+          type: "dependency_added",
+          name: "@inspecto-dev/plugin",
+          dev: true
+        });
+      } catch (err) {
+        installFailed = true;
+        log.error(`Failed to install dependency: ${err?.message || "Unknown error"}`);
+        log.hint(`Run manually: ${installCmd}`);
+      }
+    }
+  }
+  let injectionFailed = false;
+  if (buildResult.supported.length > 0) {
+    let target = resolveInjectionTarget(buildResult.supported);
+    if (target === "ambiguous") {
+      target = await promptConfigChoice(buildResult.supported);
+    }
+    if (target) {
+      const result = await injectPlugin(root, target, options.dryRun);
+      if (result.success) {
+        mutations.push(...result.mutations);
+      } else {
+        injectionFailed = true;
+      }
+    } else {
+      injectionFailed = true;
+      log.warn("Skipping plugin injection (manual configuration required)");
+    }
+  }
+  const settingsDir = path9.join(root, ".inspecto");
+  const settingsPath = path9.join(settingsDir, "settings.json");
+  const promptsPath = path9.join(settingsDir, "prompts.json");
+  if (await exists(settingsPath)) {
+    const existingSettings = await readJSON(settingsPath);
+    if (existingSettings === null) {
+      log.warn(".inspecto/settings.json exists but contains invalid JSON");
+      log.hint("Please fix the syntax errors manually, or delete it and re-run init");
+    } else {
+      log.success(".inspecto/settings.json already exists (skipped)");
+    }
+  } else {
+    const defaultSettings = {};
+    if (selectedIDE && selectedIDE.supported) {
+      defaultSettings.ide = selectedIDE.ide === "vscode" ? "vscode" : selectedIDE.ide;
+    }
+    if (options.prefer) {
+      defaultSettings.prefer = options.prefer;
+    } else if (selectedAITool) {
+      defaultSettings.prefer = selectedAITool.id;
+      if (selectedAITool.preferredMode) {
+        defaultSettings.providers = {
+          [selectedAITool.id]: {
+            type: selectedAITool.preferredMode
+          }
+        };
+      }
+    }
+    if (options.dryRun) {
+      log.dryRun("Would create .inspecto/settings.json");
+    } else {
+      await writeJSON(settingsPath, defaultSettings);
+      log.success("Created .inspecto/settings.json");
+      mutations.push({ type: "file_created", path: ".inspecto/settings.json" });
+    }
+  }
+  if (await exists(promptsPath)) {
+    log.success(".inspecto/prompts.json already exists (skipped)");
+  } else {
+    const defaultPrompts = [
+      { id: "code-review", enabled: false },
+      { id: "generate-test", enabled: false },
+      { id: "performance", enabled: false }
+    ];
+    if (options.dryRun) {
+      log.dryRun("Would create .inspecto/prompts.json");
+    } else {
+      await writeJSON(promptsPath, defaultPrompts);
+      log.success("Created .inspecto/prompts.json (disabling low-frequency intents)");
+      mutations.push({ type: "file_created", path: ".inspecto/prompts.json" });
+    }
+  }
+  if (!options.dryRun) {
+    await updateGitignore(root, options.shared, options.dryRun);
+    mutations.push({
+      type: "file_modified",
+      path: ".gitignore",
+      description: "Appended .inspecto/ ignore rules"
+    });
+  } else {
+    log.dryRun("Would update .gitignore");
+  }
+  if (!options.dryRun && mutations.length > 0) {
+    const lock = {
+      version: "1.0.0",
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      mutations
+    };
+    await writeJSON(path9.join(settingsDir, "install.lock"), lock);
+  }
+  const shouldInstallExt = !options.noExtension && (!selectedIDE || selectedIDE && selectedIDE.supported);
+  let manualExtensionInstallNeeded = false;
+  if (options.noExtension) {
+    log.warn("Skipping VS Code extension (--no-extension)");
+  } else if (!shouldInstallExt) {
+  } else {
+    const extMutation = await installExtension(options.dryRun);
+    if (extMutation && !options.dryRun) {
+      mutations.push(extMutation);
+      if (extMutation.manual_action_required) {
+        manualExtensionInstallNeeded = true;
+      }
+      const lockPath = path9.join(settingsDir, "install.lock");
+      const lock = await readJSON(lockPath);
+      if (lock) {
+        lock.mutations = mutations;
+        await writeJSON(lockPath, lock);
+      }
+    } else if (extMutation === null && !options.dryRun) {
+      manualExtensionInstallNeeded = true;
+    }
+  }
+  if (options.dryRun) {
+    log.blank();
+    log.warn("Dry run complete. No files were modified.");
+  } else if (installFailed || injectionFailed || manualExtensionInstallNeeded) {
+    log.blank();
+    log.warn("Setup completed with some manual steps required.");
+    log.hint("Please check the logs above and complete the manual steps.");
+    log.blank();
+  } else {
+    log.ready("Ready! Hold Alt + Click any element to inspect.");
+  }
+}
+
+// src/commands/doctor.ts
+import path10 from "path";
+async function doctor() {
+  const root = process.cwd();
+  const result = { errors: 0, warnings: 0 };
+  log.header("Inspecto Doctor");
+  if (!await exists(path10.join(root, "package.json"))) {
+    log.error("No package.json found");
+    log.hint("Run this command from your project root");
+    return;
+  }
+  const ideProbe = await detectIDE(root);
+  if (ideProbe.detected.length === 0) {
+    log.warn("IDE: not detected");
+    result.warnings++;
+  } else {
+    const hasSupported = ideProbe.detected.some((d) => d.supported);
+    if (hasSupported) {
+      log.success(
+        `IDE: ${ideProbe.detected.filter((d) => d.supported).map((d) => d.ide).join(", ")}`
+      );
+    } else {
+      const names = ideProbe.detected.map((d) => d.ide).join(", ");
+      log.warn(`IDE: ${names} (not supported in v1, VS Code only)`);
+      result.warnings++;
+    }
+  }
+  const frameworkResult = await detectFrameworks(root);
+  if (frameworkResult.supported.length > 0) {
+    log.success(`Framework: ${frameworkResult.supported.join(", ")}`);
+  } else if (frameworkResult.unsupported.length > 0) {
+    const names = frameworkResult.unsupported.map((f) => f.name).join(", ");
+    log.warn(`Framework: ${names} (not supported in v1, React/Vue only)`);
+    result.warnings++;
+  } else {
+    log.warn("Framework: not detected (React / Vue expected)");
+    result.warnings++;
+  }
+  const aiProbe = await detectAITools(root);
+  if (aiProbe.detected.length === 0) {
+    log.warn("AI Tool: none detected");
+    log.hint("Inspecto works best with Claude Code, Trae CLI, or GitHub Copilot");
+    result.warnings++;
+  } else {
+    const aiNames = aiProbe.detected.map((d) => {
+      const modeLabels = d.toolModes.map(
+        (mode) => mode === "plugin" ? "VS Code Extension" : "Terminal CLI"
+      );
+      return `${d.label} (${modeLabels.join(" & ")})`;
+    }).join(", ");
+    log.success(`AI Tool: ${aiNames}`);
+  }
+  const pluginPath = path10.join(root, "node_modules", "@inspecto", "plugin");
+  if (await exists(pluginPath)) {
+    const pkgJson = await readJSON(path10.join(pluginPath, "package.json"));
+    const version = pkgJson?.version ?? "unknown";
+    log.success(`@inspecto-dev/plugin@${version} installed`);
+  } else {
+    log.error("@inspecto-dev/plugin not installed");
+    const pm = await detectPackageManager(root);
+    log.hint(`Fix: ${getInstallCommand(pm, "@inspecto-dev/plugin")}`);
+    result.errors++;
+  }
+  const buildResult = await detectBuildTools(root);
+  if (buildResult.supported.length > 0) {
+    let injected = false;
+    for (const bt of buildResult.supported) {
+      const content = await readFile(path10.join(root, bt.configPath));
+      if (content && content.includes("@inspecto-dev/plugin")) {
+        log.success(`Plugin injected in ${bt.configPath}`);
+        injected = true;
+        break;
+      }
+    }
+    if (!injected) {
+      log.error("Plugin not injected in any build config");
+      log.hint("Fix: npx inspecto init");
+      result.errors++;
+    }
+  } else if (buildResult.unsupported.length > 0) {
+    const names = buildResult.unsupported.join(", ");
+    log.warn(`Build tool: ${names} (not supported in v1)`);
+    log.hint("v1 supports: Vite, Webpack, Rspack, esbuild, Rollup");
+    result.warnings++;
+  } else {
+    log.warn("No recognized build config found");
+    result.warnings++;
+  }
+  const extInstalled = await isExtensionInstalled();
+  if (extInstalled) {
+    log.success("VS Code extension detected");
+  } else {
+    const hasSupported = ideProbe.detected.some((d) => d.supported);
+    if (ideProbe.detected.length > 0 && !hasSupported) {
+      log.warn("VS Code extension not applicable (non-VS Code IDE)");
+    } else {
+      log.error("VS Code extension not found");
+      log.hint("Fix: code --install-extension inspecto.inspecto");
+      log.hint("Or: https://marketplace.visualstudio.com/items?itemName=inspecto.inspecto");
+      result.errors++;
+    }
+  }
+  const settingsPath = path10.join(root, ".inspecto", "settings.json");
+  if (await exists(settingsPath)) {
+    const settings = await readJSON(settingsPath);
+    if (settings) {
+      log.success(".inspecto/settings.json valid");
+    } else {
+      log.error(".inspecto/settings.json has invalid JSON");
+      log.hint(
+        "Fix: Manually correct the syntax errors, or delete the file and re-run npx inspecto init"
+      );
+      result.errors++;
+    }
+  } else {
+    log.warn(".inspecto/settings.json not found (using defaults)");
+    log.hint("Optional: npx inspecto init");
+    result.warnings++;
+  }
+  const gitignoreContent = await readFile(path10.join(root, ".gitignore"));
+  if (gitignoreContent) {
+    const hasLockIgnore = gitignoreContent.includes(".inspecto/install.lock") || gitignoreContent.includes(".inspecto/");
+    if (!hasLockIgnore) {
+      log.warn(".inspecto/install.lock not in .gitignore");
+      log.hint("install.lock contains local machine state and should not be committed");
+      result.warnings++;
+    }
+  }
+  log.blank();
+  if (result.errors === 0 && result.warnings === 0) {
+    log.success("All checks passed. Hold Alt + Click to start!");
+  } else {
+    const parts = [];
+    if (result.errors > 0) parts.push(`${result.errors} error(s)`);
+    if (result.warnings > 0) parts.push(`${result.warnings} warning(s)`);
+    console.log(
+      `  ${parts.join(", ")}. ${result.errors > 0 ? "Fix the errors above to get started." : ""}`
+    );
+  }
+  log.blank();
+}
+
+// src/commands/teardown.ts
+import path11 from "path";
+async function teardown() {
+  const root = process.cwd();
+  log.header("Inspecto Teardown");
+  const lockPath = path11.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(path11.join(root, ".inspecto"))) {
+      await removeDir(path11.join(root, ".inspecto"));
+      log.success("Deleted .inspecto/ directory");
+    }
+    await cleanGitignore(root);
+    log.success("Cleaned .gitignore entries");
+    log.warn("Cannot restore build config (no backup reference)");
+    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.backup && mutation.path) {
+          const backupPath = path11.join(root, mutation.backup);
+          const targetPath = path11.join(root, mutation.path);
+          if (mutation.path === ".gitignore") {
+            await cleanGitignore(root);
+            log.success("Cleaned .gitignore entries");
+            await removeFile(backupPath);
+          } else if (await exists(backupPath)) {
+            await copyFile(backupPath, targetPath);
+            await removeFile(backupPath);
+            log.success(`Restored ${mutation.path} from backup`);
+          } else {
+            log.warn(`Backup not found: ${mutation.backup}`);
+            log.hint(`Please manually remove inspecto from ${mutation.path}`);
+          }
+        } else if (mutation.path && mutation.path !== ".gitignore") {
+          log.warn(`Cannot auto-restore ${mutation.path} (no backup recorded)`);
+          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(path11.join(root, ".inspecto"));
+  log.success("Deleted .inspecto/ directory");
+  await cleanGitignore(root);
+  log.blank();
+  log.success("Done. All Inspecto traces removed.");
+  log.blank();
+}
+
+export {
+  log,
+  init,
+  doctor,
+  teardown
+};