@inspecto-dev/cli 0.2.0-alpha.1 → 0.2.0-alpha.3

package/dist/{chunk-DBXT75QF.js → chunk-HIL6365F.js}

@@ -77,15 +77,6 @@ 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 });
@@ -146,9 +137,15 @@ async function detectPackageManager(root) {
     ["yarn.lock", "yarn"],
     ["package-lock.json", "npm"]
   ];
-  for (const [file, pm] of checks) {
-    if (await exists(path2.join(root, file))) {
-      return pm;
+  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";
@@ -180,6 +177,31 @@ function getUninstallCommand(pm, 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",
@@ -203,7 +225,7 @@ var SUPPORTED_PATTERNS = [
   },
   {
     tool: "esbuild",
-    files: ["esbuild.config.js", "esbuild.config.ts", "esbuild.config.mjs"],
+    files: ["esbuild.config.js", "esbuild.config.ts", "esbuild.config.mjs", "build.js", "build.ts"],
     label: "esbuild"
   },
   {
@@ -224,34 +246,110 @@ async function detectBuildTools(root) {
   const unsupported = [];
   const pkg = await readJSON(path3.join(root, "package.json"));
   const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
-  for (const pattern of SUPPORTED_PATTERNS) {
+  const supportedChecks = SUPPORTED_PATTERNS.map(async (pattern) => {
+    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", root);
+      if (hasDep) {
+        resolvedVersion = allDeps[depName] || await getResolvedPackageVersion("@rspack/core", root);
+      }
+    } else if (pattern.tool === "webpack") {
+      const depName = allDeps["webpack"] ? "webpack" : "webpack-cli";
+      hasDep = !!allDeps["webpack"] || !!allDeps["webpack-cli"] || isPackageResolvable("webpack", root);
+      if (hasDep) {
+        resolvedVersion = allDeps[depName] || await getResolvedPackageVersion("webpack", root);
+      }
+    } else if (pattern.tool === "rsbuild") {
+      hasDep = !!allDeps["@rsbuild/core"] || isPackageResolvable("@rsbuild/core", root);
+    } else {
+      hasDep = !!allDeps[pattern.tool] || isPackageResolvable(pattern.tool, root);
+    }
+    let detectedFile = "";
+    if (pattern.tool === "esbuild" && !hasDep) {
+      return null;
+    }
     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;
+        detectedFile = file;
+        break;
+      }
+    }
+    if (hasDep && !detectedFile && (pattern.tool === "esbuild" || pattern.tool === "rollup" || pattern.tool === "webpack" || pattern.tool === "rspack" || pattern.tool === "rsbuild")) {
+      const scripts = pkg?.scripts || {};
+      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(root, 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(root, configMatch[1]))) {
+                detectedFile = configMatch[1];
+                break;
+              }
+            }
+          }
+          if (!detectedFile) {
+            detectedFile = "package.json (scripts)";
+            break;
           }
         }
-        supported.push({
-          tool: pattern.tool,
-          configPath: file,
-          label: `${pattern.label} (${file})${isLegacyRspack ? " [Legacy]" : ""}`,
-          isLegacyRspack
-        });
-        break;
       }
     }
+    if (detectedFile) {
+      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;
+        }
+      }
+      return {
+        tool: pattern.tool,
+        configPath: detectedFile,
+        label: `${pattern.label} (${detectedFile})${isLegacyRspack ? " [Legacy]" : ""}${isLegacyWebpack ? " [Webpack 4]" : ""}`,
+        isLegacyRspack,
+        isLegacyWebpack
+      };
+    }
+    return null;
+  });
+  const supportedResults = await Promise.all(supportedChecks);
+  for (const result of supportedResults) {
+    if (result) {
+      supported.push(result);
+    }
   }
-  for (const meta of UNSUPPORTED_META) {
-    if (!(meta.dep in allDeps)) continue;
+  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(root, file))) {
-        unsupported.push(meta.name);
-        break;
+        return meta.name;
       }
     }
+    return null;
+  });
+  const unsupportedResults = await Promise.all(unsupportedChecks);
+  for (const result of unsupportedResults) {
+    if (result) {
+      unsupported.push(result);
+    }
   }
   return { supported, unsupported };
 }
