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

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @inspecto-dev/cli@0.2.0-alpha.2 build /Users/bytedance/Works/hugo.felix/inspecto/packages/cli
+> @inspecto-dev/cli@0.2.0-alpha.4 build /Users/bytedance/Works/hugo.felix/inspecto/packages/cli
 > tsup
 
 CLI Building entry: src/bin.ts, src/index.ts
@@ -10,11 +10,11 @@
 CLI Target: node18
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.js          109.00 B
+ESM dist/chunk-MIHQGC3L.js 58.03 KB
 ESM dist/bin.js            2.64 KB
-ESM dist/chunk-HIL6365F.js 53.63 KB
-ESM ⚡️ Build success in 26ms
+ESM dist/index.js          109.00 B
+ESM ⚡️ Build success in 32ms
 DTS Build start
-DTS ⚡️ Build success in 1180ms
+DTS ⚡️ Build success in 1096ms
 DTS dist/bin.d.ts   13.00 B
 DTS dist/index.d.ts 1.18 KB

package/.turbo/turbo-test.log

@@ -1,15 +1,16 @@
 
-> @inspecto-dev/cli@0.2.0-alpha.2 test /Users/bytedance/Works/hugo.felix/inspecto/packages/cli
+> @inspecto-dev/cli@0.2.0-alpha.4 test /Users/bytedance/Works/hugo.felix/inspecto/packages/cli
 > vitest run --passWithNoTests
 
 
  RUN  v1.6.1 /Users/bytedance/Works/hugo.felix/inspecto/packages/cli
 
- ✓ tests/ide.test.ts  (6 tests) 3ms
- ✓ tests/framework.test.ts  (5 tests) 2ms
+ ✓ tests/framework.test.ts  (5 tests) 4ms
+ ✓ tests/build-tool.test.ts  (2 tests) 9ms
+ ✓ tests/ide.test.ts  (6 tests) 8ms
 
- Test Files  2 passed (2)
-      Tests  11 passed (11)
-   Start at  19:47:34
-   Duration  213ms (transform 48ms, setup 0ms, collect 65ms, tests 5ms, environment 0ms, prepare 121ms)
+ Test Files  3 passed (3)
+      Tests  13 passed (13)
+   Start at  15:41:01
+   Duration  771ms (transform 133ms, setup 1ms, collect 221ms, tests 21ms, environment 0ms, prepare 367ms)
 

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @inspecto-dev/cli
 
+## 0.2.0-alpha.5
+
+### Minor Changes
+
+- release alpha test version
+
+## 0.2.0-alpha.4
+
+### Minor Changes
+
+- release alpha test version
+
+### Patch Changes
+
+- Updated dependencies
+  - @inspecto-dev/types@0.2.0-alpha.4
+
 ## 0.2.0-alpha.3
 
 ### Minor Changes

package/dist/bin.js

@@ -3,7 +3,7 @@ import {
   init,
   log,
   teardown
-} from "./chunk-HIL6365F.js";
+} from "./chunk-MIHQGC3L.js";
 
 // src/bin.ts
 import { cac } from "cac";

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

@@ -205,7 +205,14 @@ async function getResolvedPackageVersion(pkgName, root) {
 var SUPPORTED_PATTERNS = [
   {
     tool: "vite",
-    files: ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"],
+    files: [
+      "vite.config.ts",
+      "vite.config.js",
+      "vite.config.mts",
+      "vite.config.mjs",
+      "vite.config.cjs",
+      "vite.config.cts"
+    ],
     label: "Vite"
   },
   {
@@ -241,117 +248,154 @@ var UNSUPPORTED_META = [
   { name: "Astro", dep: "astro", files: ["astro.config.mjs", "astro.config.ts"] },
   { name: "SvelteKit", dep: "@sveltejs/kit", files: ["svelte.config.js", "svelte.config.ts"] }
 ];
-async function detectBuildTools(root) {
+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 = [];
-  const pkg = await readJSON(path3.join(root, "package.json"));
-  const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
-  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);
+  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);
       }
-    } 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) {
+    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;
-    }
-    for (const file of pattern.files) {
-      if (await exists(path3.join(root, file))) {
-        detectedFile = file;
-        break;
+    });
+    const unsupportedResults = await Promise.all(unsupportedChecks);
+    for (const result of unsupportedResults) {
+      if (result) {
+        unsupported.add(result);
       }
     }
