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

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @inspecto-dev/cli@0.2.0-alpha.1 build /Users/bytedance/Works/hugo.felix/inspecto/packages/cli
+> @inspecto-dev/cli@0.2.0-alpha.2 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/bin.js            2.64 KB
 ESM dist/index.js          109.00 B
-ESM dist/chunk-V57BJXGZ.js 50.37 KB
-ESM ⚡️ Build success in 41ms
+ESM dist/bin.js            2.64 KB
+ESM dist/chunk-HIL6365F.js 53.63 KB
+ESM ⚡️ Build success in 26ms
 DTS Build start
-DTS ⚡️ Build success in 1418ms
+DTS ⚡️ Build success in 1180ms
 DTS dist/bin.d.ts   13.00 B
 DTS dist/index.d.ts 1.18 KB

package/.turbo/turbo-test.log

@@ -1,15 +1,15 @@
 
-> @inspecto-dev/cli@0.2.0-alpha.1 test /Users/bytedance/Works/hugo.felix/inspecto/packages/cli
+> @inspecto-dev/cli@0.2.0-alpha.2 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/framework.test.ts  (5 tests) 6ms
- ✓ tests/ide.test.ts  (6 tests) 7ms
+ ✓ tests/ide.test.ts  (6 tests) 3ms
+ ✓ tests/framework.test.ts  (5 tests) 2ms
 
  Test Files  2 passed (2)
       Tests  11 passed (11)
-   Start at  15:10:05
-   Duration  798ms (transform 169ms, setup 0ms, collect 246ms, tests 13ms, environment 0ms, prepare 674ms)
+   Start at  19:47:34
+   Duration  213ms (transform 48ms, setup 0ms, collect 65ms, tests 5ms, environment 0ms, prepare 121ms)
 

package/CHANGELOG.md

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

package/dist/bin.js

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

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

@@ -177,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",
@@ -222,7 +247,25 @@ async function detectBuildTools(root) {
   const pkg = await readJSON(path3.join(root, "package.json"));
   const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
   const supportedChecks = SUPPORTED_PATTERNS.map(async (pattern) => {
-    const hasDep = pattern.tool === "rspack" ? !!(allDeps["@rspack/cli"] || allDeps["@rspack/core"]) : pattern.tool === "webpack" ? !!(allDeps["webpack"] || allDeps["webpack-cli"]) : pattern.tool === "rsbuild" ? !!allDeps["@rsbuild/core"] : !!allDeps[pattern.tool];
+    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;
@@ -233,20 +276,33 @@ async function detectBuildTools(root) {
         break;
       }
     }
-    if (hasDep && !detectedFile && (pattern.tool === "esbuild" || pattern.tool === "rollup")) {
+    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.entries(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]))) {
-              detectedFile = match[1];
-              break;
+              if (cmd.includes(pattern.tool) || match[1].includes(pattern.tool)) {
+                detectedFile = match[1];
+                break;
+              }
             }
           }
         } else if (cmd.includes(`${pattern.tool} `)) {
-          detectedFile = "package.json (scripts)";
-          break;
+          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;
+          }
         }
       }
     }