@@ -263,6 +361,18 @@ function resolveInjectionTarget(detections) {
 
 // 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"] }
@@ -274,26 +384,53 @@ var UNSUPPORTED_FRAMEWORKS = [
   { 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"));
-  if (!pkg) return { supported: [], unsupported: [] };
   const allDeps = {
-    ...pkg.dependencies,
-    ...pkg.devDependencies
+    ...pkg?.dependencies || {},
+    ...pkg?.devDependencies || {},
+    ...pkg?.peerDependencies || {}
   };
-  const supported = [];
+  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 (deps.some((dep) => dep in allDeps)) {
-      supported.push(framework);
+    if (supportedSet.has(framework)) continue;
+    for (const dep of deps) {
+      if (dep in allDeps || !isTest && isPackageResolvable2(dep, root)) {
+        supportedSet.add(framework);
+        break;
+      }
     }
   }
-  const unsupported = [];
   for (const fw of UNSUPPORTED_FRAMEWORKS) {
-    if (fw.dep in allDeps) {
+    if (fw.dep in allDeps || !isTest && isPackageResolvable2(fw.dep, root)) {
       unsupported.push(fw);
     }
   }
-  return { supported, unsupported };
+  return {
+    supported: Array.from(supportedSet),
+    unsupported
+  };
 }
 
 // src/detect/ide.ts
@@ -302,39 +439,44 @@ 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 });
+    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: false });
+    detected.set("Trae", { ide: "trae", supported: true });
   }
   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 (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 });
   }
-  if (await exists(path5.join(root, ".trae"))) {
-    detected.set("Trae", { ide: "Trae", 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 (await exists(path5.join(root, ".cursor"))) {
-    detected.set("Cursor", { ide: "Cursor", supported: false });
+  if (hasCursor && !detected.has("Cursor")) {
+    detected.set("Cursor", { ide: "cursor", supported: true });
   }
-  if (await exists(path5.join(root, ".vscode"))) {
-    if (!detected.has("vscode")) {
-      detected.set("vscode", { ide: SUPPORTED_IDE, supported: true });
-    }
+  if (hasVscode && !detected.has("vscode")) {
+    detected.set("vscode", { ide: SUPPORTED_IDE, supported: true });
   }
-  if (await exists(path5.join(root, ".idea"))) {
+  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/ai-tool.ts
+// src/detect/provider.ts
 import path6 from "path";
 var KNOWN_CLI_TOOLS = [
   { id: "claude-code", bin: "claude", label: "Claude Code", supported: true },
@@ -344,23 +486,24 @@ var KNOWN_CLI_TOOLS = [
 ];
 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: "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) {
+async function detectProviders(root) {
   const detectedMap = /* @__PURE__ */ new Map();
-  for (const tool of KNOWN_CLI_TOOLS) {
+  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,
-        toolModes: ["cli"],
+        providerModes: ["cli"],
         preferredMode: "cli"
       });
     }
-  }
+  });
+  await Promise.all(cliChecks);
   const extensionsJsonPath = path6.join(root, ".vscode", "extensions.json");
   let recommendedExts = [];
   if (await exists(extensionsJsonPath)) {
@@ -375,35 +518,49 @@ async function detectAITools(root) {
   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 (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 {
-      }
+    } 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.toolModes.push("plugin");
-        existing.preferredMode = "plugin";
+        existing.providerModes.push("extension");
+        existing.preferredMode = "extension";
       } else {
         detectedMap.set(plugin.id, {
           id: plugin.id,
           label: plugin.label,
           supported: plugin.supported,
-          toolModes: ["plugin"],
-          preferredMode: "plugin"
+          providerModes: ["extension"],
+          preferredMode: "extension"
         });
       }
     }
@@ -413,207 +570,259 @@ async function detectAITools(root) {
 
 // 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'`
+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: "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)`
+    ];
+  }
 };
-function getImportStatement(tool, isLegacyRspack) {
-  if (tool === "rspack" && isLegacyRspack) {
-    return `import { rspackPlugin as inspecto } from '@inspecto-dev/plugin/legacy/rspack'`;
+
+// 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)`
+    ];
   }
-  return IMPORT_MAP[tool];
-}
-function getPluginExpression(isLegacyRspack) {
-  if (isLegacyRspack) {
-    return `process.env.NODE_ENV !== 'production' && inspecto({
+};
+
+// 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'],
-    }) as any`;
+    })` : `process.env.NODE_ENV !== 'production' && inspecto()`;
+    return [
+      `import { rspackPlugin as inspecto } from '${importPkg}'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  ${pluginCall},`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`
+    ];
   }
