npm - @inspecto-dev/cli - Versions diffs - 0.2.0-alpha.5 → 0.2.0-alpha.6 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

package/.turbo/turbo-build.log +8 -8
package/CHANGELOG.md +6 -0
package/README.md +58 -11
package/bin/inspecto.js +5 -1
package/dist/bin.d.ts +5 -1
package/dist/bin.js +89 -50
package/dist/{chunk-MIHQGC3L.js → chunk-PDDFPQJS.js} +1949 -1064
package/dist/index.d.ts +128 -2
package/dist/index.js +15 -3
package/package.json +2 -1
package/src/bin.ts +139 -67
package/src/commands/apply.ts +114 -0
package/src/commands/detect.ts +59 -0
package/src/commands/doctor.ts +225 -72
package/src/commands/init.ts +106 -183
package/src/commands/plan.ts +41 -0
package/src/detect/build-tool.ts +107 -3
package/src/index.ts +13 -2
package/src/inject/ast-injector.ts +2 -2
package/src/inject/extension.ts +3 -1
package/src/instructions.ts +60 -46
package/src/onboarding/apply.ts +325 -0
package/src/onboarding/context.ts +36 -0
package/src/onboarding/planner.ts +278 -0
package/src/prompts.ts +54 -11
package/src/types.ts +95 -0
package/src/utils/fs.ts +2 -1
package/src/utils/logger.ts +9 -0
package/src/utils/output.ts +40 -0
package/tests/apply.test.ts +537 -0
package/tests/ast-injector.test.ts +50 -0
package/tests/build-tool.test.ts +3 -5
package/tests/detect.test.ts +94 -0
package/tests/doctor.test.ts +224 -0
package/tests/init.test.ts +333 -0
package/tests/instructions.test.ts +61 -0
package/tests/logger.test.ts +100 -0
package/tests/plan.test.ts +713 -0
package/tests/workspace-build-tool.test.ts +75 -0

package/src/instructions.ts CHANGED Viewed

@@ -2,54 +2,68 @@ import { log } from './utils/logger.js'
 export function printNuxtManualInstructions() {
   log.blank()
-  log.hint('To enable Inspecto in Nuxt, update your nuxt.config.ts:')
-  console.log(`\x1b[36m
-  import { vitePlugin as inspecto } from '@inspecto-dev/plugin'
-  export default defineNuxtConfig({
-    vite: {
-      plugins: [inspecto()]
-    }
-  })
-\x1b[0m`)
-  log.hint('And create a Nuxt plugin at plugins/inspecto.client.ts:')
-  console.log(`\x1b[36m
-  export default defineNuxtPlugin(() => {
-    if (import.meta.dev) {
-      import('@inspecto-dev/core').then(({ mountInspector }) => {
-        mountInspector()
-      })
-    }
-  })
-\x1b[0m`)
+  log.hint('Nuxt requires manual setup in the current version.')
+  log.hint('1. Update `nuxt.config.ts` to register the Inspecto Vite plugin:')
+  log.copyableCodeBlock([
+    "import { vitePlugin as inspecto } from '@inspecto-dev/plugin'",
+    '',
+    'export default defineNuxtConfig({',
+    '  vite: {',
+    '    plugins: [inspecto()],',
+    '  },',
+    '})',
+  ])
+  log.hint('2. Create `plugins/inspecto.client.ts` to mount `@inspecto-dev/core` in development:')
+  log.copyableCodeBlock([
+    'export default defineNuxtPlugin(() => {',
+    '  if (import.meta.dev) {',
+    "    import('@inspecto-dev/core').then(({ mountInspector }) => {",
+    '      mountInspector()',
+    '    })',
+    '  }',
+    '})',
+  ])
+  log.hint('3. Restart your Nuxt dev server after updating the config.')
 }
 export function printNextJsManualInstructions() {
   log.blank()
-  log.hint('To enable Inspecto in Next.js, update your next.config.mjs:')
-  console.log(`\x1b[36m
-  import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'
-  const nextConfig = {
-    webpack: (config, { dev, isServer }) => {
-      if (dev && !isServer) config.plugins.push(inspecto())
-      return config
-    }
-  }
-  export default nextConfig
-\x1b[0m`)
-  log.hint('And initialize the client dynamically in your app/layout.tsx (or pages/_app.tsx):')
-  console.log(`\x1b[36m
-  'use client'
-  import { useEffect } from 'react'
-  export default function RootLayout({ children }) {
-    useEffect(() => {
-      if (process.env.NODE_ENV !== 'production') {
-        import('@inspecto-dev/core').then(({ mountInspector }) => {
-          mountInspector({ serverUrl: 'http://127.0.0.1:5678' })
-        })
-      }
-    }, [])
-    return <html><body>{children}</body></html>
-  }
-\x1b[0m`)
+  log.hint('Next.js requires manual setup in the current version.')
+  log.hint('1. Update `next.config.mjs` to register the Inspecto webpack plugin:')
+  log.copyableCodeBlock([
+    "import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'",
+    '',
+    "/** @type {import('next').NextConfig} */",
+    'const nextConfig = {',
+    '  webpack: (config, { dev, isServer }) => {',
+    '    if (dev && !isServer) {',
+    '      config.plugins.push(inspecto())',
+    '    }',
+    '    return config',
+    '  },',
+    '}',
+    '',
+    'export default nextConfig',
+  ])
+  log.hint(
+    '2. Initialize `@inspecto-dev/core` from a client component such as `app/layout.tsx` or `pages/_app.tsx`:',
+  )
+  log.copyableCodeBlock([
+    "'use client'",
+    '',
+    "import { useEffect } from 'react'",
+    '',
+    'export default function RootLayout({ children }) {',
+    '  useEffect(() => {',
+    "    if (process.env.NODE_ENV !== 'production') {",
+    "      import('@inspecto-dev/core').then(({ mountInspector }) => {",
+    "        mountInspector({ serverUrl: 'http://127.0.0.1:5678' })",
+    '      })',
+    '    }',
+    '  }, [])',
+    '',
+    '  return <html><body>{children}</body></html>',
+    '}',
+  ])
+  log.hint('3. Restart your Next.js dev server after updating the config.')
 }