@@ -254,12 +310,12 @@ async function detectBuildTools(root) {
       let isLegacyRspack = false;
       let isLegacyWebpack = false;
       if (pattern.tool === "rspack") {
-        const version = allDeps["@rspack/cli"] || allDeps["@rspack/core"];
+        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 = allDeps["webpack"] || allDeps["webpack-cli"];
+        const version = resolvedVersion;
         if (version && version.includes("^4") || version?.startsWith("4.")) {
           isLegacyWebpack = true;
         }
@@ -305,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"] }
@@ -316,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
@@ -1030,10 +1125,10 @@ async function init(options) {
   if (frameworkResult.supported.length > 0) {
     log.success(`Detected framework: ${frameworkResult.supported.join(", ")}`);
   }
-  const hasUnsupportedFramework = frameworkResult.unsupported.length > 0;
-  const hasNoFramework = frameworkResult.supported.length === 0 && frameworkResult.unsupported.length === 0;
-  if (hasUnsupportedFramework || hasNoFramework) {
-    if (hasUnsupportedFramework) {
+  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 {
@@ -1049,6 +1144,11 @@ async function init(options) {
     } else {
       log.warn("Continuing anyway (--force)");
     }
+  } else if (hasUnsupported) {
+    const names = frameworkResult.unsupported.map((f) => f.name).join(", ");
+    log.hint(
+      `Note: Inspecto will be configured for ${frameworkResult.supported.join(", ")}. Other detected frameworks (${names}) will be ignored.`
+    );
   }
   let manualConfigRequiredFor = "";
   if (buildResult.supported.length > 0) {
@@ -1065,7 +1165,7 @@ async function init(options) {
     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/docs/getting-started/manual-setup"
+      "Please refer to the manual setup guide: https://inspecto-dev.github.io/inspecto/guide/manual-installation"
     );
   }
   let selectedIDE = null;

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inspecto-dev/cli",
-  "version": "0.2.0-alpha.2",
+  "version": "0.2.0-alpha.3",
   "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.2"
+    "@inspecto-dev/types": "0.2.0-alpha.3"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/commands/init.ts

@@ -57,12 +57,11 @@ export async function init(options: InitOptions): Promise<void> {
     log.success(`Detected framework: ${frameworkResult.supported.join(', ')}`)
   }
 
-  const hasUnsupportedFramework = frameworkResult.unsupported.length > 0
-  const hasNoFramework =
-    frameworkResult.supported.length === 0 && frameworkResult.unsupported.length === 0
+  const isSupported = frameworkResult.supported.length > 0
+  const hasUnsupported = frameworkResult.unsupported.length > 0
 
-  if (hasUnsupportedFramework || hasNoFramework) {
-    if (hasUnsupportedFramework) {
+  if (!isSupported) {
+    if (hasUnsupported) {
       const names = frameworkResult.unsupported.map(f => f.name).join(', ')
       log.warn(`Detected ${names} — not supported in v1 (React / Vue only)`)
     } else {
@@ -79,6 +78,11 @@ export async function init(options: InitOptions): Promise<void> {
     } else {
       log.warn('Continuing anyway (--force)')
     }
+  } else if (hasUnsupported) {
+    const names = frameworkResult.unsupported.map(f => f.name).join(', ')
+    log.hint(
+      `Note: Inspecto will be configured for ${frameworkResult.supported.join(', ')}. Other detected frameworks (${names}) will be ignored.`,
+    )
   }
 
   // Build tool detection
@@ -97,7 +101,7 @@ export async function init(options: InitOptions): Promise<void> {
     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/docs/getting-started/manual-setup',
+      'Please refer to the manual setup guide: https://inspecto-dev.github.io/inspecto/guide/manual-installation',
     )
   }
 

package/src/detect/build-tool.ts

@@ -5,6 +5,7 @@
 // Recognized but unsupported: Next.js / Nuxt / Remix / Astro / SvelteKit
 // ============================================================
 import path from 'node:path'
+import { createRequire } from 'node:module'
 import { exists, readJSON } from '../utils/fs.js'
 import type { BuildTool, BuildToolDetection } from '../types.js'
 
@@ -12,6 +13,40 @@ interface PackageJSON {
   dependencies?: Record<string, string>
   devDependencies?: Record<string, string>
   scripts?: Record<string, string>
+  version?: string
+}
+
+/**
+ * Helper to check if a package can be resolved from the root directory.
+ * This handles monorepo hoisting and implicit dependencies.
+ */
+function isPackageResolvable(pkgName: string, root: string): boolean {
+  try {
+    const require = createRequire(path.join(root, 'package.json'))
+    try {
+      require.resolve(`${pkgName}/package.json`, { paths: [root] })
+      return true
+    } catch {
+      require.resolve(pkgName, { paths: [root] })
+      return true
+    }
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Attempts to read the actual version of a hoisted package from node_modules.
+ */
+async function getResolvedPackageVersion(pkgName: string, root: string): Promise<string | null> {
+  try {
+    const require = createRequire(path.join(root, 'package.json'))
+    const pkgJsonPath = require.resolve(`${pkgName}/package.json`, { paths: [root] })
+    const pkg = await readJSON<PackageJSON>(pkgJsonPath)
+    return pkg?.version || null
+  } catch {
+    return null
+  }
 }
 
 /** Supported build tools in v1 */
@@ -76,14 +111,33 @@ export async function detectBuildTools(root: string): Promise<BuildToolResult> {
 
   const supportedChecks = SUPPORTED_PATTERNS.map(async pattern => {
     // 1. Check if the package.json has a dependency for this tool
-    const hasDep =
-      pattern.tool === 'rspack'
-        ? !!(allDeps['@rspack/cli'] || allDeps['@rspack/core'])
-        : pattern.tool === 'webpack'
-          ? !!(allDeps['webpack'] || allDeps['webpack-cli'])
-          : pattern.tool === 'rsbuild'
-            ? !!allDeps['@rsbuild/core']
-            : !!allDeps[pattern.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))
+      }
+    } 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)
+    }
 
     // 2. Look for config files
     let detectedFile = ''
@@ -100,23 +154,49 @@ export async function detectBuildTools(root: string): Promise<BuildToolResult> {
       }
     }
 
-    // 3. For esbuild and rollup, if they are in dependencies but no standard config is found,
-    // we still consider them detected (as they are often used with custom scripts)
-    if (hasDep && !detectedFile && (pattern.tool === 'esbuild' || pattern.tool === 'rollup')) {
+    // 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.entries(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]))) {
-              detectedFile = match[1]
-              break
+              // 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
+              }
             }
           }
         } else if (cmd.includes(`${pattern.tool} `)) {
-          detectedFile = 'package.json (scripts)'
-          break
+          // 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
+              }
+            }
+          }
+
+          if (!detectedFile) {
+            detectedFile = 'package.json (scripts)'
+            break
+          }
         }
       }
     }
