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

package/src/detect/ide.ts

@@ -1,7 +1,7 @@
 // ============================================================
-// src/detect/ide.ts — IDE detection (v1: VS Code only)
+// src/detect/ide.ts — IDE detection
 //
-// Detects ALL known IDEs, but only VS Code is fully supported.
+// Detects ALL known IDEs, but only VS Code, Cursor, and Trae are fully supported.
 // Others are recognized and surfaced as unsupported.
 // ============================================================
 import path from 'node:path'
@@ -28,7 +28,7 @@ export async function detectIDE(root: string): Promise<IDEProbeResult> {
 
   // Cursor
   if (process.env.CURSOR_TRACE_DIR || process.env.CURSOR_CHANNEL) {
-    detected.set('Cursor', { ide: 'Cursor', supported: false })
+    detected.set('Cursor', { ide: 'cursor', supported: true })
   }
 
   // Trae
@@ -38,7 +38,7 @@ export async function detectIDE(root: string): Promise<IDEProbeResult> {
     process.env.COCO_IDE_PLUGIN_TYPE === 'Trae' ||
     (process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes('trae'))
   ) {
-    detected.set('Trae', { ide: 'Trae', supported: false })
+    detected.set('Trae', { ide: 'trae', supported: true })
   }
 
   // Zed
@@ -46,32 +46,53 @@ export async function detectIDE(root: string): Promise<IDEProbeResult> {
     detected.set('Zed', { ide: 'Zed', supported: false })
   }
 
-  // VS Code
-  // Must ensure we haven't already flagged it as Trae/Cursor since they share this variable
-  if (process.env.TERM_PROGRAM === 'vscode') {
-    if (!detected.has('Trae') && !detected.has('Cursor')) {
-      detected.set('vscode', { ide: SUPPORTED_IDE, supported: true })
-    }
+  // Windsurf
+  if (
+    process.env.WINDSURF_APP_DIR ||
+    process.env.WINDSURF_CHANNEL ||
+    process.env.__CFBundleIdentifier === 'com.codeium.windsurf' ||
+    (process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes('windsurf'))
+  ) {
+    detected.set('Windsurf', { ide: 'Windsurf', supported: false })
   }
 
+  // VS Code
+  // We cannot rely purely on TERM_PROGRAM === 'vscode' because Cursor and Trae also use it.
+  // We should ONLY use it as a fallback if no other specific variables were found, and we'll do that at the end.
+  // if (process.env.TERM_PROGRAM === 'vscode') { ... }
+
   // 2. Check Directory Artifacts (Indicates project has been opened in these IDEs)
-  if (await exists(path.join(root, '.trae'))) {
-    detected.set('Trae', { ide: 'Trae', supported: false })
+  const [hasTrae, hasCursor, hasVscode, hasIdea] = await Promise.all([
+    exists(path.join(root, '.trae')),
+    exists(path.join(root, '.cursor')),
+    exists(path.join(root, '.vscode')),
+    exists(path.join(root, '.idea')),
+  ])
+
+  // If a directory artifact exists, add it to the detection list.
+  // This allows us to surface multiple options (e.g. if you are in Cursor but also have a .vscode folder).
+  if (hasTrae && !detected.has('Trae')) {
+    detected.set('Trae', { ide: 'trae', supported: true })
   }
-  if (await exists(path.join(root, '.cursor'))) {
-    detected.set('Cursor', { ide: 'Cursor', supported: false })
+  if (hasCursor && !detected.has('Cursor')) {
+    detected.set('Cursor', { ide: 'cursor', supported: true })
   }
-  if (await exists(path.join(root, '.vscode'))) {
-    // Only add vscode if it wasn't already caught by terminal,
-    // or if the terminal is something else but .vscode exists.
-    if (!detected.has('vscode')) {
-      detected.set('vscode', { ide: SUPPORTED_IDE, supported: true })
-    }
+
+  // Only add vscode based on .vscode directory if it wasn't already added.
+  if (hasVscode && !detected.has('vscode')) {
+    detected.set('vscode', { ide: SUPPORTED_IDE, supported: true })
   }
-  if (await exists(path.join(root, '.idea'))) {
+
+  if (hasIdea && !detected.has('JetBrains IDE')) {
     detected.set('JetBrains IDE', { ide: 'JetBrains IDE', supported: false })
   }
 
+  // Fallback: If we still don't have ANY IDE detected, but we are in a terminal that identifies as 'vscode'
+  // (which could be Cursor without its specific env vars, though rare), we fallback to 'vscode'
+  if (detected.size === 0 && process.env.TERM_PROGRAM === 'vscode') {
+    detected.set('vscode', { ide: SUPPORTED_IDE, supported: true })
+  }
+
   return {
     detected: Array.from(detected.values()),
   }

package/src/detect/package-manager.ts

@@ -18,9 +18,16 @@ export async function detectPackageManager(root: string): Promise<PackageManager
     ['package-lock.json', 'npm'],
   ]
 
-  for (const [file, pm] of checks) {
-    if (await exists(path.join(root, file))) {
-      return pm
+  const results = await Promise.all(
+    checks.map(async ([file, pm]) => {
+      const isExist = await exists(path.join(root, file))
+      return { isExist, pm }
+    }),
+  )
+
+  for (const result of results) {
+    if (result.isExist) {
+      return result.pm
     }
   }
 

package/src/detect/provider.ts

@@ -0,0 +1,151 @@
+// ============================================================
+// src/detect/provider.ts — AI Provider detection (v1)
+//
+// Detects installed AI providers via PATH (CLI) or IDE extensions (Extension).
+// ============================================================
+import path from 'node:path'
+import { exists, readJSON } from '../utils/fs.js'
+import { which } from '../utils/exec.js'
+import type { Provider, ProviderMode } from '@inspecto-dev/types'
+
+export interface ProviderDetection {
+  id: Provider
+  label: string
+  supported: boolean
+  providerModes: Array<'cli' | 'extension'>
+  // The primary mode that will be written to settings if selected
+  preferredMode: 'cli' | 'extension'
+}
+
+const KNOWN_CLI_TOOLS: { id: Provider; bin: string; label: string; supported: boolean }[] = [
+  { id: 'claude-code', bin: 'claude', label: 'Claude Code', supported: true },
+  { id: 'coco', bin: 'coco', label: 'Trae CLI (Coco)', supported: true },
+  { id: 'codex', bin: 'codex', label: 'Codex CLI', supported: true },
+  { id: 'gemini', bin: 'gemini', label: 'Gemini CLI', supported: true },
+]
+
+const KNOWN_IDE_PLUGINS: { id: Provider; extId: string; label: string; supported: boolean }[] = [
+  { id: 'claude-code', extId: 'anthropic.claude-code', label: 'Claude Code', supported: true },
+  { id: 'copilot', extId: 'github.copilot', label: 'GitHub Copilot', supported: true },
+  { id: 'codex', extId: 'openai.chatgpt', label: 'Codex (ChatGPT)', supported: true },
+  { id: 'gemini', extId: 'google.geminicodeassist', label: 'Gemini Code Assist', supported: true },
+]
+
+export interface ProviderProbeResult {
+  detected: ProviderDetection[]
+}
+
+/**
+ * Detect all installed AI tools by checking PATH binaries and IDE extensions.
+ */
+export async function detectProviders(root: string): Promise<ProviderProbeResult> {
+  // Use a map to merge duplicate CLI/Plugin detections for the same AI tool
+  const detectedMap = new Map<Provider, ProviderDetection>()
+
+  // 1. Detect CLI tools concurrently
+  const cliChecks = KNOWN_CLI_TOOLS.map(async tool => {
+    if (await which(tool.bin)) {
+      detectedMap.set(tool.id, {
+        id: tool.id,
+        label: tool.label,
+        supported: tool.supported,
+        providerModes: ['cli'],
+        preferredMode: 'cli',
+      })
+    }
+  })
+  await Promise.all(cliChecks)
+
+  // 2. Detect IDE plugins (VS Code extensions)
+  // Check the local workspace .vscode/extensions.json first (recommendations)
+  const extensionsJsonPath = path.join(root, '.vscode', 'extensions.json')
+  let recommendedExts: string[] = []
+  if (await exists(extensionsJsonPath)) {
+    try {
+      const extData = await readJSON<{ recommendations?: string[] }>(extensionsJsonPath)
+      if (extData && Array.isArray(extData.recommendations)) {
+        recommendedExts = extData.recommendations.map(e => e.toLowerCase())
+      }
+    } catch {
+      // ignore JSON parse errors here
+    }
+  }
+
+  // Check user's global VS Code extensions folder once
+  const homeDir = process.env.HOME || process.env.USERPROFILE || ''
+  const globalExtDir = path.join(homeDir, '.vscode', 'extensions')
+  const globalExtExists = await exists(globalExtDir)
+  let installedExtensionFolders: string[] = []
+
+  if (globalExtExists) {
+    try {
+      const { readdir } = await import('node:fs/promises')
+      installedExtensionFolders = await readdir(globalExtDir)
+
+      // Filter out obsolete extensions
+      const obsoletePath = path.join(globalExtDir, '.obsolete')
+      if (await exists(obsoletePath)) {
+        try {
+          const obsoleteData = await readJSON<Record<string, boolean>>(obsoletePath)
+          if (obsoleteData) {
+            const obsoleteKeys = Object.keys(obsoleteData)
+            installedExtensionFolders = installedExtensionFolders.filter(folder => {
+              // The folder name usually contains the version, e.g., 'github.copilot-1.2.3'
+              // but the obsolete key might just be the exact folder name
+              return !obsoleteKeys.includes(folder)
+            })
+          }
+        } catch {
+          // Ignore parse errors for .obsolete
+        }
+      }
+    } catch {
+      // Fallback or ignore
+    }
+  }
+
+  // Check all IDE plugins
+  for (const plugin of KNOWN_IDE_PLUGINS) {
+    let isInstalled = false
+
+    // Check if it's explicitly recommended in the workspace
+    if (recommendedExts.includes(plugin.extId.toLowerCase())) {
+      isInstalled = true
+    }
+    // Otherwise check our pre-fetched global extensions list
+    else if (
+      installedExtensionFolders.some(f => {
+        const lower = f.toLowerCase()
+        return (
+          lower === plugin.extId.toLowerCase() || lower.startsWith(plugin.extId.toLowerCase() + '-')
+        )
+      })
+    ) {
+      // NOTE: We used to just check if the folder exists, but when a VS Code extension
+      // is uninstalled, the folder is not immediately removed. Instead, VS Code creates
+      // an `.obsolete` file in the `.vscode/extensions` directory containing the keys of
+      // uninstalled extensions, or it renames the extension folder.
+      isInstalled = true
+    }
+
+    if (isInstalled) {
+      // If we already detected the CLI version of this tool, we append 'extension' to the modes
+      // and set the preferredMode to 'extension' since extension integration is generally more seamless.
+      const existing = detectedMap.get(plugin.id)
+      if (existing) {
+        existing.providerModes.push('extension')
+        existing.preferredMode = 'extension'
+      } else {
+        detectedMap.set(plugin.id, {
+          id: plugin.id,
+          label: plugin.label,
+          supported: plugin.supported,
+          providerModes: ['extension'],
+          preferredMode: 'extension',
+        })
+      }
+    }
+  }
+
+  return { detected: Array.from(detectedMap.values()) }
+}

package/src/inject/ast-injector.ts

@@ -1,181 +1,53 @@
 // ============================================================
 // src/inject/ast-injector.ts — Safe plugin injection (v1)
 //
-// v1 scope: Standard `plugins: [...]` array injection.
-// Covers Vite / Webpack / Rspack / esbuild / Rollup configs.
-// Meta-framework special strategies (Next.js, Nuxt) deferred.
+// Implements the Strategy Pattern to delegate AST manipulation
+// and manual instruction generation to specific build tool strategies.
 //
 // Safety protocol:
-//   1. Backup original file (.bak)
+//   1. Parse config file safely
 //   2. Idempotency check (skip if already injected)
-//   3. Attempt regex-based injection
-//   4. Basic syntax validation
-//   5. Graceful degradation on any failure
+//   3. Find matching strategy
+//   4. Delegate injection to strategy
+//   5. Write modified configuration back to file
+//   6. Fallback to manual instructions if automatic modification fails
 // ============================================================
 
 import path from 'node:path'
-import { exists, readFile, writeFile, copyFile } from '../utils/fs.js'
+import { loadFile, writeFile as writeAstFile } from 'magicast'
+import { exists, readFile } from '../utils/fs.js'
 import { log } from '../utils/logger.js'
-import type { BuildTool, BuildToolDetection, Mutation } from '../types.js'
-
-// ---- Import & plugin expression per build tool ----
-
-const IMPORT_MAP: Record<BuildTool, string> = {
-  vite: `import { vitePlugin as inspecto } from '@inspecto-dev/plugin'`,
-  webpack: `import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'`,
-  rspack: `import { rspackPlugin as inspecto } from '@inspecto-dev/plugin'`,
-  rsbuild: `import { rspackPlugin as inspecto } from '@inspecto-dev/plugin'`,
-  esbuild: `import { esbuildPlugin as inspecto } from '@inspecto-dev/plugin'`,
-  rollup: `import { rollupPlugin as inspecto } from '@inspecto-dev/plugin'`,
-}
-
-function getImportStatement(tool: BuildTool, isLegacyRspack?: boolean): string {
-  if (tool === 'rspack' && isLegacyRspack) {
-    return `import { rspackPlugin as inspecto } from '@inspecto-dev/plugin/legacy/rspack'`
-  }
-  return IMPORT_MAP[tool]
-}
-
-function getPluginExpression(isLegacyRspack?: boolean): string {
-  if (isLegacyRspack) {
-    return `process.env.NODE_ENV !== 'production' && inspecto({
-      pathType: 'absolute',
-      escapeTags: ['Transition', 'AnimatePresence'],
-    }) as any`
-  }
-  return `process.env.NODE_ENV !== 'production' && inspecto()`
-}
-
-// ---- Manual fallback instructions ----
+import type { BuildToolDetection, Mutation } from '../types.js'
+import { STRATEGIES } from './strategies/index.js'
+import type { InjectStrategy } from './strategies/types.js'
 
 function printManualInstructions(
-  tool: BuildTool,
-  configPath: string,
+  strategy: InjectStrategy | undefined,
+  detection: BuildToolDetection,
   reason: string,
-  isLegacyRspack?: boolean,
 ) {
-  const isRsbuild = tool === 'rsbuild'
-
-  log.warn(`Could not safely auto-inject into ${configPath}`)
+  log.warn(`Could not automatically configure ${detection.configPath}`)
   log.hint(`(reason: ${reason})`)
   log.blank()
   log.hint('Please add the following manually:')
 
-  if (isRsbuild) {
-    log.codeBlock([
-      getImportStatement(tool, isLegacyRspack),
-      '',
-      '// Add to tools.rspack:',
-      `tools: {`,
-      `  rspack: {`,
-      `    plugins: [`,
-      `      ${getPluginExpression(isLegacyRspack)},`,
-      `    ]`,
-      `  }`,
-      `}`,
-    ])
+  if (strategy) {
+    const instructions = strategy.getManualInstructions(detection, reason)
+    log.codeBlock(instructions)
   } else {
-    log.codeBlock([
-      getImportStatement(tool, isLegacyRspack),
-      '',
-      '// Add to your plugins array:',
-      `plugins: [`,
-      `  ${getPluginExpression(isLegacyRspack)},`,
-      `  ...otherPlugins`,
-      `].filter(Boolean)`,
-    ])
+    log.error(`Unsupported build tool: ${detection.tool}`)
   }
 }
 
-// ---- Injection helpers ----
-
 /** Check if inspecto is already injected (idempotency). */
 function isAlreadyInjected(content: string): boolean {
+  // Use regex to avoid false positives in comments or variables
   return (
-    content.includes('@inspecto-dev/plugin') ||
-    content.includes('inspecto()') ||
-    content.includes('aiDevInspector')
-  ) // Legacy support
-}
-
-/** Inject import statement after the last existing import. */
-function injectImport(content: string, importStmt: string): string {
-  const importRegex = /^import\s.+$/gm
-  let lastImportEnd = 0
-  let match: RegExpExecArray | null
-
-  while ((match = importRegex.exec(content)) !== null) {
-    const lineEnd = content.indexOf('\n', match.index)
-    if (lineEnd > lastImportEnd) {
-      lastImportEnd = lineEnd
-    }
-  }
-
-  // Also handle CJS require patterns
-  if (lastImportEnd === 0) {
-    const requireRegex = /^(?:const|let|var)\s.+=\s*require\(.+\).*$/gm
-    while ((match = requireRegex.exec(content)) !== null) {
-      const lineEnd = content.indexOf('\n', match.index)
-      if (lineEnd > lastImportEnd) {
-        lastImportEnd = lineEnd
-      }
-    }
-  }
-
-  if (lastImportEnd > 0) {
-    return content.slice(0, lastImportEnd) + '\n' + importStmt + content.slice(lastImportEnd)
-  }
-
-  // No imports found, add at the beginning
-  return importStmt + '\n\n' + content
-}
-
-/**
- * Core injection strategy.
- * For most tools: find `plugins: [` and insert after `[`.
- * For rsbuild: find `tools: { rspack: { plugins: [` or try to add it.
- */
-function injectIntoPluginsArray(content: string, detection: BuildToolDetection): string | null {
-  const tool = detection.tool
-  if (tool === 'rsbuild') {
-    // rsbuild needs to inject into tools.rspack.plugins or tools.rspack(config, { appendPlugins })
-    // Due to the complexity of rsbuild config, we'll try a simple regex for `tools: { rspack: { plugins: [`
-    // If that fails, we fallback to manual instructions which are explicitly for rsbuild.
-
-    // Check if tools.rspack exists
-    if (!content.includes('tools:') && !content.includes('rspack:')) {
-      // Very basic config, we can try to inject before the closing brace of defineConfig
-      const exportRegex = /(export default defineConfig\(\{)/
-      const match = exportRegex.exec(content)
-      if (match) {
-        const insertPos = match.index + match[0].length
-        const pluginExpr = `\n  tools: {\n    rspack: {\n      plugins: [\n        ${getPluginExpression(detection.isLegacyRspack)}\n      ]\n    }\n  },`
-        return content.slice(0, insertPos) + pluginExpr + content.slice(insertPos)
-      }
-    }
-
-    // Otherwise it's too complex for simple regex, force manual degradation
-    return null
-  }
-
-  const pluginsRegex = /(plugins\s*:\s*\[)/
-  const match = pluginsRegex.exec(content)
-  if (!match) return null
-
-  const insertPos = match.index + match[0].length
-  const pluginExpr = `\n    ${getPluginExpression(detection.isLegacyRspack)},`
-
-  return content.slice(0, insertPos) + pluginExpr + content.slice(insertPos)
-}
-
-/** Basic bracket-balance validation. */
-function validateBrackets(content: string): boolean {
-  const openBraces = (content.match(/\{/g) || []).length
-  const closeBraces = (content.match(/\}/g) || []).length
-  const openBrackets = (content.match(/\[/g) || []).length
-  const closeBrackets = (content.match(/\]/g) || []).length
-
-  return Math.abs(openBraces - closeBraces) <= 1 && Math.abs(openBrackets - closeBrackets) <= 1
+    /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)
+  )
 }
 
 // ---- Main injection orchestrator ----
@@ -192,109 +64,76 @@ export async function injectPlugin(
   dryRun: boolean,
 ): Promise<InjectionResult> {
   const configPath = path.join(root, detection.configPath)
-  const backupPath = configPath + '.bak'
   const mutations: Mutation[] = []
 
-  // Step 1: Read config file
+  const strategy = STRATEGIES.find(s => s.supports(detection.tool))
+
+  // Step 1: Read config file to check existence and idempotency
   const content = await readFile(configPath)
   if (!content) {
-    printManualInstructions(
-      detection.tool,
-      detection.configPath,
-      'config file not readable',
-      detection.isLegacyRspack,
-    )
+    printManualInstructions(strategy, detection, 'config file not readable')
     return { success: false, mutations, failureReason: 'config file not readable' }
   }
 
   // Step 2: Idempotency check
   if (isAlreadyInjected(content)) {
-    log.success(`Plugin already injected in ${detection.configPath} (skipped)`)
-
-    // We still want to record the mutation so teardown knows how to clean it up
-    // However, if the user manually added it, we shouldn't overwrite their code with a .bak on teardown.
-    // To handle this, we register a special 'plugin_injected' mutation instead of 'file_modified',
-    // which tells teardown to use AST-removal instead of .bak restoration (if we implement it)
-    // For now, we will assume if it's already there and a .bak exists, we track it for restoration.
-    if (await exists(backupPath)) {
-      mutations.push({
-        type: 'file_modified',
-        path: detection.configPath,
-        backup: detection.configPath + '.bak',
-        description: 'Previously injected inspecto() plugin',
-      })
-    } else {
-      // If no backup exists, we just mark it as modified but without backup
-      // This tells teardown it was touched but cannot be safely rolled back
-      mutations.push({
-        type: 'file_modified',
-        path: detection.configPath,
-        description: 'Previously injected inspecto() plugin (no backup)',
-      })
-    }
-
-    return { success: true, mutations }
-  }
+    log.success(`Plugin already configured in ${detection.configPath} (skipped)`)
 
-  // Step 3: Backup
-  if (!dryRun) {
-    await copyFile(configPath, backupPath)
     mutations.push({
       type: 'file_modified',
       path: detection.configPath,
-      backup: detection.configPath + '.bak',
-      description: 'Injected inspecto() plugin',
+      description: 'Previously configured inspecto() plugin',
     })
+
+    return { success: true, mutations }
   }
-  log.success(`Backed up ${detection.configPath} → ${detection.configPath}.bak`)
 
-  // Step 4: Inject into plugins array
-  const injected = injectIntoPluginsArray(content, detection)
-  if (!injected) {
+  if (!strategy) {
     printManualInstructions(
-      detection.tool,
-      detection.configPath,
-      'could not locate plugins array — file may use dynamic config, function wrapper, or non-standard export',
-      detection.isLegacyRspack,
+      strategy,
+      detection,
+      `No injection strategy found for ${detection.tool}`,
     )
-    return {
-      success: false,
-      mutations,
-      failureReason: 'could not locate plugins array',
-    }
+    return { success: false, mutations, failureReason: 'No strategy found' }
+  }
+
+  // Step 3: Automatic configuration
+  if (dryRun) {
+    log.dryRun(`Would automatically configure plugin in ${detection.configPath}`)
+    return { success: true, mutations: [] }
   }
 
-  // Step 5: Inject import statement
-  const importStmt = getImportStatement(detection.tool, detection.isLegacyRspack)
-  const modifiedContent = injectImport(injected, importStmt)
+  try {
+    const mod = await loadFile(configPath)
 
-  // Step 6: Bracket-balance validation
-  if (!validateBrackets(modifiedContent)) {
-    log.error('Syntax validation failed after injection')
-    if (!dryRun) {
-      await copyFile(backupPath, configPath)
-      log.success(`Restored ${detection.configPath} from backup`)
-    }
+    // Delegate to strategy
+    strategy.inject({
+      mod,
+      detection,
+    })
+
+    // Step 4: Write modified config back to file
+    await writeAstFile(mod, configPath)
+
+    mutations.push({
+      type: 'file_modified',
+      path: detection.configPath,
+      description: 'Automatically configured inspecto() plugin',
+    })
+
+    log.success(`Configured plugin in ${detection.configPath}`)
+    return { success: true, mutations }
+  } catch (err) {
+    // Graceback degradation
     printManualInstructions(
-      detection.tool,
-      detection.configPath,
-      'injection produced unbalanced brackets',
-      detection.isLegacyRspack,
+      strategy,
+      detection,
+      `Automatic configuration unavailable: ${err instanceof Error ? err.message : String(err)}`,
     )
     return {
       success: false,
-      mutations: [], // Rolled back
-      failureReason: 'injection produced invalid syntax',
+      mutations,
+      failureReason: 'Automatic configuration unavailable',
     }
   }
-
-  // Step 7: Write
-  if (dryRun) {
-    log.dryRun(`Would inject plugin into ${detection.configPath}`)
-  } else {
-    await writeFile(configPath, modifiedContent)
-    log.success(`Injected plugin into ${detection.configPath}`)
-  }
-
-  return { success: true, mutations }
 }