package/src/onboarding/apply.ts ADDED Viewed

@@ -0,0 +1,325 @@
+import path from 'node:path'
+import ora from 'ora'
+import { getInstallCommand } from '../detect/package-manager.js'
+import { injectPlugin } from '../inject/ast-injector.js'
+import { installExtension } from '../inject/extension.js'
+import { updateGitignore } from '../inject/gitignore.js'
+import { shell } from '../utils/exec.js'
+import { exists, readJSON, writeJSON } from '../utils/fs.js'
+import { log } from '../utils/logger.js'
+import type {
+  BuildToolDetection,
+  CommandStatus,
+  InstallLock,
+  Mutation,
+  PackageManager,
+  PlanResult,
+} from '../types.js'
+export interface ApplyOnboardingInput {
+  repoRoot: string
+  projectRoot: string
+  packageManager: PackageManager
+  supportedBuildTargets: BuildToolDetection[]
+  options: {
+    shared: boolean
+    skipInstall: boolean
+    dryRun: boolean
+    noExtension: boolean
+    quiet?: boolean | undefined
+  }
+  selectedIDE?: { ide: string; supported: boolean } | null | undefined
+  providerDefault?: string | undefined
+  manualConfigRequiredFor?: string | undefined
+  injectionSkippedRequiresManualConfig?: boolean | undefined
+  plan?: PlanResult | undefined
+  allowManualPlanApply?: boolean | undefined
+}
+interface ApplyReporter {
+  warn(text: string): void
+  success(text: string): void
+  error(text: string): void
+  hint(text: string): void
+  dryRun(text: string): void
+}
+interface ApplySpinner {
+  start(): void
+  succeed(text: string): void
+  fail(text: string): void
+}
+export interface ApplyOnboardingResult {
+  status: CommandStatus
+  mutations: Mutation[]
+  postInstall: {
+    installFailed: boolean
+    injectionFailed: boolean
+    manualExtensionInstallNeeded: boolean
+    nextSteps: string[]
+  }
+}
+function resultStatus(nextSteps: string[]): CommandStatus {
+  return nextSteps.length > 0 ? 'warning' : 'ok'
+}
+function manualPlanSteps(plan: PlanResult): string[] {
+  return [
+    ...plan.blockers.map(blocker => blocker.message),
+    ...plan.actions
+      .filter(action => action.type === 'manual_step')
+      .map(action => action.description),
+  ]
+}
+export async function applyOnboardingPlan(
+  input: ApplyOnboardingInput,
+): Promise<ApplyOnboardingResult> {
+  return applyOnboardingPlanInternal(input)
+}
+function createReporter(quiet = false): ApplyReporter {
+  if (quiet) {
+    return {
+      warn() {},
+      success() {},
+      error() {},
+      hint() {},
+      dryRun() {},
+    }
+  }
+  return {
+    warn(text: string) {
+      log.warn(text)
+    },
+    success(text: string) {
+      log.success(text)
+    },
+    error(text: string) {
+      log.error(text)
+    },
+    hint(text: string) {
+      log.hint(text)
+    },
+    dryRun(text: string) {
+      log.dryRun(text)
+    },
+  }
+}
+function createSpinner(text: string, quiet = false): ApplySpinner {
+  if (quiet) {
+    return {
+      start() {},
+      succeed() {},
+      fail() {},
+    }
+  }
+  const spinner = ora(text)
+  return {
+    start() {
+      spinner.start()
+    },
+    succeed(successText: string) {
+      spinner.succeed(successText)
+    },
+    fail(failureText: string) {
+      spinner.fail(failureText)
+    },
+  }
+}
+async function applyOnboardingPlanInternal(
+  input: ApplyOnboardingInput,
+): Promise<ApplyOnboardingResult> {
+  const reporter = createReporter(input.options.quiet)
+  if (input.plan && input.plan.strategy !== 'supported' && !input.allowManualPlanApply) {
+    return {
+      status: input.plan.status,
+      mutations: [],
+      postInstall: {
+        installFailed: false,
+        injectionFailed: false,
+        manualExtensionInstallNeeded: false,
+        nextSteps: manualPlanSteps(input.plan),
+      },
+    }
+  }
+  const mutations: Mutation[] = []
+  const settingsDir = path.join(input.projectRoot, '.inspecto')
+  const settingsFileName = input.options.shared ? 'settings.json' : 'settings.local.json'
+  const promptsFileName = input.options.shared ? 'prompts.json' : 'prompts.local.json'
+  const settingsPath = path.join(settingsDir, settingsFileName)
+  const promptsPath = path.join(settingsDir, promptsFileName)
+  const installCmd = getInstallCommand(
+    input.packageManager,
+    '@inspecto-dev/plugin @inspecto-dev/core',
+  )
+  const nextSteps: string[] = []
+  let installFailed = false
+  if (input.options.skipInstall) {
+    reporter.warn('Skipping dependency installation (--skip-install)')
+  } else if (input.options.dryRun) {
+    reporter.dryRun(`Would run: ${installCmd}`)
+  } else {
+    const spinner = createSpinner(
+      `Installing devDependencies via: ${installCmd}`,
+      input.options.quiet,
+    )
+    try {
+      spinner.start()
+      await shell(installCmd, input.projectRoot)
+      spinner.succeed('Dependencies installed successfully')
+      reporter.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 (error: any) {
+      spinner.fail('Dependency installation failed')
+      installFailed = true
+      reporter.error(`Failed to install dependency: ${error?.message || 'Unknown error'}`)
+      reporter.hint(`Run manually in ${input.projectRoot}: ${installCmd}`)
+      reporter.hint(
+        'Setup will continue without dependencies, but Inspecto may not run until installation succeeds.',
+      )
+    }
+  }
+  let injectionFailed = Boolean(input.injectionSkippedRequiresManualConfig)
+  for (const target of input.supportedBuildTargets) {
+    const result = await injectPlugin(input.repoRoot, target, input.options.dryRun)
+    if (result.success) {
+      mutations.push(...result.mutations)
+    } else {
+      injectionFailed = true
+    }
+  }
+  if (await exists(settingsPath)) {
+    const existingSettings = await readJSON(settingsPath)
+    if (existingSettings === null) {
+      reporter.warn(`.inspecto/${settingsFileName} exists but contains invalid JSON`)
+      reporter.hint('Please fix the syntax errors manually, or delete it and re-run init')
+      nextSteps.push(`Fix .inspecto/${settingsFileName} or delete it and rerun Inspecto setup.`)
+    } else {
+      reporter.success(`.inspecto/${settingsFileName} already exists (skipped)`)
+    }
+  } else {
+    const defaultSettings: Record<string, unknown> = {}
+    if (input.selectedIDE?.supported) {
+      defaultSettings.ide =
+        input.selectedIDE.ide.toLowerCase() === 'vscode'
+          ? 'vscode'
+          : input.selectedIDE.ide.toLowerCase()
+    }
+    if (input.providerDefault) {
+      defaultSettings['provider.default'] = input.providerDefault
+    }
+    if (input.options.dryRun) {
+      reporter.dryRun(`Would create .inspecto/${settingsFileName}`)
+    } else {
+      await writeJSON(settingsPath, defaultSettings)
+      reporter.success(`Created .inspecto/${settingsFileName}`)
+      mutations.push({ type: 'file_created', path: `.inspecto/${settingsFileName}` })
+    }
+  }
+  if (await exists(promptsPath)) {
+    reporter.success(`.inspecto/${promptsFileName} already exists (skipped)`)
+  } else if (input.options.dryRun) {
+    reporter.dryRun(`Would create .inspecto/${promptsFileName}`)
+  } else {
+    await writeJSON(promptsPath, [])
+    reporter.success(`Created .inspecto/${promptsFileName}`)
+    mutations.push({ type: 'file_created', path: `.inspecto/${promptsFileName}` })
+  }
+  if (!input.options.dryRun) {
+    await updateGitignore(input.projectRoot, input.options.shared, input.options.dryRun)
+    mutations.push({
+      type: 'file_modified',
+      path: '.gitignore',
+      description: 'Appended .inspecto/ ignore rules',
+    })
+  } else {
+    reporter.dryRun('Would update .gitignore')
+  }
+  if (!input.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)
+  }
+  const shouldInstallExt =
+    !input.options.noExtension && (!input.selectedIDE || input.selectedIDE.supported)
+  let manualExtensionInstallNeeded = false
+  if (input.options.noExtension) {
+    reporter.warn('Skipping IDE extension (--no-extension)')
+  } else if (shouldInstallExt) {
+    const extMutation = await installExtension(input.options.dryRun, input.selectedIDE?.ide)
+    if (extMutation && !input.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 && !input.options.dryRun) {
+      manualExtensionInstallNeeded = true
+    }
+  }
+  if (!input.options.dryRun) {
+    if (installFailed) {
+      nextSteps.push(`Install dependencies manually in ${input.projectRoot}: ${installCmd}`)
+    }
+    if (injectionFailed) {
+      nextSteps.push(
+        'Plugin injection skipped. Follow manual instructions printed above to update your config.',
+      )
+    }
+    if (manualExtensionInstallNeeded) {
+      nextSteps.push('Install the Inspecto IDE extension manually')
+    }
+    if (input.manualConfigRequiredFor === 'Nuxt') {
+      nextSteps.push(
+        'Nuxt detected—please follow the Nuxt instructions printed above to finish setup.',
+      )
+    } else if (input.manualConfigRequiredFor === 'Next.js') {
+      nextSteps.push(
+        'Next.js detected—please follow the Next.js instructions printed above to finish setup.',
+      )
+    }
+  }
+  return {
+    status: resultStatus(nextSteps),
+    mutations,
+    postInstall: {
+      installFailed,
+      injectionFailed,
+      manualExtensionInstallNeeded,
+      nextSteps,
+    },
+  }
+}

