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

package/tests/detect.test.ts

@@ -0,0 +1,94 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { buildOnboardingContext } from '../src/onboarding/context.js'
+import * as buildToolDetector from '../src/detect/build-tool.js'
+import * as frameworkDetector from '../src/detect/framework.js'
+import * as ideDetector from '../src/detect/ide.js'
+import * as packageManagerDetector from '../src/detect/package-manager.js'
+import * as providerDetector from '../src/detect/provider.js'
+
+vi.mock('../src/detect/build-tool.js', () => ({
+  detectBuildTools: vi.fn(),
+}))
+
+vi.mock('../src/detect/framework.js', () => ({
+  detectFrameworks: vi.fn(),
+}))
+
+vi.mock('../src/detect/ide.js', () => ({
+  detectIDE: vi.fn(),
+}))
+
+vi.mock('../src/detect/package-manager.js', () => ({
+  detectPackageManager: vi.fn(),
+}))
+
+vi.mock('../src/detect/provider.js', () => ({
+  detectProviders: vi.fn(),
+}))
+
+describe('buildOnboardingContext', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+  })
+
+  it('normalizes detector output into a shared onboarding context', async () => {
+    vi.mocked(packageManagerDetector.detectPackageManager).mockResolvedValue('pnpm')
+    vi.mocked(buildToolDetector.detectBuildTools).mockResolvedValue({
+      supported: [
+        {
+          tool: 'vite',
+          configPath: 'vite.config.ts',
+          label: 'Vite (vite.config.ts)',
+        },
+      ],
+      unsupported: ['Next.js'],
+    })
+    vi.mocked(frameworkDetector.detectFrameworks).mockResolvedValue({
+      supported: ['react'],
+      unsupported: [{ name: 'Svelte', dep: 'svelte' }],
+    })
+    vi.mocked(ideDetector.detectIDE).mockResolvedValue({
+      detected: [{ ide: 'vscode', supported: true }],
+    })
+    vi.mocked(providerDetector.detectProviders).mockResolvedValue({
+      detected: [
+        {
+          id: 'codex',
+          label: 'Codex CLI',
+          supported: true,
+          providerModes: ['cli'],
+          preferredMode: 'cli',
+        },
+      ],
+    })
+
+    const result = await buildOnboardingContext('/repo')
+
+    expect(result).toEqual({
+      root: '/repo',
+      packageManager: 'pnpm',
+      buildTools: {
+        supported: [
+          {
+            tool: 'vite',
+            configPath: 'vite.config.ts',
+            label: 'Vite (vite.config.ts)',
+          },
+        ],
+        unsupported: ['Next.js'],
+      },
+      frameworks: {
+        supported: ['react'],
+        unsupported: ['Svelte'],
+      },
+      ides: [{ ide: 'vscode', supported: true }],
+      providers: [{ id: 'codex', label: 'Codex CLI', supported: true, preferredMode: 'cli' }],
+    })
+
+    expect(packageManagerDetector.detectPackageManager).toHaveBeenCalledWith('/repo')
+    expect(buildToolDetector.detectBuildTools).toHaveBeenCalledWith('/repo')
+    expect(frameworkDetector.detectFrameworks).toHaveBeenCalledWith('/repo')
+    expect(ideDetector.detectIDE).toHaveBeenCalledWith('/repo')
+    expect(providerDetector.detectProviders).toHaveBeenCalledWith('/repo')
+  })
+})

package/tests/doctor.test.ts