-    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;
-              }
+  }
+  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(root, configMatch[1]))) {
-                detectedFile = configMatch[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) {
-      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;
+        if (!detectedFile) {
+          detectedFile = "package.json (scripts)";
+          break;
         }
       }
-      return {
-        tool: pattern.tool,
-        configPath: detectedFile,
-        label: `${pattern.label} (${detectedFile})${isLegacyRspack ? " [Legacy]" : ""}${isLegacyWebpack ? " [Webpack 4]" : ""}`,
-        isLegacyRspack,
-        isLegacyWebpack
-      };
     }
+  }
+  if (!detectedFile) {
     return null;
-  });
-  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(root, file))) {
-        return meta.name;
-      }
+  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;
     }
-    return null;
-  });
-  const unsupportedResults = await Promise.all(unsupportedChecks);
-  for (const result of unsupportedResults) {
-    if (result) {
-      unsupported.push(result);
+  } else if (pattern.tool === "webpack") {
+    const version = resolvedVersion;
+    if (version && version.includes("^4") || version?.startsWith("4.")) {
+      isLegacyWebpack = true;
     }
   }
-  return { supported, unsupported };
+  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;
@@ -582,7 +626,8 @@ var ViteStrategy = class {
   inject({ mod, detection }) {
     addVitePlugin(mod, {
       from: "@inspecto-dev/plugin",
-      constructor: "vitePlugin"
+      constructor: "inspecto",
+      imported: "vitePlugin"
     });
   }
   getManualInstructions(detection, reason) {
@@ -764,8 +809,21 @@ function printManualInstructions(strategy, detection, reason) {
   }
 }
 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);
+  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);
@@ -894,8 +952,12 @@ async function findVSCodeBinary() {
 async function tryOpenURI(uri) {
   try {
     const platform = process.platform;
-    const openCmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
-    await shell(`${openCmd} "${uri}"`);
+    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;
@@ -1108,6 +1170,25 @@ function printNextJsManualInstructions() {
 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");
@@ -1117,7 +1198,7 @@ async function init(options) {
   const [pm, frameworkResult, buildResult, ideProbe, providerProbe] = await Promise.all([
     detectPackageManager(root),
     detectFrameworks(root),
-    detectBuildTools(root),
+    detectBuildTools(root, verifiedPackages.length > 0 ? verifiedPackages : void 0),
     detectIDE(root),
     detectProviders(root)
   ]);
@@ -1151,6 +1232,12 @@ async function init(options) {
     );
   }
   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}`));
   }
@@ -1230,20 +1317,46 @@ async function init(options) {
   }
   let injectionFailed = false;
   if (buildResult.supported.length > 0) {
-    let target = resolveInjectionTarget(buildResult.supported);
-    if (target === "ambiguous") {
-      target = await promptConfigChoice(buildResult.supported);
-    }
-    if (target) {
-      const result = await injectPlugin(root, target, options.dryRun);
-      if (result.success) {
-        mutations.push(...result.mutations);
-      } else {
+    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 {
-      injectionFailed = true;
-      log.warn("Skipping plugin injection (manual configuration required)");
+      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");
@@ -1351,6 +1464,27 @@ async function init(options) {
     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";

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   doctor,
   init,
   teardown
-} from "./chunk-HIL6365F.js";
+} from "./chunk-MIHQGC3L.js";
 export {
   doctor,
   init,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inspecto-dev/cli",
-  "version": "0.2.0-alpha.3",
+  "version": "0.2.0-alpha.5",
   "description": "CLI tools for Inspecto onboarding and lifecycle management",
   "keywords": [
     "inspecto",
@@ -19,7 +19,7 @@
     "magicast": "^0.5.2",
     "picocolors": "^1.0.0",
     "prompts": "^2.4.2",
-    "@inspecto-dev/types": "0.2.0-alpha.3"
+    "@inspecto-dev/types": "0.2.0-alpha.4"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/commands/init.ts

@@ -18,7 +18,7 @@ import { detectProviders, type ProviderDetection } from '../detect/provider.js'
 import { injectPlugin } from '../inject/ast-injector.js'
 import { updateGitignore } from '../inject/gitignore.js'
 import { installExtension } from '../inject/extension.js'
-import type { InitOptions, InstallLock, Mutation } from '../types.js'
+import type { InitOptions, InstallLock, Mutation, BuildToolDetection } from '../types.js'
 import {
   promptIDEChoice,
   promptProviderChoice,
@@ -30,6 +30,29 @@ import { printNextJsManualInstructions, printNuxtManualInstructions } from '../i
 export async function init(options: InitOptions): Promise<void> {
   const root = process.cwd()
   const mutations: Mutation[] = []
+  const normalizedPackages = normalizePackageList(options.packages)
+
+  const verifiedPackages: string[] = []
+  for (const pkg of normalizedPackages) {
+    if (!pkg) {
+      // Empty string represents the workspace root
+      verifiedPackages.push(pkg)
+      continue
+    }
+
+    const absolutePath = path.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')
 
@@ -44,7 +67,7 @@ export async function init(options: InitOptions): Promise<void> {
   const [pm, frameworkResult, buildResult, ideProbe, providerProbe] = await Promise.all([
     detectPackageManager(root),
     detectFrameworks(root),
-    detectBuildTools(root),
+    detectBuildTools(root, verifiedPackages.length > 0 ? verifiedPackages : undefined),
     detectIDE(root),
     detectProviders(root),
   ])
@@ -87,6 +110,13 @@ export async function init(options: InitOptions): Promise<void> {
 
   // Build tool detection
   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}`))
   }