package/src/onboarding/context.ts ADDED Viewed

@@ -0,0 +1,36 @@
+import { detectBuildTools } from '../detect/build-tool.js'
+import { detectFrameworks } from '../detect/framework.js'
+import { detectIDE } from '../detect/ide.js'
+import { detectPackageManager } from '../detect/package-manager.js'
+import { detectProviders } from '../detect/provider.js'
+import type { OnboardingContext } from '../types.js'
+export async function buildOnboardingContext(root: string): Promise<OnboardingContext> {
+  const [packageManager, buildTools, frameworks, ides, providers] = await Promise.all([
+    detectPackageManager(root),
+    detectBuildTools(root),
+    detectFrameworks(root),
+    detectIDE(root),
+    detectProviders(root),
+  ])
+  return {
+    root,
+    packageManager,
+    buildTools: {
+      supported: buildTools.supported,
+      unsupported: buildTools.unsupported,
+    },
+    frameworks: {
+      supported: frameworks.supported,
+      unsupported: frameworks.unsupported.map(item => item.name),
+    },
+    ides: ides.detected.map(({ ide, supported }) => ({ ide, supported })),
+    providers: providers.detected.map(({ id, label, supported, preferredMode }) => ({
+      id,
+      label,
+      supported,
+      preferredMode,
+    })),
+  }
+}