@@ -0,0 +1,224 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('../src/utils/fs.js', () => ({
+  exists: vi.fn(),
+  readJSON: vi.fn(),
+  readFile: vi.fn(),
+}))
+
+vi.mock('../src/detect/package-manager.js', () => ({
+  detectPackageManager: vi.fn(),
+  getInstallCommand: vi.fn(),
+}))
+
+vi.mock('../src/detect/build-tool.js', () => ({
+  detectBuildTools: vi.fn(),
+}))
+
+vi.mock('../src/detect/framework.js', () => ({
+  detectFrameworks: vi.fn(),
+}))
+
+vi.mock('../src/detect/ide.js', () => ({
+  detectIDE: vi.fn(),
+}))
+
+vi.mock('../src/detect/provider.js', () => ({
+  detectProviders: vi.fn(),
+}))
+
+vi.mock('../src/inject/extension.js', () => ({
+  isExtensionInstalled: vi.fn(),
+}))
+
+import { collectDoctorResult, doctor } from '../src/commands/doctor.js'
+import * as buildTool from '../src/detect/build-tool.js'
+import * as framework from '../src/detect/framework.js'
+import * as ide from '../src/detect/ide.js'
+import * as packageManager from '../src/detect/package-manager.js'
+import * as provider from '../src/detect/provider.js'
+import * as extension from '../src/inject/extension.js'
+import * as fsUtils from '../src/utils/fs.js'
+import { log } from '../src/utils/logger.js'
+
+function mockFailingInstall(): void {
+  vi.mocked(fsUtils.exists).mockImplementation(async (filePath: string) => {
+    const existingPaths = new Set([
+      '/repo/package.json',
+      '/repo/vite.config.ts',
+      '/repo/node_modules/@inspecto-dev/plugin',
+      '/repo/.inspecto/settings.json',
+      '/repo/.gitignore',
+    ])
+    return existingPaths.has(filePath)
+  })
+  vi.mocked(fsUtils.readJSON).mockImplementation(async (filePath: string) => {
+    if (filePath === '/repo/node_modules/@inspecto-dev/plugin/package.json') {
+      return { version: '1.2.3' }
+    }
+    if (filePath === '/repo/.inspecto/settings.json') {
+      return null
+    }
+    return null
+  })
+  vi.mocked(fsUtils.readFile).mockImplementation(async (filePath: string) => {
+    if (filePath === '/repo/vite.config.ts') {
+      return 'export default {}'
+    }
+    if (filePath === '/repo/.gitignore') {
+      return 'node_modules/\n'
+    }
+    return null
+  })
+  vi.mocked(packageManager.detectPackageManager).mockResolvedValue('pnpm')
+  vi.mocked(packageManager.getInstallCommand).mockReturnValue('pnpm add -D @inspecto-dev/plugin')
+  vi.mocked(ide.detectIDE).mockResolvedValue({
+    detected: [{ ide: 'vscode', supported: true }],
+  })
+  vi.mocked(framework.detectFrameworks).mockResolvedValue({
+    supported: ['react'],
+    unsupported: [],
+  })
+  vi.mocked(provider.detectProviders).mockResolvedValue({
+    detected: [],
+  })
+  vi.mocked(buildTool.detectBuildTools).mockResolvedValue({
+    supported: [{ tool: 'vite', configPath: 'vite.config.ts', label: 'Vite (vite.config.ts)' }],
+    unsupported: [],
+  })
+  vi.mocked(extension.isExtensionInstalled).mockResolvedValue(false)
+}
+
+describe('doctor command', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+    vi.clearAllMocks()
+    vi.spyOn(process, 'cwd').mockReturnValue('/repo')
+  })
+
+  it('returns an early blocked result when package.json is missing', async () => {
+    vi.mocked(fsUtils.exists).mockResolvedValue(false)
+    const detectIdeSpy = vi.mocked(ide.detectIDE)
+
+    const result = await collectDoctorResult('/repo')
+
+    expect(result).toEqual({
+      status: 'blocked',
+      summary: { errors: 1, warnings: 0 },
+      project: { root: '/repo' },
+      errors: [
+        {
+          code: 'missing-package-json',
+          status: 'error',
+          message: 'No package.json found',
+          hints: ['Run this command from your project root'],
+        },
+      ],
+      warnings: [],
+      checks: [
+        {
+          code: 'missing-package-json',
+          status: 'error',
+          message: 'No package.json found',
+          hints: ['Run this command from your project root'],
+        },
+      ],
+    })
+    expect(detectIdeSpy).not.toHaveBeenCalled()
+  })
+
+  it('returns structured diagnostics in json mode for a failing installation', async () => {
+    mockFailingInstall()
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined)
+    const headerSpy = vi.spyOn(log, 'header')
+
+    const result = await doctor({ json: true })
+
+    expect(result.status).toBe('blocked')
+    expect(result.summary).toEqual({
+      errors: 3,
+      warnings: 2,
+    })
+    expect(result.errors).toEqual([
+      expect.objectContaining({
+        code: 'plugin-not-configured',
+        message: 'Plugin not configured in any build config',
+      }),
+      expect.objectContaining({
+        code: 'extension-missing',
+        message: 'VS Code extension not found',
+        hints: [
+          'Fix: code --install-extension inspecto.inspecto',
+          'Or: https://marketplace.visualstudio.com/items?itemName=inspecto.inspecto',
+        ],
+      }),
+      expect.objectContaining({
+        code: 'settings-invalid-json',
+        message: '.inspecto/settings.json has invalid JSON',
+      }),
+    ])
+    expect(result.warnings).toEqual([
+      expect.objectContaining({
+        code: 'provider-missing',
+        message: 'Provider: none detected',
+      }),
+      expect.objectContaining({
+        code: 'gitignore-missing-install-lock',
+        message: '.inspecto/install.lock not in .gitignore',
+      }),
+    ])
+    expect(result.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ code: 'plugin-installed', status: 'ok' }),
+        expect.objectContaining({ code: 'plugin-not-configured', status: 'error' }),
+        expect.objectContaining({ code: 'provider-missing', status: 'warning' }),
+      ]),
+    )
+    expect(headerSpy).not.toHaveBeenCalled()
+    expect(consoleSpy).toHaveBeenCalledWith(JSON.stringify(result, null, 2))
+  })
+
+  it('does not report a VS Code extension error for supported non-VS Code IDEs', async () => {
+    mockFailingInstall()
+    vi.mocked(ide.detectIDE).mockResolvedValue({
+      detected: [{ ide: 'cursor', supported: true }],
+    })
+
+    const result = await collectDoctorResult('/repo')
+
+    expect(result.errors).toEqual(
+      expect.not.arrayContaining([expect.objectContaining({ code: 'extension-missing' })]),
+    )
+    expect(result.warnings).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'extension-not-applicable',
+          message: 'VS Code extension not applicable (non-VS Code IDE)',
+        }),
+      ]),
+    )
+  })
+
+  it('preserves the human-readable doctor output in text mode', async () => {
+    mockFailingInstall()
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined)
+
+    const result = await doctor()
+    const output = consoleSpy.mock.calls.map(call => call.join(' ')).join('\n')
+
+    expect(result.status).toBe('blocked')
+    expect(output).toContain('Inspecto Doctor')
+    expect(output).toContain('Provider: none detected')
+    expect(output).toContain('Inspecto works best with Claude Code, Trae CLI, or GitHub Copilot')
+    expect(output).toContain('Plugin not configured in any build config')
+    expect(output).toContain('Fix: npx @inspecto-dev/cli init')
+    expect(output).toContain('VS Code extension not found')
+    expect(output).toContain('Fix: code --install-extension inspecto.inspecto')
+    expect(output).toContain('.inspecto/settings.json has invalid JSON')
+    expect(output).toContain('3 error(s), 2 warning(s). Fix the errors above to get started.')
+    expect(output).not.toContain('"status"')
+    expect(output).not.toContain('"summary"')
+  })
+})

