@inspecto-dev/cli 0.3.3 → 0.3.5

package/tests/integration-install.test.ts

@@ -1,6 +1,8 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const writeFileMock = vi.fn()
+const writeJSONMock = vi.fn()
+const readJSONMock = vi.fn()
 const existsMock = vi.fn()
 const chmodMock = vi.fn()
 const logMock = {
@@ -14,9 +16,13 @@ const logMock = {
   blank: vi.fn(),
 }
 const runIntegrationAutomationMock = vi.fn()
+const resolveIntegrationHostIdeMock = vi.fn()
+const resolveIntegrationDispatchModeMock = vi.fn()
 
 vi.mock('../src/utils/fs.js', () => ({
   writeFile: writeFileMock,
+  writeJSON: writeJSONMock,
+  readJSON: readJSONMock,
   exists: existsMock,
 }))
 
@@ -38,11 +44,21 @@ vi.mock('../src/commands/integration-automation.js', () => ({
   runIntegrationAutomation: runIntegrationAutomationMock,
 }))
 
+vi.mock('../src/commands/integration-host-ide.js', () => ({
+  resolveIntegrationHostIde: resolveIntegrationHostIdeMock,
+}))
+
+vi.mock('../src/commands/integration-dispatch-mode.js', () => ({
+  resolveIntegrationDispatchMode: resolveIntegrationDispatchModeMock,
+}))
+
 describe('integration install', () => {
   beforeEach(() => {
     vi.resetModules()
     vi.clearAllMocks()
+    vi.spyOn(process, 'cwd').mockReturnValue('/repo')
     existsMock.mockResolvedValue(false)
+    readJSONMock.mockResolvedValue(null)
     vi.stubGlobal(
       'fetch',
       vi.fn().mockResolvedValue({
@@ -56,6 +72,17 @@ describe('integration install', () => {
       status: 'launched',
       message: 'Onboarding launched in Cursor for Codex.',
     })
+    resolveIntegrationHostIdeMock.mockResolvedValue({
+      ide: 'cursor',
+      source: 'explicit',
+      confidence: 'high',
+      candidates: ['cursor'],
+    })
+    resolveIntegrationDispatchModeMock.mockResolvedValue({
+      mode: 'extension',
+      ready: true,
+      reason: 'cursor_codex_extension',
+    })
   })
 
   it('installs the Claude Code skill into the user skill directory', async () => {
@@ -145,6 +172,92 @@ describe('integration install', () => {
     )
   })
 
+  it('installs the Trae skill with a launcher script', async () => {
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('trae')
+
+    expect(writeFileMock).toHaveBeenCalledWith(
+      '.trae/skills/inspecto-onboarding/SKILL.md',
+      '# mock asset',
+    )
+    expect(writeFileMock).toHaveBeenCalledWith(
+      '.trae/skills/inspecto-onboarding/scripts/run-inspecto.sh',
+      '# mock asset',
+    )
+    expect(chmodMock).toHaveBeenCalledWith(
+      '.trae/skills/inspecto-onboarding/scripts/run-inspecto.sh',
+      0o755,
+    )
+  })
+
+  it('persists an explicit project host ide into .inspecto/settings.local.json before onboarding launch', async () => {
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('gemini', { ide: 'trae-cn' })
+
+    expect(writeJSONMock).toHaveBeenCalledWith('/repo/.inspecto/settings.local.json', {
+      ide: 'trae-cn',
+      'provider.default': 'gemini.extension',
+    })
+  })
+
+  it('updates the project host ide and provider.default to the selected assistant without dropping other keys', async () => {
+    readJSONMock.mockResolvedValue({
+      ide: 'trae',
+      'provider.default': 'coco.cli',
+      'prompt.autoSend': true,
+    })
+
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('gemini', { ide: 'trae-cn' })
+
+    expect(writeJSONMock).toHaveBeenCalledWith('/repo/.inspecto/settings.local.json', {
+      ide: 'trae-cn',
+      'provider.default': 'gemini.extension',
+      'prompt.autoSend': true,
+    })
+  })
+
+  it('persists the selected assistant as provider.default so onboarding does not fall back to another detected tool', async () => {
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('codex', { ide: 'cursor' })
+
+    expect(writeJSONMock).toHaveBeenCalledWith('/repo/.inspecto/settings.local.json', {
+      ide: 'cursor',
+      'provider.default': 'codex.extension',
+    })
+  })
+
+  it('does not persist host ide settings for user-level installs', async () => {
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('codex', { scope: 'user', ide: 'cursor' })
+
+    expect(writeJSONMock).not.toHaveBeenCalled()
+  })
+
+  it('installs the Coco skill with a launcher script', async () => {
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('coco')
+
+    expect(writeFileMock).toHaveBeenCalledWith(
+      '.trae/skills/inspecto-onboarding/SKILL.md',
+      '# mock asset',
+    )
+    expect(writeFileMock).toHaveBeenCalledWith(
+      '.trae/skills/inspecto-onboarding/scripts/run-inspecto.sh',
+      '# mock asset',
+    )
+    expect(chmodMock).toHaveBeenCalledWith(
+      '.trae/skills/inspecto-onboarding/scripts/run-inspecto.sh',
+      0o755,
+    )
+  })
+
   it('surfaces a blocked automation outcome as a warning with next-step guidance', async () => {
     runIntegrationAutomationMock.mockResolvedValue({
       status: 'blocked',
@@ -166,6 +279,40 @@ describe('integration install', () => {
     )
   })
 
+  it('blocks automatic onboarding when no explicit host ide, config, or env signal is available', async () => {
+    runIntegrationAutomationMock.mockResolvedValue({
+      status: 'blocked',
+      message:
+        'Automatic setup stopped: Inspecto could not determine which IDE should receive onboarding.',
+      nextStep:
+        'Re-run with --host-ide <vscode|cursor|trae|trae-cn> or run the command from the target IDE terminal to continue automatic setup.',
+    })
+    resolveIntegrationHostIdeMock.mockResolvedValue({
+      ide: null,
+      source: 'none',
+      confidence: 'low',
+      candidates: [],
+    })
+
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('coco')
+
+    expect(runIntegrationAutomationMock).toHaveBeenCalledWith(
+      'coco',
+      expect.objectContaining({
+        ignoreProjectArtifacts: true,
+      }),
+      '/repo',
+    )
+    expect(logMock.warn).toHaveBeenCalledWith(
+      'Automatic setup stopped: Inspecto could not determine which IDE should receive onboarding.',
+    )
+    expect(logMock.hint).toHaveBeenCalledWith(
+      'Re-run with --host-ide <vscode|cursor|trae|trae-cn> or run the command from the target IDE terminal to continue automatic setup.',
+    )
+  })
+
   it('surfaces a partial automation outcome as a warning with follow-up guidance', async () => {
     runIntegrationAutomationMock.mockResolvedValue({
       status: 'partial',
@@ -207,6 +354,7 @@ describe('integration install', () => {
     await installIntegration('codex', { preview: true, ide: 'cursor' })
 
     expect(writeFileMock).not.toHaveBeenCalled()
+    expect(writeJSONMock).not.toHaveBeenCalled()
     expect(chmodMock).not.toHaveBeenCalled()
     expect(fetchMock).not.toHaveBeenCalled()
     expect(logMock.info).toHaveBeenCalledWith('Step 1/6: Previewing Codex integration assets')
@@ -398,6 +546,20 @@ describe('integration install', () => {
     })
   })
 
+  it('describes coco using the trae skill install target', async () => {
+    const { describeIntegration } = await import('../src/commands/integration-install.js')
+
+    expect(describeIntegration('coco')).toMatchObject({
+      assistant: 'coco',
+      targets: [
+        '.trae/skills/inspecto-onboarding/SKILL.md',
+        '.trae/skills/inspecto-onboarding/scripts/run-inspecto.sh',
+      ],
+      preferredInstall:
+        'npx @inspecto-dev/cli integrations install coco --host-ide <vscode|cursor|trae|trae-cn>',
+    })
+  })
+
   it('prints integration paths without using post-install hints', async () => {
     const { printIntegrationPath } = await import('../src/commands/integration-install.js')
 
@@ -534,6 +696,37 @@ describe('integration install', () => {
     })
   })
 
+  it('wires the dev command group to link, status, and unlink handlers', async () => {
+    const linkCommand = vi.fn().mockResolvedValue(undefined)
+    const statusCommand = vi.fn().mockResolvedValue(undefined)
+    const unlinkCommand = vi.fn().mockResolvedValue(undefined)
+
+    vi.doMock('../src/commands/init.js', () => ({ init: vi.fn() }))
+    vi.doMock('../src/commands/doctor.js', () => ({ doctor: vi.fn() }))
+    vi.doMock('../src/commands/teardown.js', () => ({ teardown: vi.fn() }))
+    vi.doMock('../src/commands/detect.js', () => ({ detect: vi.fn() }))
+    vi.doMock('../src/commands/plan.js', () => ({ plan: vi.fn() }))
+    vi.doMock('../src/commands/apply.js', () => ({ apply: vi.fn() }))
+    vi.doMock('../src/commands/dev-config.js', () => ({
+      devLink: linkCommand,
+      devStatus: statusCommand,
+      devUnlink: unlinkCommand,
+    }))
+
+    const { runCli } = await import('../src/bin.js')
+
+    await runCli(['node', 'inspecto', 'dev', 'link', '--cli-bin', '/tmp/inspecto/bin.js'])
+    await runCli(['node', 'inspecto', 'dev', 'status', '--json'])
+    await runCli(['node', 'inspecto', 'dev', 'unlink'])
+
+    expect(linkCommand).toHaveBeenCalledWith({
+      cliBin: '/tmp/inspecto/bin.js',
+      json: false,
+    })
+    expect(statusCommand).toHaveBeenCalledWith(true)
+    expect(unlinkCommand).toHaveBeenCalledWith(false)
+  })
+
   it('sets a non-zero exit code when integrations doctor reports a blocked result', async () => {
     const doctorCommand = vi.fn().mockResolvedValue({ status: 'blocked' })
 

package/tests/nextjs-guidance.test.ts

@@ -0,0 +1,128 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import { createNextJsGuidance } from '../src/onboarding/nextjs-guidance.js'
+
+const tempDirs: string[] = []
+
+async function createTempProject(files: Record<string, string>) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'inspecto-nextjs-'))
+  tempDirs.push(root)
+
+  for (const [relativePath, contents] of Object.entries(files)) {
+    const filePath = path.join(root, relativePath)
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+    await fs.writeFile(filePath, contents)
+  }
+
+  return root
+}
+
+describe('createNextJsGuidance', () => {
+  afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map(dir => fs.rm(dir, { recursive: true, force: true })))
+  })
+
+  it('creates a high-confidence patch plan for object-export next.config.mjs', async () => {
+    const root = await createTempProject({
+      'next.config.mjs': `export default {\n  reactStrictMode: true,\n}\n`,
+      'app/layout.tsx': `export default function RootLayout({ children }) { return <html><body>{children}</body></html> }\n`,
+    })
+
+    const guidance = createNextJsGuidance(root)
+
+    expect(guidance.metaFramework).toBe('Next.js')
+    expect(guidance.routerMode).toBe('app')
+    expect(guidance.patches).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          path: 'next.config.mjs',
+          confidence: 'high',
+          reason: 'next_config_object_export',
+        }),
+        expect.objectContaining({
+          path: 'app/layout.tsx',
+          status: 'manual_patch_required',
+          reason: 'next_app_router_mount',
+        }),
+      ]),
+    )
+    expect(guidance.assistantPrompt).toContain('Next.js')
+    expect(guidance.patches[0]?.snippet).toContain('if (dev) {')
+    expect(guidance.patches[0]?.snippet).not.toContain('!isServer')
+  })
+
+  it('treats exported nextConfig objects as high-confidence patches', async () => {
+    const root = await createTempProject({
+      'next.config.ts': `import type { NextConfig } from 'next'\nconst nextConfig: NextConfig = {\n  reactStrictMode: true,\n}\n\nexport default nextConfig\n`,
+      'src/app/layout.tsx': `export default function RootLayout({ children }) { return <html><body>{children}</body></html> }\n`,
+      'package.json': `{\n  "scripts": {\n    "dev": "next dev"\n  }\n}\n`,
+    })
+
+    const guidance = createNextJsGuidance(root)
+
+    expect(guidance.patches).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          path: 'next.config.ts',
+          status: 'planned',
+          confidence: 'high',
+          reason: 'next_config_object_export',
+        }),
+      ]),
+    )
+  })
+
+  it('degrades to a medium-confidence manual patch plan for wrapped next config', async () => {
+    const root = await createTempProject({
+      'next.config.js': `const withBundleAnalyzer = require('@next/bundle-analyzer')({ enabled: true })\nmodule.exports = withBundleAnalyzer({ reactStrictMode: true })\n`,
+      'pages/_app.tsx': `export default function App({ Component, pageProps }) { return <Component {...pageProps} /> }\n`,
+    })
+
+    const guidance = createNextJsGuidance(root)
+
+    expect(guidance.routerMode).toBe('pages')
+    expect(guidance.patches[0]).toMatchObject({
+      path: 'next.config.js',
+      confidence: 'medium',
+      status: 'manual_patch_required',
+      reason: 'next_config_wrapped_export',
+    })
+    expect(guidance.patches).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          path: 'pages/_app.tsx',
+          status: 'manual_patch_required',
+          reason: 'next_pages_router_mount',
+        }),
+      ]),
+    )
+  })
+
+  it('adds a webpack dev-server follow-up when package.json still runs next dev without --webpack', async () => {
+    const root = await createTempProject({
+      'next.config.ts': `import type { NextConfig } from 'next'\nconst nextConfig: NextConfig = {\n  reactStrictMode: true,\n}\n\nexport default nextConfig\n`,
+      'app/layout.tsx': `export default function RootLayout({ children }) { return <html><body>{children}</body></html> }\n`,
+      'package.json': `{\n  "scripts": {\n    "dev": "next dev"\n  }\n}\n`,
+    })
+
+    const guidance = createNextJsGuidance(root)
+
+    expect(guidance.pendingSteps).toEqual(
+      expect.arrayContaining([
+        'Update the Next.js dev script to use webpack mode for Inspecto validation.',
+      ]),
+    )
+    expect(guidance.patches).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          path: 'package.json',
+          status: 'manual_patch_required',
+          reason: 'next_dev_script_requires_webpack',
+        }),
+      ]),
+    )
+    expect(guidance.assistantPrompt).toContain('Use the generated patches directly')
+  })
+})

