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

package/dist/chunk-MIHQGC3L.js

@@ -1,1720 +0,0 @@
-// 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 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"]
-  ];
-  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/detect/build-tool.ts
-import path3 from "path";
-import { createRequire } from "module";
-function isPackageResolvable(pkgName, root) {
-  try {
-    const require2 = createRequire(path3.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(path3.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 = path3.relative(root, filePath);
-  const normalized = relative.split(path3.sep).join("/");
-  return normalized || path3.basename(filePath);
-}
-function createTargets(root, packagePaths) {
-  if (!packagePaths || packagePaths.length === 0) {
-    return [{ packagePath: "", absolutePath: root }];
-  }
-  return packagePaths.map((pkg) => ({
-    packagePath: pkg,
-    absolutePath: pkg ? path3.join(root, pkg) : root
-  }));
-}
-async function detectBuildTools(root, packagePaths) {
-  const supported = [];
-  const unsupported = /* @__PURE__ */ new Set();
-  const targets = createTargets(root, packagePaths);
-  for (const target of targets) {
-    const pkg = await readJSON(path3.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(path3.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 = "";
-  if (pattern.tool === "esbuild" && !hasDep) {
-    return null;
-  }
-  for (const file of pattern.files) {
-    if (await exists(path3.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(path3.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(path3.join(targetRoot, configMatch[1]))) {
-              detectedFile = configMatch[1];
-              break;
-            }
-          }
-        }
-        if (!detectedFile) {
-          detectedFile = "package.json (scripts)";
-          break;
-        }
-      }
-    }
-  }
-  if (!detectedFile) {
-    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 = path3.join(targetRoot, detectedFile);
-  const relativeConfig = normalizeRelativePath(workspaceRoot, absoluteConfig);
-  return {
-    tool: pattern.tool,
-    configPath: relativeConfig,
-    label: `${pattern.label} (${relativeConfig})${isLegacyRspack ? " [Legacy]" : ""}${isLegacyWebpack ? " [Webpack 4]" : ""}`,
-    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 path4 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(path4.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(path4.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 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: 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(path5.join(root, ".trae")),
-    exists(path5.join(root, ".cursor")),
-    exists(path5.join(root, ".vscode")),
-    exists(path5.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 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: "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 = 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);
-  let installedExtensionFolders = [];
-  if (globalExtExists) {
-    try {
-      const { readdir } = await import("fs/promises");
-      installedExtensionFolders = await readdir(globalExtDir);
-      const obsoletePath = path6.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/inject/ast-injector.ts
-import path7 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) {
-  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.codeBlock(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) {
-  const configPath = path7.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");
-    return { success: false, mutations, failureReason: "config file not readable" };
-  }
-  if (isAlreadyInjected(content)) {
-    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}`
-    );
-    return { success: false, mutations, failureReason: "No strategy found" };
-  }
-  if (dryRun) {
-    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"
-    });
-    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)}`
-    );
-    return {
-      success: false,
-      mutations,
-      failureReason: "Automatic configuration unavailable"
-    };
-  }
-}
-
-// 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/ 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) {
-    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;
-    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) {
-  if (dryRun) {
-    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]);
-        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;
-  }
-  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 from Inspecto releases");
-  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/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
-      };
-    })
-  });
-  if (choice === void 0) 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 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("To enable Inspecto in Nuxt, update your nuxt.config.ts:");
-  console.log(`\x1B[36m
-  import { vitePlugin as inspecto } from '@inspecto-dev/plugin'
-  export default defineNuxtConfig({
-    vite: {
-      plugins: [inspecto()]
-    }
-  })
-\x1B[0m`);
-  log.hint("And create a Nuxt plugin at plugins/inspecto.client.ts:");
-  console.log(`\x1B[36m
-  export default defineNuxtPlugin(() => {
-    if (import.meta.dev) {
-      import('@inspecto-dev/core').then(({ mountInspector }) => {
-        mountInspector()
-      })
-    }
-  })
-\x1B[0m`);
-}
-function printNextJsManualInstructions() {
-  log.blank();
-  log.hint("To enable Inspecto in Next.js, update your next.config.mjs:");
-  console.log(`\x1B[36m
-  import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'
-  const nextConfig = {
-    webpack: (config, { dev, isServer }) => {
-      if (dev && !isServer) config.plugins.push(inspecto())
-      return config
-    }
-  }
-  export default nextConfig
-\x1B[0m`);
-  log.hint("And initialize the client dynamically in your app/layout.tsx (or pages/_app.tsx):");
-  console.log(`\x1B[36m
-  '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>
-  }
-\x1B[0m`);
-}
-
-// src/commands/init.ts
-async function init(options) {
-  const root = process.cwd();
-  const mutations = [];
-  const normalizedPackages = normalizePackageList(options.packages);
-  const verifiedPackages = [];
-  for (const pkg of normalizedPackages) {
-    if (!pkg) {
-      verifiedPackages.push(pkg);
-      continue;
-    }
-    const absolutePath = path9.join(root, 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(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, frameworkResult, buildResult, ideProbe, providerProbe] = await Promise.all([
-    detectPackageManager(root),
-    detectFrameworks(root),
-    detectBuildTools(root, verifiedPackages.length > 0 ? verifiedPackages : void 0),
-    detectIDE(root),
-    detectProviders(root)
-  ]);
-  log.success(`Detected package manager: ${pm}`);
-  if (frameworkResult.supported.length > 0) {
-    log.success(`Detected framework: ${frameworkResult.supported.join(", ")}`);
-  }
-  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.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;
-  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 {
-      selectedProvider = await promptProviderChoice(providerProbe.detected);
-      if (selectedProvider) {
-        log.success(`Selected provider: ${selectedProvider.label}`);
-      }
-    }
-  }
-  let installFailed = false;
-  if (options.skipInstall) {
-    log.warn("Skipping dependency installation (--skip-install)");
-  } else {
-    const installCmd = getInstallCommand(pm, "@inspecto-dev/plugin @inspecto-dev/core");
-    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 and @inspecto-dev/core as devDependencies");
-        mutations.push({ type: "dependency_added", name: "@inspecto-dev/plugin", dev: true });
-        mutations.push({ type: "dependency_added", name: "@inspecto-dev/core", 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) {
-    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) {
-        injectionFailed = true;
-      }
-      for (const target of targets) {
-        const result = await injectPlugin(root, target, options.dryRun);
-        if (result.success) {
-          mutations.push(...result.mutations);
-        } else {
-          injectionFailed = true;
-        }
-      }
-    } else {
-      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 settingsFileName = options.shared ? "settings.json" : "settings.local.json";
-  const promptsFileName = options.shared ? "prompts.json" : "prompts.local.json";
-  const settingsPath = path9.join(settingsDir, settingsFileName);
-  const promptsPath = path9.join(settingsDir, promptsFileName);
-  if (await exists(settingsPath)) {
-    const existingSettings = await readJSON(settingsPath);
-    if (existingSettings === null) {
-      log.warn(`.inspecto/${settingsFileName} exists but contains invalid JSON`);
-      log.hint("Please fix the syntax errors manually, or delete it and re-run init");
-    } else {
-      log.success(`.inspecto/${settingsFileName} already exists (skipped)`);
-    }
-  } else {
-    const defaultSettings = {};
-    if (selectedIDE && selectedIDE.supported) {
-      defaultSettings.ide = selectedIDE.ide.toLowerCase() === "vscode" ? "vscode" : selectedIDE.ide.toLowerCase();
-    }
-    if (options.provider) {
-      const tool = options.provider;
-      const mode = tool === "coco" ? "cli" : "extension";
-      defaultSettings["provider.default"] = `${tool}.${mode}`;
-    } else if (selectedProvider) {
-      const toolId = selectedProvider.id;
-      const mode = selectedProvider.preferredMode === "cli" ? "cli" : "extension";
-      defaultSettings["provider.default"] = `${toolId}.${mode}`;
-    }
-    if (options.dryRun) {
-      log.dryRun(`Would create .inspecto/${settingsFileName}`);
-    } else {
-      await writeJSON(settingsPath, defaultSettings);
-      log.success(`Created .inspecto/${settingsFileName}`);
-      mutations.push({ type: "file_created", path: `.inspecto/${settingsFileName}` });
-    }
-  }
-  if (await exists(promptsPath)) {
-    log.success(`.inspecto/${promptsFileName} already exists (skipped)`);
-  } else {
-    const defaultPrompts = [];
-    if (options.dryRun) {
-      log.dryRun(`Would create .inspecto/${promptsFileName}`);
-    } else {
-      await writeJSON(promptsPath, defaultPrompts);
-      log.success(`Created .inspecto/${promptsFileName}`);
-      mutations.push({ type: "file_created", path: `.inspecto/${promptsFileName}` });
-    }
-  }
-  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 IDE extension (--no-extension)");
-  } else if (!shouldInstallExt) {
-  } else {
-    const extMutation = await installExtension(options.dryRun, selectedIDE?.ide);
-    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 || manualConfigRequiredFor) {
-    log.blank();
-    log.warn("Setup completed with some manual steps required.");
-    if (manualConfigRequiredFor === "Nuxt") {
-      printNuxtManualInstructions();
-    } else if (manualConfigRequiredFor === "Next.js") {
-      printNextJsManualInstructions();
-    } else {
-      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.");
-  }
-}
-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));
-}
-
-// 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, frameworkResult, providerProbe, pm, buildResult, extInstalled] = await Promise.all([
-    detectIDE(root),
-    detectFrameworks(root),
-    detectProviders(root),
-    detectPackageManager(root),
-    detectBuildTools(root),
-    isExtensionInstalled()
-  ]);
-  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, Cursor, Trae only)`);
-      result.warnings++;
-    }
-  }
-  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++;
-  }
-  if (providerProbe.detected.length === 0) {
-    log.warn("Provider: none detected");
-    log.hint("Inspecto works best with Claude Code, Trae CLI, or GitHub Copilot");
-    result.warnings++;
-  } 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(", ");
-    log.success(`Provider: ${aiNames}`);
-  }
-  const pluginPath = path10.join(root, "node_modules", "@inspecto-dev", "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 pm2 = await detectPackageManager(root);
-    log.hint(`Fix: ${getInstallCommand(pm2, "@inspecto-dev/plugin")}`);
-    result.errors++;
-  }
-  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 configured in ${bt.configPath}`);
-        injected = true;
-        break;
-      }
-    }
-    if (!injected) {
-      log.error("Plugin not configured in any build config");
-      log.hint("Fix: npx @inspecto-dev/cli 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("current version supports: Vite, Webpack, Rspack, esbuild, Rollup");
-    result.warnings++;
-  } else {
-    log.warn("No recognized build config found");
-    result.warnings++;
-  }
-  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 settingsJsonPath = path10.join(root, ".inspecto", "settings.json");
-  const settingsLocalPath = path10.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) {
-      log.success(`.inspecto/${fileName} valid`);
-    } else {
-      log.error(`.inspecto/${fileName} has invalid JSON`);
-      log.hint(
-        "Fix: Manually correct the syntax errors, or delete the file and re-run npx @inspecto-dev/cli init"
-      );
-      result.errors++;
-    }
-  } else {
-    log.warn("No .inspecto/settings.json or settings.local.json found (using defaults)");
-    log.hint("Optional: npx @inspecto-dev/cli 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 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(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
-};