@@ -177,22 +207,54 @@ export async function init(options: InitOptions): Promise<void> {
   // ---- Step 4: Inject plugin into build config ----
   let injectionFailed = false
   if (buildResult.supported.length > 0) {
-    let target = resolveInjectionTarget(buildResult.supported)
+    if (verifiedPackages.length > 0) {
+      const targets = buildResult.supported.filter(detection =>
+        matchesAnyPackage(detection, verifiedPackages),
+      )
 
-    if (target === 'ambiguous') {
-      target = await promptConfigChoice(buildResult.supported)
-    }
+      const unmatchedPackages = verifiedPackages.filter(
+        pkg => !buildResult.supported.some(detection => matchesPackage(detection, pkg)),
+      )
 
-    if (target) {
-      const result = await injectPlugin(root, target, options.dryRun)
-      if (result.success) {
-        mutations.push(...result.mutations)
-      } else {
+      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 {
-      injectionFailed = true
-      log.warn('Skipping plugin injection (manual configuration required)')
+      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)')
+      }
     }
   }
 
@@ -329,3 +391,33 @@ export async function init(options: InitOptions): Promise<void> {
     log.ready('Ready! Hold Alt + Click any element to inspect.')
   }
 }
+
+function normalizePackageList(packages?: string[]): string[] {
+  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 is string => value !== null)
+
+  return Array.from(new Set(normalized))
+}
+
+function matchesPackage(detection: BuildToolDetection, pkg: string): boolean {
+  const configPath = detection.configPath.replace(/\\/g, '/')
+  if (!pkg) {
+    return !configPath.includes('/')
+  }
+
+  return configPath === pkg || configPath.startsWith(`${pkg}/`)
+}
+
+function matchesAnyPackage(detection: BuildToolDetection, packages: string[]): boolean {
+  if (packages.length === 0) return true
+  return packages.some(pkg => matchesPackage(detection, pkg))
+}

package/src/detect/build-tool.ts