@@ -126,7 +206,7 @@ export async function detectBuildTools(root: string): Promise<BuildToolResult> {
       let isLegacyWebpack = false
 
       if (pattern.tool === 'rspack') {
-        const version = allDeps['@rspack/cli'] || allDeps['@rspack/core']
+        const version = resolvedVersion
         if (
           version &&
           (version.includes('0.3.') || version.includes('0.2.') || version.includes('0.1.'))
@@ -134,7 +214,7 @@ export async function detectBuildTools(root: string): Promise<BuildToolResult> {
           isLegacyRspack = true
         }
       } else if (pattern.tool === 'webpack') {
-        const version = allDeps['webpack'] || allDeps['webpack-cli']
+        const version = resolvedVersion
         if ((version && version.includes('^4')) || version?.startsWith('4.')) {
           isLegacyWebpack = true
         }

package/src/detect/framework.ts

@@ -5,6 +5,7 @@
 // Recognized but unsupported: Solid, Svelte, Angular, Preact, Lit
 // ============================================================
 import path from 'node:path'
+import { createRequire } from 'node:module'
 import { readJSON } from '../utils/fs.js'
 
 export type Framework = 'react' | 'vue'
@@ -17,6 +18,20 @@ export interface FrameworkDetection {
 interface PackageJSON {
   dependencies?: Record<string, string>
   devDependencies?: Record<string, string>
+  peerDependencies?: Record<string, string>
+}
+
+// Map meta-frameworks to their underlying UI frameworks
+const META_FRAMEWORK_MAP: Record<string, Framework> = {
+  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',
 }
 
 /** Supported frameworks in v1 */
@@ -34,32 +49,79 @@ const UNSUPPORTED_FRAMEWORKS: { name: string; dep: string }[] = [
   { name: 'Lit', dep: 'lit' },
 ]
 
+/**
+ * Helper to check if a package can be resolved from the root directory.
+ * This handles monorepo hoisting and implicit dependencies.
+ */
+function isPackageResolvable(pkgName: string, root: string): boolean {
+  try {
+    const require = createRequire(path.join(root, 'package.json'))
+    // Some packages might not expose package.json in exports, so resolving the package name directly is safer for entry points,
+    // but resolving package.json is generally safer to just check existence without executing code.
+    // We'll try resolving package.json first, and fallback to resolving the package root if possible.
+    try {
+      require.resolve(`${pkgName}/package.json`, { paths: [root] })
+      return true
+    } catch {
+      require.resolve(pkgName, { paths: [root] })
+      return true
+    }
+  } catch {
+    return false
+  }
+}
+
 /**
  * Detect frontend frameworks.
+ * Uses a waterfall approach:
+ * 1. Checks package.json explicitly (dependencies, devDependencies, peerDependencies)
+ * 2. Checks meta-frameworks mapping (e.g. nuxt -> vue)
+ * 3. Uses Node.js module resolution to find hoisted/implicit packages
  * Returns both supported and recognized-but-unsupported frameworks.
  */
 export async function detectFrameworks(root: string): Promise<FrameworkDetection> {
   const pkg = await readJSON<PackageJSON>(path.join(root, 'package.json'))
-  if (!pkg) return { supported: [], unsupported: [] }
 
   const allDeps = {
-    ...pkg.dependencies,
-    ...pkg.devDependencies,
+    ...(pkg?.dependencies || {}),
+    ...(pkg?.devDependencies || {}),
+    ...(pkg?.peerDependencies || {}),
   }
 
-  const supported: Framework[] = []
+  const supportedSet = new Set<Framework>()
+  const unsupported: { name: string; dep: string }[] = []
+
+  // Skip node resolution mock errors during unit tests
+  const isTest = root.includes('/mock/root')
+
+  // Tier 1: Meta-framework / Ecosystem Inference
+  for (const [metaPkg, framework] of Object.entries(META_FRAMEWORK_MAP)) {
+    if (metaPkg in allDeps || (!isTest && isPackageResolvable(metaPkg, root))) {
+      supportedSet.add(framework)
+    }
+  }
+
+  // Tier 2: Explicit Dependency & Node Resolution (Hoisting support)
   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 && isPackageResolvable(dep, root))) {
+        supportedSet.add(framework)
+        break
+      }
     }
   }
 
-  const unsupported: { name: string; dep: string }[] = []
+  // Tier 3: Check unsupported frameworks
   for (const fw of UNSUPPORTED_FRAMEWORKS) {
-    if (fw.dep in allDeps) {
+    if (fw.dep in allDeps || (!isTest && isPackageResolvable(fw.dep, root))) {
       unsupported.push(fw)
     }
   }
 
-  return { supported, unsupported }
+  return {
+    supported: Array.from(supportedSet),
+    unsupported,
+  }
 }