package/tests/nuxt-guidance.test.ts

@@ -0,0 +1,67 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import { createNuxtGuidance } from '../src/onboarding/nuxt-guidance.js'
+
+const tempDirs: string[] = []
+
+async function createTempProject(files: Record<string, string>) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'inspecto-nuxt-'))
+  tempDirs.push(root)
+
+  for (const [relativePath, contents] of Object.entries(files)) {
+    const filePath = path.join(root, relativePath)
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+    await fs.writeFile(filePath, contents)
+  }
+
+  return root
+}
+
+describe('createNuxtGuidance', () => {
+  afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map(dir => fs.rm(dir, { recursive: true, force: true })))
+  })
+
+  it('creates a high-confidence patch plan for object-export nuxt.config.ts', async () => {
+    const root = await createTempProject({
+      'nuxt.config.ts': `export default defineNuxtConfig({\n  devtools: { enabled: true },\n})\n`,
+    })
+
+    const guidance = createNuxtGuidance(root)
+
+    expect(guidance.metaFramework).toBe('Nuxt')
+    expect(guidance.framework).toBe('vue')
+    expect(guidance.patches).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          path: 'nuxt.config.ts',
+          confidence: 'high',
+          reason: 'nuxt_config_object_export',
+          status: 'planned',
+        }),
+        expect.objectContaining({
+          path: 'plugins/inspecto.client.ts',
+          reason: 'nuxt_client_plugin_mount',
+          status: 'manual_patch_required',
+        }),
+      ]),
+    )
+  })
+
+  it('degrades to a medium-confidence manual patch plan for wrapped nuxt config', async () => {
+    const root = await createTempProject({
+      'nuxt.config.js': `export default withFoo(defineNuxtConfig({ ssr: true }))\n`,
+    })
+
+    const guidance = createNuxtGuidance(root)
+
+    expect(guidance.patches[0]).toMatchObject({
+      path: 'nuxt.config.js',
+      confidence: 'medium',
+      status: 'manual_patch_required',
+      reason: 'nuxt_config_wrapped_export',
+    })
+  })
+})