package/tests/init.test.ts

@@ -0,0 +1,333 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { init } from '../src/commands/init.js'
+import * as fsUtils from '../src/utils/fs.js'
+import * as execUtils from '../src/utils/exec.js'
+import * as promptUtils from '../src/prompts.js'
+import * as buildToolUtils from '../src/detect/build-tool.js'
+import * as frameworkUtils from '../src/detect/framework.js'
+import * as ideUtils from '../src/detect/ide.js'
+import * as packageManagerUtils from '../src/detect/package-manager.js'
+import * as providerUtils from '../src/detect/provider.js'
+import * as astInjectorUtils from '../src/inject/ast-injector.js'
+import * as instructionUtils from '../src/instructions.js'
+import * as onboardingApply from '../src/onboarding/apply.js'
+
+vi.mock('../src/utils/fs.js', () => ({
+  exists: vi.fn(),
+  readJSON: vi.fn(),
+  writeJSON: vi.fn(),
+}))
+
+vi.mock('../src/utils/exec.js', () => ({
+  shell: vi.fn(),
+}))
+
+vi.mock('../src/detect/package-manager.js', async () => {
+  const actual = await vi.importActual('../src/detect/package-manager.js')
+  return {
+    ...actual,
+    detectPackageManager: vi.fn(),
+  }
+})
+
+vi.mock('../src/detect/build-tool.js', async () => {
+  const actual = await vi.importActual('../src/detect/build-tool.js')
+  return {
+    ...actual,
+    detectBuildTools: vi.fn(),
+    resolveInjectionTarget: vi.fn(),
+  }
+})
+
+vi.mock('../src/detect/framework.js', () => ({
+  detectFrameworks: vi.fn(),
+}))
+
+vi.mock('../src/detect/ide.js', () => ({
+  detectIDE: vi.fn(),
+}))
+
+vi.mock('../src/detect/provider.js', () => ({
+  detectProviders: vi.fn(),
+}))
+
+vi.mock('../src/prompts.js', async () => {
+  const actual = await vi.importActual('../src/prompts.js')
+  return {
+    ...actual,
+    promptMonorepoPackageChoice: vi.fn(),
+  }
+})
+
+vi.mock('../src/inject/ast-injector.js', () => ({
+  injectPlugin: vi.fn().mockResolvedValue({ success: true, mutations: [] }),
+}))
+
+vi.mock('../src/inject/gitignore.js', () => ({
+  updateGitignore: vi.fn(),
+}))
+
+vi.mock('../src/inject/extension.js', () => ({
+  installExtension: vi.fn().mockResolvedValue(null),
+}))
+
+vi.mock('../src/instructions.js', () => ({
+  printNextJsManualInstructions: vi.fn(),
+  printNuxtManualInstructions: vi.fn(),
+}))
+
+vi.mock('../src/onboarding/apply.js', async () => {
+  const actual = await vi.importActual('../src/onboarding/apply.js')
+  return {
+    ...actual,
+    applyOnboardingPlan: vi.fn().mockResolvedValue({
+      status: 'ok',
+      mutations: [],
+      postInstall: {
+        installFailed: false,
+        injectionFailed: false,
+        manualExtensionInstallNeeded: false,
+        nextSteps: [],
+      },
+    }),
+  }
+})
+
+describe('init in monorepo roots', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.spyOn(process, 'cwd').mockReturnValue('/repo')
+    vi.mocked(onboardingApply.applyOnboardingPlan).mockResolvedValue({
+      status: 'ok',
+      mutations: [],
+      postInstall: {
+        installFailed: false,
+        injectionFailed: false,
+        manualExtensionInstallNeeded: false,
+        nextSteps: [],
+      },
+    })
+
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return (
+        filePath === '/repo/package.json' ||
+        filePath === '/repo/apps/web' ||
+        filePath === '/repo/apps/admin'
+      )
+    })
+
+    vi.mocked(fsUtils.readJSON).mockResolvedValue({})
+    vi.mocked(execUtils.shell).mockResolvedValue({ stdout: '', stderr: '' })
+    vi.mocked(packageManagerUtils.detectPackageManager).mockResolvedValue('pnpm')
+    vi.mocked(frameworkUtils.detectFrameworks).mockResolvedValue({
+      supported: ['react'],
+      unsupported: [],
+    })
+    vi.mocked(ideUtils.detectIDE).mockResolvedValue({
+      detected: [{ ide: 'vscode', supported: true }],
+    })
+    vi.mocked(providerUtils.detectProviders).mockResolvedValue({
+      detected: [],
+    })
+    vi.mocked(buildToolUtils.resolveInjectionTarget).mockReturnValue({
+      tool: 'vite',
+      configPath: 'apps/web/vite.config.ts',
+      label: 'Vite (apps/web/vite.config.ts)',
+      packagePath: 'apps/web',
+    })
+    vi.mocked(astInjectorUtils.injectPlugin).mockResolvedValue({
+      success: true,
+      mutations: [],
+    })
+  })
+
+  it('routes installation and config generation into the selected app instead of the monorepo root', async () => {
+    vi.mocked(buildToolUtils.detectBuildTools)
+      .mockResolvedValueOnce({
+        supported: [
+          {
+            tool: 'vite',
+            configPath: 'apps/web/vite.config.ts',
+            label: 'Vite (apps/web/vite.config.ts)',
+            packagePath: 'apps/web',
+          },
+          {
+            tool: 'vite',
+            configPath: 'apps/admin/vite.config.ts',
+            label: 'Vite (apps/admin/vite.config.ts)',
+            packagePath: 'apps/admin',
+          },
+        ],
+        unsupported: [],
+      })
+      .mockResolvedValueOnce({
+        supported: [
+          {
+            tool: 'vite',
+            configPath: 'apps/web/vite.config.ts',
+            label: 'Vite (apps/web/vite.config.ts)',
+            packagePath: 'apps/web',
+          },
+        ],
+        unsupported: [],
+      })
+
+    vi.mocked(promptUtils.promptMonorepoPackageChoice).mockResolvedValue('apps/web')
+
+    await init({
+      shared: false,
+      skipInstall: false,
+      dryRun: false,
+      noExtension: false,
+      force: false,
+    })
+
+    expect(promptUtils.promptMonorepoPackageChoice).toHaveBeenCalledWith([
+      {
+        tool: 'vite',
+        configPath: 'apps/web/vite.config.ts',
+        label: 'Vite (apps/web/vite.config.ts)',
+        packagePath: 'apps/web',
+      },
+      {
+        tool: 'vite',
+        configPath: 'apps/admin/vite.config.ts',
+        label: 'Vite (apps/admin/vite.config.ts)',
+        packagePath: 'apps/admin',
+      },
+    ])
+    expect(buildToolUtils.detectBuildTools).toHaveBeenNthCalledWith(2, '/repo', ['apps/web'])
+    expect(onboardingApply.applyOnboardingPlan).toHaveBeenCalledWith({
+      repoRoot: '/repo',
+      projectRoot: '/repo/apps/web',
+      packageManager: 'pnpm',
+      supportedBuildTargets: [
+        {
+          tool: 'vite',
+          configPath: 'apps/web/vite.config.ts',
+          label: 'Vite (apps/web/vite.config.ts)',
+          packagePath: 'apps/web',
+        },
+      ],
+      options: {
+        shared: false,
+        skipInstall: false,
+        dryRun: false,
+        noExtension: false,
+      },
+      selectedIDE: {
+        ide: 'vscode',
+        supported: true,
+      },
+      providerDefault: undefined,
+      manualConfigRequiredFor: '',
+      injectionSkippedRequiresManualConfig: false,
+      allowManualPlanApply: true,
+    })
+  })
+
+  it('prints detailed Next.js manual instructions when Next.js is detected', async () => {
+    vi.mocked(buildToolUtils.detectBuildTools).mockResolvedValue({
+      supported: [],
+      unsupported: ['Next.js'],
+    })
+
+    await init({
+      shared: false,
+      skipInstall: true,
+      dryRun: true,
+      noExtension: true,
+      force: false,
+    })
+
+    expect(instructionUtils.printNextJsManualInstructions).toHaveBeenCalled()
+    expect(instructionUtils.printNuxtManualInstructions).not.toHaveBeenCalled()
+  })
+
+  it('preserves detected preferred mode for an explicit provider override', async () => {
+    vi.mocked(buildToolUtils.detectBuildTools).mockResolvedValue({
+      supported: [
+        {
+          tool: 'vite',
+          configPath: 'vite.config.ts',
+          label: 'Vite (vite.config.ts)',
+        },
+      ],
+      unsupported: [],
+    })
+    vi.mocked(providerUtils.detectProviders).mockResolvedValue({
+      detected: [
+        {
+          id: 'codex',
+          label: 'Codex CLI',
+          supported: true,
+          providerModes: ['cli'],
+          preferredMode: 'cli',
+        },
+      ],
+    })
+
+    await init({
+      shared: false,
+      skipInstall: false,
+      dryRun: false,
+      provider: 'codex',
+      noExtension: false,
+      force: false,
+    })
+
+    expect(onboardingApply.applyOnboardingPlan).toHaveBeenCalledWith(
+      expect.objectContaining({
+        providerDefault: 'codex.cli',
+      }),
+    )
+  })
+
+  it('prints delegated manual steps when the shared apply flow returns a warning', async () => {
+    vi.mocked(buildToolUtils.detectBuildTools).mockResolvedValue({
+      supported: [
+        {
+          tool: 'vite',
+          configPath: 'vite.config.ts',
+          label: 'Vite (vite.config.ts)',
+        },
+      ],
+      unsupported: [],
+    })
+    vi.mocked(onboardingApply.applyOnboardingPlan).mockResolvedValue({
+      status: 'warning',
+      mutations: [],
+      postInstall: {
+        installFailed: false,
+        injectionFailed: false,
+        manualExtensionInstallNeeded: false,
+        nextSteps: [
+          'Install dependencies manually in /repo: pnpm add -D @inspecto-dev/plugin @inspecto-dev/core',
+        ],
+      },
+    })
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    await init({
+      shared: false,
+      skipInstall: false,
+      dryRun: false,
+      noExtension: false,
+      force: false,
+    })
+
+    const output = consoleSpy.mock.calls.flatMap(call => call.map(value => String(value)))
+    expect(output.some(line => line.includes('Manual Steps Required'))).toBe(true)
+    expect(
+      output.some(line =>
+        line.includes(
+          'Install dependencies manually in /repo: pnpm add -D @inspecto-dev/plugin @inspecto-dev/core',
+        ),
+      ),
+    ).toBe(true)
+    expect(
+      output.some(line => line.includes('Ready! Hold Alt + Click any element to inspect.')),
+    ).toBe(false)
+  })
+})