-  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),
+};
+
+// 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: [`,
-      `      ${getPluginExpression(isLegacyRspack)},`,
+      `      process.env.NODE_ENV !== 'production' && inspecto(),`,
       `    ]`,
       `  }`,
       `}`
-    ]);
-  } else {
-    log.codeBlock([
-      getImportStatement(tool, isLegacyRspack),
+    ];
+  }
+};
+
+// 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: [`,
-      `  ${getPluginExpression(isLegacyRspack)},`,
+      `  process.env.NODE_ENV !== 'production' && inspecto(),`,
       `  ...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;
-      }
-    }
+      `].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()`,
+      `}`
+    ];
   }
-  if (lastImportEnd > 0) {
-    return content.slice(0, lastImportEnd) + "\n" + importStmt + content.slice(lastImportEnd);
+};
+
+// 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()`,
+      `}`
+    ];
   }
-  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;
+};
+
+// 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}`);
   }
-  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;
+function isAlreadyInjected(content) {
+  return /import\s+.*@inspecto-dev\/plugin/.test(content) || /require\(['"]@inspecto-dev\/plugin['"]\)/.test(content) || /import\s+.*ai-dev-inspector/.test(content) || // Legacy support
+  /require\(['"]ai-dev-inspector['"]\)/.test(content);
 }
 async function injectPlugin(root, detection, dryRun) {
   const configPath = path7.join(root, detection.configPath);
-  const backupPath = configPath + ".bak";
   const mutations = [];
+  const strategy = STRATEGIES.find((s) => s.supports(detection.tool));
   const content = await readFile(configPath);
   if (!content) {
-    printManualInstructions(
-      detection.tool,
-      detection.configPath,
-      "config file not readable",
-      detection.isLegacyRspack
-    );
+    printManualInstructions(strategy, detection, "config file not readable");
     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);
+    log.success(`Plugin already configured in ${detection.configPath} (skipped)`);
     mutations.push({
       type: "file_modified",
       path: detection.configPath,
-      backup: detection.configPath + ".bak",
-      description: "Injected inspecto() plugin"
+      description: "Previously configured inspecto() plugin"
     });
+    return { success: true, mutations };
   }
-  log.success(`Backed up ${detection.configPath} \u2192 ${detection.configPath}.bak`);
-  const injected = injectIntoPluginsArray(content, detection);
-  if (!injected) {
+  if (!strategy) {
     printManualInstructions(
-      detection.tool,
-      detection.configPath,
-      "could not locate plugins array \u2014 file may use dynamic config, function wrapper, or non-standard export",
-      detection.isLegacyRspack
+      strategy,
+      detection,
+      `No injection strategy found for ${detection.tool}`
     );
-    return {
-      success: false,
-      mutations,
-      failureReason: "could not locate plugins array"
-    };
+    return { success: false, mutations, failureReason: "No strategy found" };
   }
-  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`);
-    }
+  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(
-      detection.tool,
-      detection.configPath,
-      "injection produced unbalanced brackets",
-      detection.isLegacyRspack
+      strategy,
+      detection,
+      `Automatic configuration unavailable: ${err instanceof Error ? err.message : String(err)}`
     );
     return {
       success: false,
-      mutations: [],
-      // Rolled back
-      failureReason: "injection produced invalid syntax"
+      mutations,
+      failureReason: "Automatic configuration unavailable"
     };
   }
-  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
@@ -630,7 +839,7 @@ async function updateGitignore(root, shared, dryRun) {
     if (!dryRun) {
       await writeFile(gitignorePath, content);
     }
-    log.success("Updated .gitignore: .inspecto/settings.json is now trackable");
+    log.success("Updated .gitignore: .inspecto/ is no longer fully ignored");
     return;
   }
   const missingRules = desiredRules.filter((rule) => !content.includes(rule));
@@ -692,41 +901,54 @@ async function tryOpenURI(uri) {
     return false;
   }
 }
-async function installExtension(dryRun) {
+async function installExtension(dryRun, ide) {
   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 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 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;
   }
-  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.warn(`Could not auto-install extension for ${ide}`);
   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}`);
+  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() {
@@ -746,70 +968,49 @@ async function isExtensionInstalled() {
   }
 }
 
-// src/commands/init.ts
+// 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];
   }
-  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);
+  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 promptAIToolChoice(detections) {
+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];
   }
-  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);
+  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) {
@@ -817,30 +1018,93 @@ async function promptConfigChoice(detections) {
     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}`);
+  const choices = detections.map((d, i) => ({
+    title: d.label,
+    value: i
+  }));
+  choices.push({
+    title: "Skip (I'll configure manually)",
+    value: -1
   });
-  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);
+  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 = [];
@@ -850,37 +1114,60 @@ async function init(options) {
     log.hint("Run this command from your project root");
     return;
   }
-  const pm = await detectPackageManager(root);
+  const [pm, frameworkResult, buildResult, ideProbe, providerProbe] = await Promise.all([
+    detectPackageManager(root),
+    detectFrameworks(root),
+    detectBuildTools(root),
+    detectIDE(root),
+    detectProviders(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 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.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");
+    log.hint(
+      `Note: Inspecto will be configured for ${frameworkResult.supported.join(", ")}. Other detected frameworks (${names}) will be ignored.`
+    );
   }
-  const buildResult = await detectBuildTools(root);
+  let manualConfigRequiredFor = "";
   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");
+    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("v1 supports: Vite, Webpack, Rspack, esbuild, Rollup");
+    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"
+    );
   }
-  const ideProbe = await detectIDE(root);
   let selectedIDE = null;
   if (ideProbe.detected.length === 0) {
     log.error("No IDE detected in current project");
@@ -901,21 +1188,20 @@ async function init(options) {
       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) {
+  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 (aiToolProbe.detected.length === 1) {
-      selectedAITool = aiToolProbe.detected[0];
-      if (selectedAITool.supported) {
-        log.success(`Detected AI tool: ${selectedAITool.label}`);
+    } else if (providerProbe.detected.length === 1) {
+      selectedProvider = providerProbe.detected[0];
+      if (selectedProvider.supported) {
+        log.success(`Detected AI tool: ${selectedProvider.label}`);
       }
     } else {
-      selectedAITool = await promptAIToolChoice(aiToolProbe.detected);
-      if (selectedAITool) {
-        log.success(`Selected AI tool: ${selectedAITool.label}`);
+      selectedProvider = await promptProviderChoice(providerProbe.detected);
+      if (selectedProvider) {
+        log.success(`Selected provider: ${selectedProvider.label}`);
       }
     }
   }
@@ -933,16 +1219,8 @@ async function init(options) {
           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
-        });
+        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"}`);
@@ -969,55 +1247,50 @@ async function init(options) {
     }
   }
   const settingsDir = path9.join(root, ".inspecto");
