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

package/dist/index.d.ts

@@ -7,9 +7,10 @@ interface InitOptions {
     shared: boolean;
     skipInstall: boolean;
     dryRun: boolean;
-    prefer?: string;
+    provider?: string;
     noExtension: boolean;
     packages?: string[];
+    force: boolean;
 }
 /** A single mutation recorded in install.lock */
 interface Mutation {

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inspecto-dev/cli",
-  "version": "0.2.0-alpha.0",
+  "version": "0.2.0-alpha.2",
   "description": "CLI tools for Inspecto onboarding and lifecycle management",
   "keywords": [
     "inspecto",
@@ -16,9 +16,10 @@
   },
   "dependencies": {
     "cac": "^6.7.14",
+    "magicast": "^0.5.2",
     "picocolors": "^1.0.0",
     "prompts": "^2.4.2",
-    "@inspecto-dev/types": "0.2.0-alpha.0"
+    "@inspecto-dev/types": "0.2.0-alpha.2"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/bin.ts

@@ -3,87 +3,101 @@
 //
 // v1 scope: VS Code | React + Vue | Vite + Webpack + Rspack + esbuild + Rollup
 // ============================================================
-import { parseArgs } from 'node:util'
+import { cac, type CAC } from 'cac'
+import { createRequire } from 'node:module'
 import { init } from './commands/init.js'
 import { doctor } from './commands/doctor.js'
 import { teardown } from './commands/teardown.js'
 import { log } from './utils/logger.js'
 
-const HELP = `
-  ✦ Inspecto CLI (v1)
+const require = createRequire(import.meta.url)
+const { version } = require('../package.json')
 
-  Supported: VS Code | React + Vue | Vite + Webpack + Rspack + esbuild + Rollup
+// cac object
+const cli: CAC = cac('inspecto')
 
-  Usage:
-    inspecto init       Set up Inspecto in your project
-    inspecto doctor     Diagnose your Inspecto installation
-    inspecto teardown   Remove Inspecto from your project
-
-  Init Options:
-    --shared            Share .inspecto/settings.json with your team via Git
-    --skip-install      Skip npm dependency installation
-    --dry-run           Preview changes without modifying files
-    --prefer <tool>     Set default AI tool (e.g. github-copilot, claude-code)
-    --no-extension      Skip VS Code extension installation
-    --packages <names>  (Monorepo) Comma-separated list of packages to inject
+interface GlobalOptions {
+  debug?: boolean
+}
 
-  Examples:
-    npx inspecto init
-    npx inspecto init --shared --prefer github-copilot
-    npx inspecto init --dry-run
-    npx inspecto doctor
-    npx inspecto teardown
-`
+interface InitCommandOptions extends GlobalOptions {
+  shared?: boolean
+  skipInstall?: boolean
+  dryRun?: boolean
+  provider?: string
+  noExtension?: boolean
+  packages?: string
+  force?: boolean
+}
 
-async function main() {
-  const args = process.argv.slice(2)
-  const command = args[0]
+cli
+  .command('init', 'Set up Inspecto in your project')
+  .option('--shared', 'Share .inspecto/settings.json with your team via Git', { default: false })
+  .option('--skip-install', 'Skip npm dependency installation', { default: false })
+  .option('--dry-run', 'Preview changes without modifying files', { default: false })
+  .option('--provider <provider>', 'Set default provider (e.g. copilot, claude-code)')
+  .option('--no-extension', 'Skip VS Code extension installation', { default: false })
+  .option('--packages <names>', '(Monorepo) Comma-separated list of packages to inject')
+  .option('--force', 'Force initialization even if environment is unsupported', { default: false })
+  .option('--debug', 'Enable debug mode to show full error traces', { default: false })
+  .action(async (options: InitCommandOptions) => {
+    try {
+      await init({
+        shared: options.shared ?? false,
+        skipInstall: options.skipInstall ?? false,
+        dryRun: options.dryRun ?? false,
+        ...(options.provider && { provider: options.provider }), // Changed from prefer to provider
+        noExtension: options.noExtension ?? false,
+        ...(options.packages && {
+          packages: options.packages.split(',').map((s: string) => s.trim()),
+        }),
+        force: options.force ?? false,
+      })
+    } catch (err) {
+      log.error(err instanceof Error ? err.message : String(err))
+      if (options.debug && err instanceof Error && err.stack) {
+        console.error(err.stack)
+      }
+      process.exit(1)
+    }
+  })
 
-  if (!command || command === '--help' || command === '-h') {
-    console.log(HELP)
-    process.exit(0)
-  }
+cli
+  .command('doctor', 'Diagnose your Inspecto installation')
+  .option('--debug', 'Enable debug mode to show full error traces', { default: false })
+  .action(async (options: GlobalOptions) => {
+    try {
+      await doctor()
+    } catch (err) {
+      log.error(err instanceof Error ? err.message : String(err))
+      if (options.debug && err instanceof Error && err.stack) {
+        console.error(err.stack)
+      }
+      process.exit(1)
+    }
+  })
 
-  try {
-    switch (command) {
-      case 'init': {
-        const { values } = parseArgs({
-          args: args.slice(1),
-          options: {
-            shared: { type: 'boolean', default: false },
-            'skip-install': { type: 'boolean', default: false },
-            'dry-run': { type: 'boolean', default: false },
-            prefer: { type: 'string' },
-            'no-extension': { type: 'boolean', default: false },
-            packages: { type: 'string' },
-          },
-          strict: true,
-        })
-        await init({
-          shared: values.shared ?? false,
-          skipInstall: values['skip-install'] ?? false,
-          dryRun: values['dry-run'] ?? false,
-          ...(values.prefer && { prefer: values.prefer }),
-          noExtension: values['no-extension'] ?? false,
-          ...(values.packages && { packages: values.packages.split(',').map(s => s.trim()) }),
-        })
-        break
+cli
+  .command('teardown', 'Remove Inspecto from your project')
+  .option('--debug', 'Enable debug mode to show full error traces', { default: false })
+  .action(async (options: GlobalOptions) => {
+    try {
+      await teardown()
+    } catch (err) {
+      log.error(err instanceof Error ? err.message : String(err))
+      if (options.debug && err instanceof Error && err.stack) {
+        console.error(err.stack)
       }
-      case 'doctor':
-        await doctor()
-        break
-      case 'teardown':
-        await teardown()
-        break
-      default:
-        log.error(`Unknown command: ${command}`)
-        console.log(HELP)
-        process.exit(1)
+      process.exit(1)
     }
-  } catch (err) {
-    log.error(err instanceof Error ? err.message : String(err))
-    process.exit(1)
-  }
-}
+  })
 
-main()
+cli.help()
+cli.version(version)
+
+try {
+  cli.parse()
+} catch (err) {
+  log.error(err instanceof Error ? err.message : String(err))
+  process.exit(1)
+}

package/src/commands/doctor.ts

@@ -8,7 +8,7 @@ import { detectPackageManager, getInstallCommand } from '../detect/package-manag
 import { detectBuildTools } from '../detect/build-tool.js'
 import { detectFrameworks } from '../detect/framework.js'
 import { detectIDE } from '../detect/ide.js'
-import { detectAITools } from '../detect/ai-tool.js'
+import { detectProviders } from '../detect/provider.js'
 import { isExtensionInstalled } from '../inject/extension.js'
 
 interface DiagResult {
@@ -29,8 +29,18 @@ export async function doctor(): Promise<void> {
     return
   }
 
+  // Run detections concurrently
+  const [ideProbe, frameworkResult, providerProbe, pm, buildResult, extInstalled] =
+    await Promise.all([
+      detectIDE(root),
+      detectFrameworks(root),
+      detectProviders(root),
+      detectPackageManager(root),
+      detectBuildTools(root),
+      isExtensionInstalled(),
+    ])
+
   // Check 2: IDE
-  const ideProbe = await detectIDE(root)
   if (ideProbe.detected.length === 0) {
     log.warn('IDE: not detected')
     result.warnings++
@@ -46,13 +56,12 @@ export async function doctor(): Promise<void> {
       )
     } else {
       const names = ideProbe.detected.map(d => d.ide).join(', ')
-      log.warn(`IDE: ${names} (not supported in v1, VS Code only)`)
+      log.warn(`IDE: ${names} (not supported in v1, VS Code, Cursor, Trae only)`)
       result.warnings++
     }
   }
 
   // Check 3: Supported framework
-  const frameworkResult = await detectFrameworks(root)
   if (frameworkResult.supported.length > 0) {
     log.success(`Framework: ${frameworkResult.supported.join(', ')}`)
   } else if (frameworkResult.unsupported.length > 0) {
@@ -64,26 +73,25 @@ export async function doctor(): Promise<void> {
     result.warnings++
   }
 
-  // Check 3.5: AI Tools
-  const aiProbe = await detectAITools(root)
-  if (aiProbe.detected.length === 0) {
-    log.warn('AI Tool: none detected')
+  // Check 3.5: Providers
+  if (providerProbe.detected.length === 0) {
+    log.warn('Provider: none detected')
     log.hint('Inspecto works best with Claude Code, Trae CLI, or GitHub Copilot')
     result.warnings++
   } else {
-    const aiNames = aiProbe.detected
+    const aiNames = providerProbe.detected
       .map(d => {
-        const modeLabels = d.toolModes.map(mode =>
-          mode === 'plugin' ? 'VS Code Extension' : 'Terminal CLI',
+        const modeLabels = d.providerModes.map(mode =>
+          mode === 'extension' ? 'VS Code Extension' : 'Terminal CLI',
         )
         return `${d.label} (${modeLabels.join(' & ')})`
       })
       .join(', ')
-    log.success(`AI Tool: ${aiNames}`)
+    log.success(`Provider: ${aiNames}`)
   }
 
   // Check 4: @inspecto-dev/plugin installed
-  const pluginPath = path.join(root, 'node_modules', '@inspecto', 'plugin')
+  const pluginPath = path.join(root, 'node_modules', '@inspecto-dev', 'plugin')
   if (await exists(pluginPath)) {
     const pkgJson = await readJSON<{ version?: string }>(path.join(pluginPath, 'package.json'))
     const version = pkgJson?.version ?? 'unknown'
@@ -96,26 +104,25 @@ export async function doctor(): Promise<void> {
   }
 
   // Check 5: Plugin injected in build config
-  const buildResult = await detectBuildTools(root)
   if (buildResult.supported.length > 0) {
     let injected = false
     for (const bt of buildResult.supported) {
       const content = await readFile(path.join(root, bt.configPath))
       if (content && content.includes('@inspecto-dev/plugin')) {
-        log.success(`Plugin injected in ${bt.configPath}`)
+        log.success(`Plugin configured in ${bt.configPath}`)
         injected = true
         break
       }
     }
     if (!injected) {
-      log.error('Plugin not injected in any build config')
-      log.hint('Fix: npx inspecto init')
+      log.error('Plugin not configured in any build config')
+      log.hint('Fix: npx @inspecto-dev/cli init')
       result.errors++
     }
   } else if (buildResult.unsupported.length > 0) {
     const names = buildResult.unsupported.join(', ')
     log.warn(`Build tool: ${names} (not supported in v1)`)
-    log.hint('v1 supports: Vite, Webpack, Rspack, esbuild, Rollup')
+    log.hint('current version supports: Vite, Webpack, Rspack, esbuild, Rollup')
     result.warnings++
   } else {
     log.warn('No recognized build config found')
@@ -123,7 +130,6 @@ export async function doctor(): Promise<void> {
   }
 
   // Check 6: VS Code extension
-  const extInstalled = await isExtensionInstalled()
   if (extInstalled) {
     log.success('VS Code extension detected')
   } else {
@@ -138,22 +144,29 @@ export async function doctor(): Promise<void> {
     }
   }
 
-  // Check 7: settings.json
-  const settingsPath = path.join(root, '.inspecto', 'settings.json')
-  if (await exists(settingsPath)) {
-    const settings = await readJSON(settingsPath)
+  // Check 7: settings
+  const settingsJsonPath = path.join(root, '.inspecto', 'settings.json')
+  const settingsLocalPath = path.join(root, '.inspecto', 'settings.local.json')
+
+  const hasSettingsJson = await exists(settingsJsonPath)
+  const hasSettingsLocal = await exists(settingsLocalPath)
+
+  if (hasSettingsJson || hasSettingsLocal) {
+    const targetPath = hasSettingsLocal ? settingsLocalPath : settingsJsonPath
+    const fileName = hasSettingsLocal ? 'settings.local.json' : 'settings.json'
+    const settings = await readJSON(targetPath)
     if (settings) {
-      log.success('.inspecto/settings.json valid')
+      log.success(`.inspecto/${fileName} valid`)
     } else {
-      log.error('.inspecto/settings.json has invalid JSON')
+      log.error(`.inspecto/${fileName} has invalid JSON`)
       log.hint(
-        'Fix: Manually correct the syntax errors, or delete the file and re-run npx inspecto init',
+        'Fix: Manually correct the syntax errors, or delete the file and re-run npx @inspecto-dev/cli init',
       )
       result.errors++
     }
   } else {
-    log.warn('.inspecto/settings.json not found (using defaults)')
-    log.hint('Optional: npx inspecto init')
+    log.warn('No .inspecto/settings.json or settings.local.json found (using defaults)')
+    log.hint('Optional: npx @inspecto-dev/cli init')
     result.warnings++
   }