@@ -53,7 +53,14 @@ async function getResolvedPackageVersion(pkgName: string, root: string): Promise
 const SUPPORTED_PATTERNS: { tool: BuildTool; files: string[]; label: string }[] = [
   {
     tool: 'vite',
-    files: ['vite.config.ts', 'vite.config.js', 'vite.config.mts', 'vite.config.mjs'],
+    files: [
+      'vite.config.ts',
+      'vite.config.js',
+      'vite.config.mts',
+      'vite.config.mjs',
+      'vite.config.cjs',
+      'vite.config.cts',
+    ],
     label: 'Vite',
   },
   {
@@ -92,171 +99,223 @@ const UNSUPPORTED_META: { name: string; dep: string; files: string[] }[] = [
   { name: 'SvelteKit', dep: '@sveltejs/kit', files: ['svelte.config.js', 'svelte.config.ts'] },
 ]
 
+interface DetectionTarget {
+  /** Relative path provided via --packages ('' for repo root) */
+  packagePath: string
+  /** Absolute path to run detection from */
+  absolutePath: string
+}
+
 export interface BuildToolResult {
   supported: BuildToolDetection[]
   unsupported: string[]
 }
 
+function normalizeRelativePath(root: string, filePath: string): string {
+  const relative = path.relative(root, filePath)
+  const normalized = relative.split(path.sep).join('/')
+  return normalized || path.basename(filePath)
+}
+
+function createTargets(root: string, packagePaths?: string[]): DetectionTarget[] {
+  if (!packagePaths || packagePaths.length === 0) {
+    return [{ packagePath: '', absolutePath: root }]
+  }
+
+  return packagePaths.map(pkg => ({
+    packagePath: pkg,
+    absolutePath: pkg ? path.join(root, pkg) : root,
+  }))
+}
+
 /**
  * Detect all build tools / meta-frameworks.
  * Returns supported tools and recognized-but-unsupported meta-frameworks.
  */
-export async function detectBuildTools(root: string): Promise<BuildToolResult> {
+export async function detectBuildTools(
+  root: string,
+  packagePaths?: string[],
+): Promise<BuildToolResult> {
   const supported: BuildToolDetection[] = []
-  const unsupported: string[] = []
-
-  // Detect supported build tools (by config file)
-  const pkg = await readJSON<PackageJSON>(path.join(root, 'package.json'))
-  const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies }
-
-  const supportedChecks = SUPPORTED_PATTERNS.map(async pattern => {
-    // 1. Check if the package.json has a dependency for this tool
-    let hasDep: boolean
-    let resolvedVersion: string | null = 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))
+  const unsupported = new Set<string>()
+  const targets = createTargets(root, packagePaths)
+
+  for (const target of targets) {
+    const pkg = await readJSON<PackageJSON>(path.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)
       }
-    } 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))
+    const unsupportedChecks = UNSUPPORTED_META.map(async meta => {
+      if (!(meta.dep in allDeps)) return null
+      for (const file of meta.files) {
+        if (await exists(path.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)
       }
-    } else if (pattern.tool === 'rsbuild') {
-      hasDep = !!allDeps['@rsbuild/core'] || isPackageResolvable('@rsbuild/core', root)
-    } else {
-      hasDep = !!allDeps[pattern.tool] || isPackageResolvable(pattern.tool, root)
     }
+  }
 
-    // 2. Look for config files
-    let detectedFile = ''
+  return { supported, unsupported: Array.from(unsupported) }
+}
 
-    // For esbuild, dependency is strictly required
-    if (pattern.tool === 'esbuild' && !hasDep) {
-      return null
+interface PatternContext {
+  pattern: { tool: BuildTool; files: string[]; label: string }
+  workspaceRoot: string
+  targetRoot: string
+  packagePath: string
+  allDeps: Record<string, string | undefined>
+  scripts: Record<string, string>
+}
+
+async function detectPattern({
+  pattern,
+  workspaceRoot,
+  targetRoot,
+  packagePath,
+  allDeps,
+  scripts,
+}: PatternContext): Promise<BuildToolDetection | null> {
+  let hasDep: boolean
+  let resolvedVersion: string | null = 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)
 
-    for (const file of pattern.files) {
-      if (await exists(path.join(root, file))) {
-        detectedFile = file
-        break
-      }
+    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)
+  }
 
-    // 3. For esbuild, rollup, and webpack, if they are in dependencies but no standard config is found,
-    // we still consider them detected (as they are often used with custom scripts or config file names)
-    if (
-      hasDep &&
-      !detectedFile &&
-      (pattern.tool === 'esbuild' ||
-        pattern.tool === 'rollup' ||
-        pattern.tool === 'webpack' ||
-        pattern.tool === 'rspack' ||
-        pattern.tool === 'rsbuild')
-    ) {
-      // Look at npm scripts to guess the build file
-      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(path.join(root, match[1]))) {
-              // Only fallback to a bare node script if the script mentions the tool name somewhere
-              // or if it's explicitly inside a directory named after the tool (like /rspack-scripts/)
-              if (cmd.includes(pattern.tool) || match[1].includes(pattern.tool)) {
-                detectedFile = match[1]
-                break
-              }
+  let detectedFile = ''
+
+  if (pattern.tool === 'esbuild' && !hasDep) {
+    return null
+  }
+
+  for (const file of pattern.files) {
+    if (await exists(path.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(path.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 we see webpack/rspack in a script but didn't find the exact file above,
-          // let's try to extract a custom --config flag if provided
-          if (pattern.tool === 'webpack' || pattern.tool === 'rspack') {
-            const configMatch = cmd.match(/--config\s+([^\s]+)/)
-            if (configMatch && configMatch[1]) {
-              if (await exists(path.join(root, configMatch[1]))) {
-                detectedFile = configMatch[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(path.join(targetRoot, configMatch[1]))) {
+              detectedFile = configMatch[1]
+              break
             }
           }
-
-          if (!detectedFile) {
-            detectedFile = 'package.json (scripts)'
-            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
+        if (!detectedFile) {
+          detectedFile = 'package.json (scripts)'
+          break
         }
       }
-
-      return {
-        tool: pattern.tool,
-        configPath: detectedFile,
-        label: `${pattern.label} (${detectedFile})${isLegacyRspack ? ' [Legacy]' : ''}${isLegacyWebpack ? ' [Webpack 4]' : ''}`,
-        isLegacyRspack,
-        isLegacyWebpack,
-      }
     }
+  }
 
+  if (!detectedFile) {
     return null
-  })
-
-  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(path.join(root, file))) {
-        return meta.name
-      }
-    }
-    return null
-  })
+  let isLegacyRspack = false
+  let isLegacyWebpack = false
 
