@inspecto-dev/cli 0.2.0-alpha.5 → 0.3.0-alpha.1

package/src/commands/init.ts

@@ -8,27 +8,27 @@
 // ============================================================
 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 { resolveOnboardingTarget } from '../onboarding/target-resolution.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 +40,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 +57,63 @@ 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 monorepoCandidates = buildResult.supported.filter(detection => !!detection.packagePath)
+    if (monorepoCandidates.length > 0) {
+      const frameworkSupportByPackage = await detectFrameworkSupportByPackage(
+        repoRoot,
+        monorepoCandidates,
+      )
+      const targetResolution = resolveOnboardingTarget({
+        repoRoot,
+        buildTools: monorepoCandidates,
+        frameworkSupportByPackage,
+      })
+
+      if (targetResolution.status === 'needs_selection') {
+        log.warn('Monorepo root detected with multiple candidate apps.')
+        const selectedPackage = await promptMonorepoPackageChoice(
+          monorepoCandidates.filter(detection =>
+            targetResolution.candidates.some(
+              candidate => candidate.packagePath === (detection.packagePath ?? ''),
+            ),
+          ),
+        )
+        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 (targetResolution.selected?.packagePath) {
+        const selectedPackage = targetResolution.selected.packagePath
+        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 +121,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 +177,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 +220,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 +234,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 +267,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 +279,57 @@ 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! Inspecto is set up.')
+      log.info('Next:')
+      log.hint('1. Start or restart your dev server.')
+      log.hint('2. Open your app in the browser.')
+      log.hint('3. Hold Alt + Click any element to inspect.')
     }
-    log.blank()
-  } else {
-    log.ready('Ready! Hold Alt + Click any element to inspect.')
   }
 }
 
@@ -421,3 +362,22 @@ function matchesAnyPackage(detection: BuildToolDetection, packages: string[]): b
   if (packages.length === 0) return true
   return packages.some(pkg => matchesPackage(detection, pkg))
 }
+
+async function detectFrameworkSupportByPackage(
+  repoRoot: string,
+  buildTools: BuildToolDetection[],
+): Promise<Record<string, string[]>> {
+  const packagePaths = Array.from(
+    new Set(buildTools.map(buildTool => buildTool.packagePath).filter((value): value is string => !!value)),
+  )
+  const supportByPackage: Record<string, string[]> = {}
+
+  await Promise.all(
+    packagePaths.map(async packagePath => {
+      const result = await detectFrameworks(path.join(repoRoot, packagePath))
+      supportByPackage[packagePath] = result.supported
+    }),
+  )
+
+  return supportByPackage
+}