-  const settingsPath = path9.join(settingsDir, "settings.json");
-  const promptsPath = path9.join(settingsDir, "prompts.json");
+  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/settings.json exists but contains invalid JSON");
+      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/settings.json already exists (skipped)");
+      log.success(`.inspecto/${settingsFileName} already exists (skipped)`);
     }
   } else {
     const defaultSettings = {};
     if (selectedIDE && selectedIDE.supported) {
-      defaultSettings.ide = selectedIDE.ide === "vscode" ? "vscode" : selectedIDE.ide;
+      defaultSettings.ide = selectedIDE.ide.toLowerCase() === "vscode" ? "vscode" : selectedIDE.ide.toLowerCase();
     }
-    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.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/settings.json");
+      log.dryRun(`Would create .inspecto/${settingsFileName}`);
     } else {
       await writeJSON(settingsPath, defaultSettings);
-      log.success("Created .inspecto/settings.json");
-      mutations.push({ type: "file_created", path: ".inspecto/settings.json" });
+      log.success(`Created .inspecto/${settingsFileName}`);
+      mutations.push({ type: "file_created", path: `.inspecto/${settingsFileName}` });
     }
   }
   if (await exists(promptsPath)) {
-    log.success(".inspecto/prompts.json already exists (skipped)");
+    log.success(`.inspecto/${promptsFileName} already exists (skipped)`);
   } else {
-    const defaultPrompts = [
-      { id: "code-review", enabled: false },
-      { id: "generate-test", enabled: false },
-      { id: "performance", enabled: false }
-    ];
+    const defaultPrompts = [];
     if (options.dryRun) {
-      log.dryRun("Would create .inspecto/prompts.json");
+      log.dryRun(`Would create .inspecto/${promptsFileName}`);
     } else {
       await writeJSON(promptsPath, defaultPrompts);
-      log.success("Created .inspecto/prompts.json (disabling low-frequency intents)");
-      mutations.push({ type: "file_created", path: ".inspecto/prompts.json" });
+      log.success(`Created .inspecto/${promptsFileName}`);
+      mutations.push({ type: "file_created", path: `.inspecto/${promptsFileName}` });
     }
   }
   if (!options.dryRun) {
@@ -1041,10 +1314,10 @@ async function init(options) {
   const shouldInstallExt = !options.noExtension && (!selectedIDE || selectedIDE && selectedIDE.supported);
   let manualExtensionInstallNeeded = false;
   if (options.noExtension) {
-    log.warn("Skipping VS Code extension (--no-extension)");
+    log.warn("Skipping IDE extension (--no-extension)");
   } else if (!shouldInstallExt) {
   } else {
-    const extMutation = await installExtension(options.dryRun);
+    const extMutation = await installExtension(options.dryRun, selectedIDE?.ide);
     if (extMutation && !options.dryRun) {
       mutations.push(extMutation);
       if (extMutation.manual_action_required) {
@@ -1063,10 +1336,16 @@ async function init(options) {
   if (options.dryRun) {
     log.blank();
     log.warn("Dry run complete. No files were modified.");
-  } else if (installFailed || injectionFailed || manualExtensionInstallNeeded) {
+  } else if (installFailed || injectionFailed || manualExtensionInstallNeeded || manualConfigRequiredFor) {
     log.blank();
     log.warn("Setup completed with some manual steps required.");
-    log.hint("Please check the logs above and complete the manual steps.");
+    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.");
@@ -1084,7 +1363,14 @@ async function doctor() {
     log.hint("Run this command from your project root");
     return;
   }
-  const ideProbe = await detectIDE(root);
+  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++;
@@ -1096,11 +1382,10 @@ async function doctor() {
       );
     } else {
       const names = ideProbe.detected.map((d) => d.ide).join(", ");
-      log.warn(`IDE: ${names} (not supported in v1, VS Code only)`);
+      log.warn(`IDE: ${names} (not supported in v1, VS Code, Cursor, Trae 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) {
@@ -1111,57 +1396,54 @@ async function doctor() {
     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");
+  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 = aiProbe.detected.map((d) => {
-      const modeLabels = d.toolModes.map(
-        (mode) => mode === "plugin" ? "VS Code Extension" : "Terminal CLI"
+    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(`AI Tool: ${aiNames}`);
+    log.success(`Provider: ${aiNames}`);
   }
-  const pluginPath = path10.join(root, "node_modules", "@inspecto", "plugin");
+  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 pm = await detectPackageManager(root);
-    log.hint(`Fix: ${getInstallCommand(pm, "@inspecto-dev/plugin")}`);
+    const pm2 = await detectPackageManager(root);
+    log.hint(`Fix: ${getInstallCommand(pm2, "@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}`);
+        log.success(`Plugin configured in ${bt.configPath}`);
         injected = true;
         break;
       }
     }
     if (!injected) {
-      log.error("Plugin not injected in any build config");
+      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("v1 supports: Vite, Webpack, Rspack, esbuild, Rollup");
+    log.hint("current version 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 {
@@ -1175,20 +1457,25 @@ async function doctor() {
       result.errors++;
     }
   }
-  const settingsPath = path10.join(root, ".inspecto", "settings.json");
-  if (await exists(settingsPath)) {
-    const settings = await readJSON(settingsPath);
+  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/settings.json valid");
+      log.success(`.inspecto/${fileName} valid`);
     } else {
-      log.error(".inspecto/settings.json has invalid JSON");
+      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(".inspecto/settings.json not found (using defaults)");
+    log.warn("No .inspecto/settings.json or settings.local.json found (using defaults)");
     log.hint("Optional: npx @inspecto-dev/cli init");
     result.warnings++;
   }
@@ -1239,7 +1526,7 @@ async function teardown() {
     }
     await cleanGitignore(root);
     log.success("Cleaned .gitignore entries");
-    log.warn("Cannot restore build config (no backup reference)");
+    log.warn("Cannot restore build config auto-magically");
     log.hint("Please manually remove the inspecto() plugin from your build config");
     log.blank();
     return;
@@ -1249,24 +1536,12 @@ async function teardown() {
   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}`);
+        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;
       }