-  const unsupportedResults = await Promise.all(unsupportedChecks)
-  for (const result of unsupportedResults) {
-    if (result) {
-      unsupported.push(result)
+  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 { supported, unsupported }
+  const absoluteConfig = path.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 || undefined,
+  }
 }
 
 /**

package/src/inject/ast-injector.ts

@@ -41,13 +41,24 @@ function printManualInstructions(
 
 /** Check if inspecto is already injected (idempotency). */
 function isAlreadyInjected(content: string): boolean {
-  // Use regex to avoid false positives in comments or variables
-  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)
-  )
+  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: RegExpExecArray | null
+  importPlugin.lastIndex = 0
+  while ((match = importPlugin.exec(normalized))) {
+    const importClause = match[1] || ''
+    if (/inspecto/.test(importClause) || /vitePlugin/.test(importClause)) {
+      return true
+    }
+  }
+
+  return false
 }
 
 // ---- Main injection orchestrator ----

package/src/inject/extension.ts

@@ -54,9 +54,12 @@ async function findVSCodeBinary(): Promise<string | null> {
 async function tryOpenURI(uri: string): Promise<boolean> {
   try {
     const platform = process.platform
-    const openCmd = platform === 'darwin' ? 'open' : platform === 'win32' ? 'start' : 'xdg-open'
-
-    await shell(`${openCmd} "${uri}"`)
+    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

package/src/inject/strategies/vite.ts

@@ -12,7 +12,8 @@ export class ViteStrategy implements InjectStrategy {
   inject({ mod, detection }: InjectOptions): void {
     addVitePlugin(mod, {
       from: '@inspecto-dev/plugin',
-      constructor: 'vitePlugin',
+      constructor: 'inspecto',
+      imported: 'vitePlugin',
     })
   }
 

package/src/types.ts

@@ -18,6 +18,8 @@ export interface BuildToolDetection {
   isLegacyRspack?: boolean
   /** Whether this is Webpack 4.x */
   isLegacyWebpack?: boolean
+  /** Relative package path when using --packages */
+  packagePath?: string
 }
 
 /** Options passed to `inspecto init` */

package/tests/build-tool.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { detectBuildTools } from '../src/detect/build-tool.js'
+import * as fsUtils from '../src/utils/fs.js'
+
+vi.mock('../src/utils/fs.js', () => ({
+  exists: vi.fn(),
+  readJSON: vi.fn(),
+}))
+
+describe('detectBuildTools', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+  })
+
+  it('detects Vite config inside a specified package path', async () => {
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath.includes('packages/app/package.json')) {
+        return { devDependencies: { vite: '^5.0.0' } }
+      }
+      if (filePath.endsWith('/package.json')) {
+        return {}
+      }
+      return null
+    })
+
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath =>
+      filePath.includes('packages/app/vite.config.ts'),
+    )
+
+    const result = await detectBuildTools('/repo', ['packages/app'])
+    expect(result.supported).toHaveLength(1)
+    expect(result.supported[0]?.configPath).toBe('packages/app/vite.config.ts')
+    expect(result.supported[0]?.packagePath).toBe('packages/app')
+  })
+
+  it('detects vite.config.cjs at the repo root', async () => {
+    vi.mocked(fsUtils.readJSON).mockResolvedValue({ devDependencies: { vite: '^5.0.0' } })
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath =>
+      filePath.endsWith('vite.config.cjs'),
+    )
+
+    const result = await detectBuildTools('/repo')
+    expect(result.supported).toHaveLength(1)
+    expect(result.supported[0]?.configPath).toBe('vite.config.cjs')
+  })
+})