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

package/src/commands/init.ts

@@ -14,149 +14,18 @@ import { detectPackageManager, getInstallCommand } from '../detect/package-manag
 import { detectBuildTools, resolveInjectionTarget } from '../detect/build-tool.js'
 import { detectFrameworks } from '../detect/framework.js'
 import { detectIDE } from '../detect/ide.js'
-import { detectAITools, type AIToolDetection } from '../detect/ai-tool.js'
+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, BuildToolDetection } from '../types.js'
-
-/**
- * Interactive prompt for IDE choice.
- */
-async function promptIDEChoice(
-  detections: { ide: string; supported: boolean }[],
-): Promise<{ ide: string; supported: boolean } | null> {
-  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: ')
-
-    // We must resume stdin in case it was paused by a previous prompt
-    process.stdin.resume()
-    process.stdin.setEncoding('utf-8')
-
-    const onData = (data: Buffer) => {
-      const choice = parseInt(String(data).trim(), 10)
-
-      // Cleanup the listener to avoid memory leaks or multiple fires
-      process.stdin.off('data', onData)
-      process.stdin.pause() // Pause so the CLI can exit when done
-
-      if (choice >= 1 && choice <= detections.length) {
-        resolve(detections[choice - 1]!)
-      } else {
-        resolve(null)
-      }
-    }
-
-    process.stdin.on('data', onData)
-  })
-}
-/**
- * Interactive prompt for AI tool choice.
- */
-async function promptAIToolChoice(detections: AIToolDetection[]): Promise<AIToolDetection | null> {
-  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) => {
-    // Map toolModes array to human-readable labels
-    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: ')
-
-    // We must resume stdin in case it was paused by a previous prompt
-    process.stdin.resume()
-    process.stdin.setEncoding('utf-8')
-
-    const onData = (data: Buffer) => {
-      const choice = parseInt(String(data).trim(), 10)
-
-      // Cleanup the listener to avoid memory leaks or multiple fires
-      process.stdin.off('data', onData)
-      process.stdin.pause() // Pause so the CLI can exit when done
-
-      if (choice >= 1 && choice <= detections.length) {
-        resolve(detections[choice - 1]!)
-      } else {
-        resolve(null)
-      }
-    }
-
-    process.stdin.on('data', onData)
-  })
-}
-
-async function promptConfigChoice(
-  detections: BuildToolDetection[],
-): Promise<BuildToolDetection | null> {
-  if (!process.stdin.isTTY) {
-    log.warn('Multiple config files detected but stdin is not interactive')
-    log.hint(`Using: ${detections[0]!.label} (first match)`)
-    return detections[0]!
-  }
-
-  console.log()
-  console.log('  ? Detected multiple build tool configs:')
-  detections.forEach((d, i) => {
-    // Determine recommendation based on whether it seems like the "main" one
-    // We can infer Rsbuild > Rspack > Vite > Webpack as a priority if needed,
-    // but without package.json scripts analysis, we just highlight them plainly.
-    console.log(`      ${i + 1}. ${d.label}`)
-  })
-  console.log(`      ${detections.length + 1}. Skip (I'll configure manually)`)
-  console.log()
-
-  return new Promise(resolve => {
-    process.stdout.write('  > Your choice: ')
-
-    // We must resume stdin in case it was paused by a previous prompt
-    process.stdin.resume()
-    process.stdin.setEncoding('utf-8')
-
-    const onData = (data: Buffer) => {
-      const choice = parseInt(String(data).trim(), 10)
-
-      // Cleanup the listener to avoid memory leaks or multiple fires
-      process.stdin.off('data', onData)
-      process.stdin.pause() // Pause so the CLI can exit when done
-
-      if (choice >= 1 && choice <= detections.length) {
-        resolve(detections[choice - 1]!)
-      } else {
-        resolve(null)
-      }
-    }
-
-    process.stdin.on('data', onData)
-  })
-}
+import type { InitOptions, InstallLock, Mutation } from '../types.js'
+import {
+  promptIDEChoice,
+  promptProviderChoice,
+  promptConfigChoice,
+  promptUnsupportedFrameworkContinue,
+} from '../prompts.js'
+import { printNextJsManualInstructions, printNuxtManualInstructions } from '../instructions.js'
 
 export async function init(options: InitOptions): Promise<void> {
   const root = process.cwd()
@@ -172,56 +41,75 @@ export async function init(options: InitOptions): Promise<void> {
   }
 
   // ---- Step 2: Detect environment ----
+  const [pm, frameworkResult, buildResult, ideProbe, providerProbe] = await Promise.all([
+    detectPackageManager(root),
+    detectFrameworks(root),
+    detectBuildTools(root),
+    detectIDE(root),
+    detectProviders(root),
+  ])
 
   // Package manager
-  const pm = await detectPackageManager(root)
   log.success(`Detected package manager: ${pm}`)
 
-  // Framework detection (supported + unsupported)
-  const frameworkResult = await detectFrameworks(root)
+  // Framework verification
   if (frameworkResult.supported.length > 0) {
     log.success(`Detected framework: ${frameworkResult.supported.join(', ')}`)
   }
-  if (frameworkResult.unsupported.length > 0) {
-    const names = frameworkResult.unsupported.map(f => f.name).join(', ')
-    log.warn(`Detected ${names} — not supported in v1 (React / Vue only)`)
-    log.hint('Inspecto may still work but is not tested for this framework')
-  }
-  if (frameworkResult.supported.length === 0 && frameworkResult.unsupported.length === 0) {
-    log.warn('No frontend framework detected')
-    log.hint('Inspecto v1 supports React and Vue projects')
+
+  const hasUnsupportedFramework = frameworkResult.unsupported.length > 0
+  const hasNoFramework =
+    frameworkResult.supported.length === 0 && frameworkResult.unsupported.length === 0
+
+  if (hasUnsupportedFramework || hasNoFramework) {
+    if (hasUnsupportedFramework) {
+      const names = frameworkResult.unsupported.map(f => f.name).join(', ')
+      log.warn(`Detected ${names} — 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)')
+    }
   }
 
-  // Build tool detection (supported + unsupported)
-  const buildResult = await detectBuildTools(root)
+  // Build tool detection
+  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} — 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} — 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/docs/getting-started/manual-setup',
+    )
   }
 
   // IDE detection
-  const ideProbe = await detectIDE(root)
   let selectedIDE: { ide: string; supported: boolean } | null = null
 
   if (ideProbe.detected.length === 0) {
     log.error('No IDE detected in current project')
     log.hint('Please open this project in a supported IDE (like VS Code)')
-    // We could potentially block here, but we will allow the rest of the CLI to run
-    // for settings generation and build config injection.
   } else if (ideProbe.detected.length === 1) {
     selectedIDE = ideProbe.detected[0]!
   } else {
-    // Has multiple
     selectedIDE = await promptIDEChoice(ideProbe.detected)
   }
 
@@ -238,24 +126,21 @@ export async function init(options: InitOptions): Promise<void> {
   }
 
   // AI Tool detection
-  const aiToolProbe = await detectAITools(root)
-  let selectedAITool: AIToolDetection | null = null
+  let selectedProvider: ProviderDetection | null = null
 
-  // If user passed --prefer, we trust it over probing, but if they didn't:
-  if (!options.prefer) {
-    if (aiToolProbe.detected.length === 0) {
+  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 {
-      // Has multiple AI Tools
-      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}`)
       }
     }
   }
@@ -265,7 +150,7 @@ export async function init(options: InitOptions): Promise<void> {
   if (options.skipInstall) {
     log.warn('Skipping dependency installation (--skip-install)')
   } else {
-    const installCmd = getInstallCommand(pm, '@inspecto-dev/plugin')
+    const installCmd = getInstallCommand(pm, '@inspecto-dev/plugin @inspecto-dev/core')
     if (options.dryRun) {
       log.dryRun(`Would run: ${installCmd}`)
     } else {
@@ -274,18 +159,13 @@ export async function init(options: InitOptions): Promise<void> {
         if (result.stderr && result.stderr.toLowerCase().includes('error')) {
           throw new Error(result.stderr)
         }
-        log.success('Installed @inspecto-dev/plugin as devDependency')
-        mutations.push({
-          type: 'dependency_added',
-          name: '@inspecto-dev/plugin',
-          dev: true,
-        })
+        log.success('Installed @inspecto-dev/plugin and @inspecto-dev/core as devDependencies')
+        mutations.push({ type: 'dependency_added', name: '@inspecto-dev/plugin', dev: true })
+        mutations.push({ type: 'dependency_added', name: '@inspecto-dev/core', dev: true })
       } catch (err: any) {
         installFailed = true
         log.error(`Failed to install dependency: ${err?.message || 'Unknown error'}`)
         log.hint(`Run manually: ${installCmd}`)
-        // We do not return here to allow the rest of the setup to continue,
-        // but we will show a warning at the end instead of the success message.
       }
     }
   }
@@ -314,68 +194,58 @@ export async function init(options: InitOptions): Promise<void> {
 
   // ---- Step 5: Generate default settings ----
   const settingsDir = path.join(root, '.inspecto')
-  const settingsPath = path.join(settingsDir, 'settings.json')
-  const promptsPath = path.join(settingsDir, 'prompts.json')
+  const settingsFileName = options.shared ? 'settings.json' : 'settings.local.json'
+  const promptsFileName = options.shared ? 'prompts.json' : 'prompts.local.json'
+
+  const settingsPath = path.join(settingsDir, settingsFileName)
+  const promptsPath = path.join(settingsDir, promptsFileName)
 
   if (await exists(settingsPath)) {
-    // Attempt to read the existing settings file to see if it's valid JSON
     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 {
-    // Only omit properties that can be auto-inferred
-    // The schema allows empty objects or just specifying the IDE/prefer
     const defaultSettings: Record<string, unknown> = {}
 
     if (selectedIDE && selectedIDE.supported) {
-      defaultSettings.ide = selectedIDE.ide === 'vscode' ? 'vscode' : selectedIDE.ide // Fallback string handling
+      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 the selected tool has a specific mode (like cli vs plugin), we can pre-configure the providers block
-      // to ensure it uses the intended mode, providing an optimal out-of-the-box experience.
-      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 as string
+      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}` })
     }
   }
 
-  // Generate prompts.json to disable low-frequency intents by default
   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: unknown[] = []
 
     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}` })
     }
   }
 
@@ -401,19 +271,17 @@ export async function init(options: InitOptions): Promise<void> {
     await writeJSON(path.join(settingsDir, 'install.lock'), lock)
   }
 
-  // ---- Step 8: Install VS Code extension ----
-  // Only attempt if IDE is VS Code or not detected (might be VS Code)
+  // ---- Step 8: Install IDE extension ----
   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) {
-    // Unsupported IDE detected — skip extension, already warned above
+    // Unsupported IDE detected — skip extension
   } else {
-    const extMutation = await installExtension(options.dryRun)
+    const extMutation = await installExtension(options.dryRun, selectedIDE?.ide)
     if (extMutation && !options.dryRun) {
       mutations.push(extMutation)
 
@@ -436,10 +304,22 @@ export async function init(options: InitOptions): Promise<void> {
   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.')

package/src/commands/teardown.ts

@@ -3,7 +3,7 @@
 // ============================================================
 import path from 'node:path'
 import { log } from '../utils/logger.js'
-import { exists, readJSON, copyFile, removeDir, removeFile } from '../utils/fs.js'
+import { exists, readJSON, removeDir } from '../utils/fs.js'
 import { shell } from '../utils/exec.js'
 import { detectPackageManager, getUninstallCommand } from '../detect/package-manager.js'
 import { cleanGitignore } from '../inject/gitignore.js'
@@ -43,7 +43,7 @@ export async function teardown(): Promise<void> {
     log.success('Cleaned .gitignore entries')
 
     // Warn about config file
-    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()
@@ -57,27 +57,17 @@ export async function teardown(): Promise<void> {
   for (const mutation of lock.mutations) {
     switch (mutation.type) {
       case 'file_modified': {
-        if (mutation.backup && mutation.path) {
-          const backupPath = path.join(root, mutation.backup)
-          const targetPath = path.join(root, mutation.path)
-
-          if (mutation.path === '.gitignore') {
-            // For .gitignore, use the clean function instead of backup restore
-            await cleanGitignore(root)
-            log.success('Cleaned .gitignore entries')
-            // Remove the .gitignore backup if it exists
-            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') {
+          // gitignore is cleaned up at the end of teardown, so we can just log here
+          log.success('Cleaned .gitignore entries')
+        } else if (mutation.path) {
+          // We no longer create .bak files in the new AST approach.
+          // In a future update, we can use magicast to auto-remove the plugin from AST.
+          // For now, we print a manual warning since we did not backup the file.
+          log.warn(`Cannot auto-restore ${mutation.path}`)
+          log.hint(`Please manually remove the inspecto plugin from ${mutation.path}`)
         }
         break
       }

package/src/detect/build-tool.ts

@@ -11,6 +11,7 @@ import type { BuildTool, BuildToolDetection } from '../types.js'
 interface PackageJSON {
   dependencies?: Record<string, string>
   devDependencies?: Record<string, string>
+  scripts?: Record<string, string>
 }
 
 /** Supported build tools in v1 */
@@ -37,7 +38,7 @@ const SUPPORTED_PATTERNS: { tool: BuildTool; files: string[]; label: string }[]
   },
   {
     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',
   },
   {
@@ -73,39 +74,106 @@ export async function detectBuildTools(root: string): Promise<BuildToolResult> {
   const pkg = await readJSON<PackageJSON>(path.join(root, 'package.json'))
   const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies }
 
-  for (const pattern of SUPPORTED_PATTERNS) {
+  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]
+
+    // 2. Look for config files
+    let detectedFile = ''
+
+    // For esbuild, dependency is strictly required
+    if (pattern.tool === 'esbuild' && !hasDep) {
+      return null
+    }
+
     for (const file of pattern.files) {
       if (await exists(path.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
+      }
+    }
+
+    // 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')) {
+      // Look at npm scripts to guess the build file
+      const scripts = pkg?.scripts || {}
+      for (const [_, cmd] of Object.entries(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
+            }
           }
+        } else if (cmd.includes(`${pattern.tool} `)) {
+          detectedFile = 'package.json (scripts)'
+          break
         }
+      }
+    }
+
+    if (detectedFile) {
+      let isLegacyRspack = false
+      let isLegacyWebpack = false
 
-        supported.push({
-          tool: pattern.tool,
-          configPath: file,
-          label: `${pattern.label} (${file})${isLegacyRspack ? ' [Legacy]' : ''}`,
-          isLegacyRspack,
-        })
-        break // One match per tool
+      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
+        }
+      } else if (pattern.tool === 'webpack') {
+        const version = allDeps['webpack'] || allDeps['webpack-cli']
+        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(path.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 }