@inspecto-dev/cli 0.2.0-alpha.4 → 0.2.0-alpha.6

package/src/commands/init.ts

@@ -8,27 +8,26 @@
 // ============================================================
 import path from 'node:path'
 import { log } from '../utils/logger.js'
-import { exists, writeJSON, readJSON } from '../utils/fs.js'
-import { shell } from '../utils/exec.js'
-import { detectPackageManager, getInstallCommand } from '../detect/package-manager.js'
+import { exists } from '../utils/fs.js'
+import { detectPackageManager } from '../detect/package-manager.js'
 import { detectBuildTools, resolveInjectionTarget } from '../detect/build-tool.js'
 import { detectFrameworks } from '../detect/framework.js'
 import { detectIDE } from '../detect/ide.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'
+import { applyOnboardingPlan } from '../onboarding/apply.js'
+import type { InitOptions, Mutation, BuildToolDetection } from '../types.js'
 import {
   promptIDEChoice,
   promptProviderChoice,
   promptConfigChoice,
+  promptMonorepoPackageChoice,
   promptUnsupportedFrameworkContinue,
 } from '../prompts.js'
 import { printNextJsManualInstructions, printNuxtManualInstructions } from '../instructions.js'
 
 export async function init(options: InitOptions): Promise<void> {
-  const root = process.cwd()
+  const repoRoot = process.cwd()
+  let projectRoot = repoRoot
   const mutations: Mutation[] = []
   const normalizedPackages = normalizePackageList(options.packages)
 
@@ -40,7 +39,7 @@ export async function init(options: InitOptions): Promise<void> {
       continue
     }
 
-    const absolutePath = path.join(root, pkg)
+    const absolutePath = path.join(repoRoot, pkg)
     if (await exists(absolutePath)) {
       verifiedPackages.push(pkg)
     } else {
@@ -57,19 +56,50 @@ export async function init(options: InitOptions): Promise<void> {
   log.header('Inspecto Setup')
 
   // ---- Step 1: Validate project ----
-  if (!(await exists(path.join(root, 'package.json')))) {
+  if (!(await exists(path.join(repoRoot, 'package.json')))) {
     log.error('No package.json found in current directory')
     log.hint('Run this command from your project root')
     return
   }
 
   // ---- Step 2: Detect environment ----
-  const [pm, frameworkResult, buildResult, ideProbe, providerProbe] = await Promise.all([
-    detectPackageManager(root),
-    detectFrameworks(root),
-    detectBuildTools(root, verifiedPackages.length > 0 ? verifiedPackages : undefined),
-    detectIDE(root),
-    detectProviders(root),
+  const pm = await detectPackageManager(repoRoot)
+  let buildResult = await detectBuildTools(
+    repoRoot,
+    verifiedPackages.length > 0 ? verifiedPackages : undefined,
+  )
+
+  if (verifiedPackages.length === 0) {
+    const monorepoTargets = Array.from(
+      new Set(
+        buildResult.supported.map(d => d.packagePath).filter((value): value is string => !!value),
+      ),
+    )
+
+    if (monorepoTargets.length > 1) {
+      log.warn('Monorepo root detected with multiple candidate apps.')
+      const selectedPackage = await promptMonorepoPackageChoice(buildResult.supported)
+      if (!selectedPackage) {
+        log.hint('Run `inspecto init` inside the target app, or pass --packages <app-path>.')
+        return
+      }
+
+      projectRoot = path.join(repoRoot, selectedPackage)
+      buildResult = await detectBuildTools(repoRoot, [selectedPackage])
+      log.info(`Continuing initialization in ${selectedPackage}`)
+    } else if (monorepoTargets.length === 1) {
+      const [selectedPackage] = monorepoTargets
+      projectRoot = path.join(repoRoot, selectedPackage!)
+      buildResult = await detectBuildTools(repoRoot, [selectedPackage!])
+      log.warn(`Monorepo root detected. Using the only candidate app: ${selectedPackage}`)
+      log.hint('Run `inspecto init` inside that app next time to skip this prompt.')
+    }
+  }
+
+  const [frameworkResult, ideProbe, providerProbe] = await Promise.all([
+    detectFrameworks(projectRoot),
+    detectIDE(projectRoot),
+    detectProviders(projectRoot),
   ])
 
   // Package manager
@@ -77,7 +107,15 @@ export async function init(options: InitOptions): Promise<void> {
 
   // Framework verification
   if (frameworkResult.supported.length > 0) {
-    log.success(`Detected framework: ${frameworkResult.supported.join(', ')}`)
+    const frameworks = frameworkResult.supported.join(', ')
+    log.success(`Detected framework: ${frameworks}`)
+    if (frameworkResult.unsupported.length > 0) {
+      log.hint(
+        `Other frameworks detected (${frameworkResult.unsupported
+          .map(f => f.name)
+          .join(', ')}) will be skipped in this setup.`,
+      )
+    }
   }
 
   const isSupported = frameworkResult.supported.length > 0
@@ -125,6 +163,13 @@ export async function init(options: InitOptions): Promise<void> {
     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.unsupported.includes('Next.js')) {
+      printNextJsManualInstructions()
+    }
+    if (buildResult.unsupported.includes('Nuxt')) {
+      printNuxtManualInstructions()
+    }
   }
   if (buildResult.supported.length === 0 && buildResult.unsupported.length === 0) {
     log.warn('No recognized build tool detected')
@@ -161,6 +206,9 @@ export async function init(options: InitOptions): Promise<void> {
 
   // AI Tool detection
   let selectedProvider: ProviderDetection | null = null
+  const explicitProvider = options.provider
+    ? (providerProbe.detected.find(provider => provider.id === options.provider) ?? null)
+    : null
 
   if (!options.provider) {
     if (providerProbe.detected.length === 0) {
@@ -172,40 +220,19 @@ export async function init(options: InitOptions): Promise<void> {
         log.success(`Detected AI tool: ${selectedProvider.label}`)
       }
     } else {
+      log.info('Multiple providers detected, waiting for your selection...')
       selectedProvider = await promptProviderChoice(providerProbe.detected)
       if (selectedProvider) {
         log.success(`Selected provider: ${selectedProvider.label}`)
+      } else {
+        log.warn('No provider selected. You can set provider.default later in .inspecto/settings.')
       }
     }
   }
 
-  // ---- Step 3: Install dependency ----
-  let installFailed = false
-  if (options.skipInstall) {
-    log.warn('Skipping dependency installation (--skip-install)')
-  } else {
-    const installCmd = getInstallCommand(pm, '@inspecto-dev/plugin @inspecto-dev/core')
-    if (options.dryRun) {
-      log.dryRun(`Would run: ${installCmd}`)
-    } else {
-      try {
-        const result = await shell(installCmd, root)
-        if (result.stderr && result.stderr.toLowerCase().includes('error')) {
-          throw new Error(result.stderr)
-        }
-        log.success('Installed @inspecto-dev/plugin and @inspecto-dev/core as devDependencies')
-        mutations.push({ type: 'dependency_added', name: '@inspecto-dev/plugin', dev: true })
-        mutations.push({ type: 'dependency_added', name: '@inspecto-dev/core', dev: true })
-      } catch (err: any) {
-        installFailed = true
-        log.error(`Failed to install dependency: ${err?.message || 'Unknown error'}`)
-        log.hint(`Run manually: ${installCmd}`)
-      }
-    }
-  }
-
-  // ---- Step 4: Inject plugin into build config ----
-  let injectionFailed = false
+  // ---- Step 3: Resolve injection targets ----
+  let injectionSkippedRequiresManualConfig = false
+  const supportedBuildTargets: BuildToolDetection[] = []
   if (buildResult.supported.length > 0) {
     if (verifiedPackages.length > 0) {
       const targets = buildResult.supported.filter(detection =>
@@ -226,17 +253,10 @@ export async function init(options: InitOptions): Promise<void> {
       }
 
       if (targets.length === 0) {
-        injectionFailed = true
+        injectionSkippedRequiresManualConfig = true
       }
 
-      for (const target of targets) {
-        const result = await injectPlugin(root, target, options.dryRun)
-        if (result.success) {
-          mutations.push(...result.mutations)
-        } else {
-          injectionFailed = true
-        }
-      }
+      supportedBuildTargets.push(...targets)
     } else {
       let target = resolveInjectionTarget(buildResult.supported)
 
@@ -245,150 +265,53 @@ export async function init(options: InitOptions): Promise<void> {
       }
 
       if (target) {
-        const result = await injectPlugin(root, target, options.dryRun)
-        if (result.success) {
-          mutations.push(...result.mutations)
-        } else {
-          injectionFailed = true
-        }
+        supportedBuildTargets.push(target)
       } else {
-        injectionFailed = true
+        injectionSkippedRequiresManualConfig = true
         log.warn('Skipping plugin injection (manual configuration required)')
       }
     }
   }
 
-  // ---- Step 5: Generate default settings ----
-  const settingsDir = path.join(root, '.inspecto')
-  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)) {
-    const existingSettings = await readJSON(settingsPath)
-    if (existingSettings === null) {
-      log.warn(`.inspecto/${settingsFileName} exists but contains invalid JSON`)
-      log.hint('Please fix the syntax errors manually, or delete it and re-run init')
-    } else {
-      log.success(`.inspecto/${settingsFileName} already exists (skipped)`)
-    }
-  } else {
-    const defaultSettings: Record<string, unknown> = {}
-
-    if (selectedIDE && selectedIDE.supported) {
-      defaultSettings.ide =
-        selectedIDE.ide.toLowerCase() === 'vscode' ? 'vscode' : selectedIDE.ide.toLowerCase()
-    }
-
-    if (options.provider) {
-      const tool = options.provider
-      const mode = tool === 'coco' ? 'cli' : 'extension'
-      defaultSettings['provider.default'] = `${tool}.${mode}`
-    } else if (selectedProvider) {
-      const toolId = selectedProvider.id as string
-      const mode = selectedProvider.preferredMode === 'cli' ? 'cli' : 'extension'
-      defaultSettings['provider.default'] = `${toolId}.${mode}`
-    }
-
-    if (options.dryRun) {
-      log.dryRun(`Would create .inspecto/${settingsFileName}`)
-    } else {
-      await writeJSON(settingsPath, defaultSettings)
-      log.success(`Created .inspecto/${settingsFileName}`)
-      mutations.push({ type: 'file_created', path: `.inspecto/${settingsFileName}` })
-    }
-  }
-
-  if (await exists(promptsPath)) {
-    log.success(`.inspecto/${promptsFileName} already exists (skipped)`)
-  } else {
-    const defaultPrompts: unknown[] = []
-
-    if (options.dryRun) {
-      log.dryRun(`Would create .inspecto/${promptsFileName}`)
-    } else {
-      await writeJSON(promptsPath, defaultPrompts)
-      log.success(`Created .inspecto/${promptsFileName}`)
-      mutations.push({ type: 'file_created', path: `.inspecto/${promptsFileName}` })
-    }
-  }
-
-  // ---- Step 6: Update .gitignore ----
-  if (!options.dryRun) {
-    await updateGitignore(root, options.shared, options.dryRun)
-    mutations.push({
-      type: 'file_modified',
-      path: '.gitignore',
-      description: 'Appended .inspecto/ ignore rules',
-    })
-  } else {
-    log.dryRun('Would update .gitignore')
-  }
-
-  // ---- Step 7: Write install.lock ----
-  if (!options.dryRun && mutations.length > 0) {
-    const lock: InstallLock = {
-      version: '1.0.0',
-      created_at: new Date().toISOString(),
-      mutations,
-    }
-    await writeJSON(path.join(settingsDir, 'install.lock'), lock)
-  }
-
-  // ---- Step 8: Install IDE extension ----
-  const shouldInstallExt =
-    !options.noExtension && (!selectedIDE || (selectedIDE && selectedIDE.supported))
-  let manualExtensionInstallNeeded = false
-
-  if (options.noExtension) {
-    log.warn('Skipping IDE extension (--no-extension)')
-  } else if (!shouldInstallExt) {
-    // Unsupported IDE detected — skip extension
-  } else {
-    const extMutation = await installExtension(options.dryRun, selectedIDE?.ide)
-    if (extMutation && !options.dryRun) {
-      mutations.push(extMutation)
-
-      if (extMutation.manual_action_required) {
-        manualExtensionInstallNeeded = true
-      }
-
-      const lockPath = path.join(settingsDir, 'install.lock')
-      const lock = await readJSON<InstallLock>(lockPath)
-      if (lock) {
-        lock.mutations = mutations
-        await writeJSON(lockPath, lock)
-      }
-    } else if (extMutation === null && !options.dryRun) {
-      manualExtensionInstallNeeded = true
-    }
-  }
+  const providerDefault = options.provider
+    ? `${options.provider}.${explicitProvider?.preferredMode ?? (options.provider === 'coco' ? 'cli' : 'extension')}`
+    : selectedProvider
+      ? `${selectedProvider.id}.${selectedProvider.preferredMode === 'cli' ? 'cli' : 'extension'}`
+      : undefined
+
+  const applyResult = await applyOnboardingPlan({
+    repoRoot,
+    projectRoot,
+    packageManager: pm,
+    supportedBuildTargets,
+    options: {
+      shared: options.shared,
+      skipInstall: options.skipInstall,
+      dryRun: options.dryRun,
+      noExtension: options.noExtension,
+    },
+    selectedIDE,
+    providerDefault,
+    manualConfigRequiredFor,
+    injectionSkippedRequiresManualConfig,
+    allowManualPlanApply: true,
+  })
+  mutations.push(...applyResult.mutations)
 
   // ---- Done ----
   if (options.dryRun) {
     log.blank()
     log.warn('Dry run complete. No files were modified.')
-  } else if (
-    installFailed ||
-    injectionFailed ||
-    manualExtensionInstallNeeded ||
-    manualConfigRequiredFor
-  ) {
+  } else {
     log.blank()
-    log.warn('Setup completed with some manual steps required.')
-
-    if (manualConfigRequiredFor === 'Nuxt') {
-      printNuxtManualInstructions()
-    } else if (manualConfigRequiredFor === 'Next.js') {
-      printNextJsManualInstructions()
+    if (applyResult.postInstall.nextSteps.length > 0) {
+      log.warn('──────── Manual Steps Required ────────')
+      applyResult.postInstall.nextSteps.forEach(step => log.error(step))
+      log.hint('Complete the items above.')
+      log.blank()
     } else {
-      log.hint('Please check the logs above and complete the manual steps.')
+      log.ready('Ready! Hold Alt + Click any element to inspect.')
     }
-    log.blank()
-  } else {
-    log.ready('Ready! Hold Alt + Click any element to inspect.')
   }
 }
 

package/src/commands/plan.ts

@@ -0,0 +1,41 @@
+import { log } from '../utils/logger.js'
+import { writeCommandOutput } from '../utils/output.js'
+import { buildOnboardingContext } from '../onboarding/context.js'
+import { createPlanResult } from '../onboarding/planner.js'
+import type { PlanResult } from '../types.js'
+
+function printPlanResult(result: PlanResult): void {
+  log.header('Inspecto Plan')
+  log.info(`Status: ${result.status}`)
+  log.info(`Strategy: ${result.strategy}`)
+
+  if (result.defaults.provider) {
+    log.info(`Default provider: ${result.defaults.provider}`)
+  }
+  if (result.defaults.ide) {
+    log.info(`Default IDE: ${result.defaults.ide}`)
+  }
+  log.info(`Shared mode: ${result.defaults.shared ? 'enabled' : 'disabled'}`)
+  log.info(`Extension mode: ${result.defaults.extension ? 'enabled' : 'disabled'}`)
+
+  if (result.actions.length > 0) {
+    log.blank()
+    log.info('Actions:')
+    for (const action of result.actions) {
+      log.hint(`${action.type}: ${action.target} — ${action.description}`)
+    }
+  }
+
+  for (const blocker of result.blockers) {
+    log.error(blocker.message)
+  }
+  for (const warning of result.warnings) {
+    log.warn(warning.message)
+  }
+}
+
+export async function plan(json = false): Promise<PlanResult> {
+  const context = await buildOnboardingContext(process.cwd())
+  const result = createPlanResult(context)
+  return writeCommandOutput(result, json, printPlanResult)
+}

package/src/detect/build-tool.ts

@@ -5,8 +5,9 @@
 // Recognized but unsupported: Next.js / Nuxt / Remix / Astro / SvelteKit
 // ============================================================
 import path from 'node:path'
+import fs from 'node:fs/promises'
 import { createRequire } from 'node:module'
-import { exists, readJSON } from '../utils/fs.js'
+import { exists, readFile, readJSON } from '../utils/fs.js'
 import type { BuildTool, BuildToolDetection } from '../types.js'
 
 interface PackageJSON {
@@ -128,6 +129,89 @@ function createTargets(root: string, packagePaths?: string[]): DetectionTarget[]
   }))
 }
 
+async function getWorkspacePackagePatterns(root: string): Promise<string[]> {
+  const pkg = await readJSON<{ workspaces?: string[] | { packages?: string[] } }>(
+    path.join(root, 'package.json'),
+  )
+
+  const workspaces = pkg?.workspaces
+  if (Array.isArray(workspaces)) {
+    return workspaces
+  }
+
+  if (workspaces && Array.isArray(workspaces.packages)) {
+    return workspaces.packages
+  }
+
+  const pnpmWorkspace = await readFile(path.join(root, 'pnpm-workspace.yaml'))
+  if (!pnpmWorkspace) {
+    return []
+  }
+
+  const patterns: string[] = []
+  for (const line of pnpmWorkspace.split('\n')) {
+    const match = line.match(/^\s*-\s*['"]?([^'"]+)['"]?\s*$/)
+    if (match?.[1]) {
+      patterns.push(match[1])
+    }
+  }
+
+  return patterns
+}
+
+async function expandWorkspacePattern(root: string, pattern: string): Promise<string[]> {
+  const normalized = pattern.replace(/\\/g, '/').replace(/\/$/, '')
+  if (!normalized || normalized.startsWith('!')) {
+    return []
+  }
+
+  if (!normalized.includes('*')) {
+    return (await exists(path.join(root, normalized))) ? [normalized] : []
+  }
+
+  const starIndex = normalized.indexOf('*')
+  const baseDir = normalized.slice(0, starIndex).replace(/\/$/, '')
+  const suffix = normalized.slice(starIndex + 1)
+
+  if (suffix && suffix !== '') {
+    return []
+  }
+
+  const absoluteBaseDir = path.join(root, baseDir)
+  if (!(await exists(absoluteBaseDir))) {
+    return []
+  }
+
+  try {
+    const entries = await fs.readdir(absoluteBaseDir, { withFileTypes: true })
+    return entries
+      .filter(entry => entry.isDirectory())
+      .map(entry => path.posix.join(baseDir, entry.name))
+  } catch {
+    return []
+  }
+}
+
+async function detectWorkspaceTargets(root: string): Promise<DetectionTarget[]> {
+  const patterns = await getWorkspacePackagePatterns(root)
+  if (patterns.length === 0) {
+    return []
+  }
+
+  const packagePaths = new Set<string>()
+  for (const pattern of patterns) {
+    const expanded = await expandWorkspacePattern(root, pattern)
+    for (const packagePath of expanded) {
+      packagePaths.add(packagePath)
+    }
+  }
+
+  return Array.from(packagePaths).map(packagePath => ({
+    packagePath,
+    absolutePath: path.join(root, packagePath),
+  }))
+}
+
 /**
  * Detect all build tools / meta-frameworks.
  * Returns supported tools and recognized-but-unsupported meta-frameworks.
@@ -138,7 +222,10 @@ export async function detectBuildTools(
 ): Promise<BuildToolResult> {
   const supported: BuildToolDetection[] = []
   const unsupported = new Set<string>()
-  const targets = createTargets(root, packagePaths)
+  const explicitTargets = createTargets(root, packagePaths)
+  const workspaceTargets =
+    !packagePaths || packagePaths.length === 0 ? await detectWorkspaceTargets(root) : []
+  const targets = workspaceTargets.length > 0 ? workspaceTargets : explicitTargets
 
   for (const target of targets) {
     const pkg = await readJSON<PackageJSON>(path.join(target.absolutePath, 'package.json'))
@@ -230,6 +317,7 @@ async function detectPattern({
   }
 
   let detectedFile = ''
+  let inferredFromScripts = false
 
   if (pattern.tool === 'esbuild' && !hasDep) {
     return null
@@ -274,6 +362,7 @@ async function detectPattern({
         }
 
         if (!detectedFile) {
+          inferredFromScripts = true
           detectedFile = 'package.json (scripts)'
           break
         }
@@ -282,6 +371,21 @@ async function detectPattern({
   }
 
   if (!detectedFile) {
+    if (
+      hasDep &&
+      (pattern.tool === 'rollup' ||
+        pattern.tool === 'webpack' ||
+        pattern.tool === 'rspack' ||
+        pattern.tool === 'esbuild')
+    ) {
+      // dependency present but no config/scripting evidence; provide low-confidence detection
+      return {
+        tool: pattern.tool,
+        configPath: 'package.json (dependency)',
+        label: `${pattern.label} (detected via dependency)`,
+        packagePath: packagePath || undefined,
+      }
+    }
     return null
   }
 
@@ -311,7 +415,7 @@ async function detectPattern({
     configPath: relativeConfig,
     label: `${pattern.label} (${relativeConfig})${isLegacyRspack ? ' [Legacy]' : ''}${
       isLegacyWebpack ? ' [Webpack 4]' : ''
-    }`,
+    }${inferredFromScripts ? ' [Scripts Detected]' : ''}`,
     isLegacyRspack,
     isLegacyWebpack,
     packagePath: packagePath || undefined,

package/src/index.ts

@@ -1,5 +1,16 @@
+export { apply } from './commands/apply.js'
+export { detect } from './commands/detect.js'
 export { init } from './commands/init.js'
-export { doctor } from './commands/doctor.js'
+export { collectDoctorResult, doctor } from './commands/doctor.js'
+export { plan } from './commands/plan.js'
 export { teardown } from './commands/teardown.js'
-export type { InitOptions, BuildTool, PackageManager, InstallLock } from './types.js'
+export { writeCommandOutput, reportCommandError } from './utils/output.js'
+export type {
+  InitOptions,
+  BuildTool,
+  PackageManager,
+  InstallLock,
+  DoctorDiagnostic,
+  DoctorResult,
+} from './types.js'
 export type { Framework } from './detect/framework.js'

package/src/inject/ast-injector.ts

@@ -15,7 +15,7 @@
 
 import path from 'node:path'
 import { loadFile, writeFile as writeAstFile } from 'magicast'
-import { exists, readFile } from '../utils/fs.js'
+import { readFile } from '../utils/fs.js'
 import { log } from '../utils/logger.js'
 import type { BuildToolDetection, Mutation } from '../types.js'
 import { STRATEGIES } from './strategies/index.js'
@@ -33,7 +33,7 @@ function printManualInstructions(
 
   if (strategy) {
     const instructions = strategy.getManualInstructions(detection, reason)
-    log.codeBlock(instructions)
+    log.copyableCodeBlock(instructions)
   } else {
     log.error(`Unsupported build tool: ${detection.tool}`)
   }
@@ -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

@@ -125,7 +125,9 @@ export async function installExtension(dryRun: boolean, ide?: string): Promise<M
   // Other IDEs: Prompt to install via VSIX
   log.warn(`Could not auto-install extension for ${ide}`)
   log.hint('Please install it manually to enable Inspector features:')
-  log.hint('  1. Download the latest .vsix file from Inspecto releases')
+  log.hint(
+    '  1. Download the latest .vsix file (Open VSX: https://open-vsx.org/extension/inspecto/inspecto)',
+  )
   log.hint(`  2. Open ${ide}`)
   log.hint('  3. Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P)')
   log.hint('  4. Type and select "Extensions: Install from VSIX..."')