@inspecto-dev/cli 0.3.0 → 0.3.2

package/tests/integration-dispatch-mode.test.ts

@@ -0,0 +1,203 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const existsMock = vi.fn()
+const readJSONMock = vi.fn()
+const whichMock = vi.fn()
+
+vi.mock('../src/utils/fs.js', () => ({
+  exists: existsMock,
+  readJSON: readJSONMock,
+}))
+
+vi.mock('../src/utils/exec.js', () => ({
+  which: whichMock,
+}))
+
+describe('resolveIntegrationDispatchMode', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    existsMock.mockResolvedValue(false)
+    readJSONMock.mockResolvedValue(null)
+    whichMock.mockResolvedValue(false)
+  })
+
+  it('prefers the Cursor Codex extension when it is installed', async () => {
+    existsMock.mockImplementation(async filePath => {
+      return (
+        filePath === '/Users/tester/.cursor/extensions' ||
+        filePath === '/Users/tester/.cursor/extensions/.obsolete'
+      )
+    })
+    readJSONMock.mockResolvedValue({})
+
+    vi.doMock('node:fs/promises', () => ({
+      readdir: vi.fn().mockResolvedValue(['openai.chatgpt-1.2.3']),
+    }))
+
+    const { resolveIntegrationDispatchMode } =
+      await import('../src/commands/integration-dispatch-mode.js')
+
+    await expect(
+      resolveIntegrationDispatchMode({
+        assistant: 'codex',
+        hostIde: 'cursor',
+        homeDir: '/Users/tester',
+      }),
+    ).resolves.toMatchObject({
+      mode: 'extension',
+      ready: true,
+      reason: 'cursor_codex_extension',
+    })
+  })
+
+  it('falls back to codex CLI when the Cursor extension is not installed but the CLI is available', async () => {
+    whichMock.mockImplementation(async bin => bin === 'codex')
+
+    const { resolveIntegrationDispatchMode } =
+      await import('../src/commands/integration-dispatch-mode.js')
+
+    await expect(
+      resolveIntegrationDispatchMode({
+        assistant: 'codex',
+        hostIde: 'cursor',
+        homeDir: '/Users/tester',
+      }),
+    ).resolves.toMatchObject({
+      mode: 'cli',
+      ready: true,
+      reason: 'codex_cli',
+    })
+  })
+
+  it('returns guidance when neither the Cursor Codex extension nor the codex CLI is available', async () => {
+    const { resolveIntegrationDispatchMode } =
+      await import('../src/commands/integration-dispatch-mode.js')
+
+    await expect(
+      resolveIntegrationDispatchMode({
+        assistant: 'codex',
+        hostIde: 'cursor',
+        homeDir: '/Users/tester',
+      }),
+    ).resolves.toMatchObject({
+      mode: null,
+      ready: false,
+      reason: 'missing_codex_runtime',
+    })
+  })
+
+  it('prefers the Claude Code extension in Cursor when available', async () => {
+    existsMock.mockImplementation(async filePath => {
+      return (
+        filePath === '/Users/tester/.cursor/extensions' ||
+        filePath === '/Users/tester/.cursor/extensions/.obsolete'
+      )
+    })
+    readJSONMock.mockResolvedValue({})
+
+    vi.doMock('node:fs/promises', () => ({
+      readdir: vi.fn().mockResolvedValue(['anthropic.claude-code-0.9.0']),
+    }))
+
+    const { resolveIntegrationDispatchMode } =
+      await import('../src/commands/integration-dispatch-mode.js')
+
+    await expect(
+      resolveIntegrationDispatchMode({
+        assistant: 'claude-code',
+        hostIde: 'cursor',
+        homeDir: '/Users/tester',
+      }),
+    ).resolves.toMatchObject({
+      mode: 'extension',
+      ready: true,
+      reason: 'cursor_claude-code_extension',
+    })
+  })
+
+  it('falls back to claude CLI in Cursor when the extension is unavailable', async () => {
+    whichMock.mockImplementation(async bin => bin === 'claude')
+
+    const { resolveIntegrationDispatchMode } =
+      await import('../src/commands/integration-dispatch-mode.js')
+
+    await expect(
+      resolveIntegrationDispatchMode({
+        assistant: 'claude-code',
+        hostIde: 'cursor',
+        homeDir: '/Users/tester',
+      }),
+    ).resolves.toMatchObject({
+      mode: 'cli',
+      ready: true,
+      reason: 'claude-code_cli',
+    })
+  })
+
+  it('prefers the Gemini extension in VS Code when available', async () => {
+    existsMock.mockImplementation(async filePath => {
+      return (
+        filePath === '/Users/tester/.vscode/extensions' ||
+        filePath === '/Users/tester/.vscode/extensions/.obsolete'
+      )
+    })
+    readJSONMock.mockResolvedValue({})
+
+    vi.doMock('node:fs/promises', () => ({
+      readdir: vi.fn().mockResolvedValue(['google.geminicodeassist-2.1.0']),
+    }))
+
+    const { resolveIntegrationDispatchMode } =
+      await import('../src/commands/integration-dispatch-mode.js')
+
+    await expect(
+      resolveIntegrationDispatchMode({
+        assistant: 'gemini',
+        hostIde: 'vscode',
+        homeDir: '/Users/tester',
+      }),
+    ).resolves.toMatchObject({
+      mode: 'extension',
+      ready: true,
+      reason: 'vscode_gemini_extension',
+    })
+  })
+
+  it('falls back to gemini CLI when the VS Code extension is unavailable', async () => {
+    whichMock.mockImplementation(async bin => bin === 'gemini')
+
+    const { resolveIntegrationDispatchMode } =
+      await import('../src/commands/integration-dispatch-mode.js')
+
+    await expect(
+      resolveIntegrationDispatchMode({
+        assistant: 'gemini',
+        hostIde: 'vscode',
+        homeDir: '/Users/tester',
+      }),
+    ).resolves.toMatchObject({
+      mode: 'cli',
+      ready: true,
+      reason: 'gemini_cli',
+    })
+  })
+
+  it('falls back to gemini CLI in Trae CN when the Gemini extension is unavailable', async () => {
+    whichMock.mockImplementation(async bin => bin === 'gemini')
+
+    const { resolveIntegrationDispatchMode } =
+      await import('../src/commands/integration-dispatch-mode.js')
+
+    await expect(
+      resolveIntegrationDispatchMode({
+        assistant: 'gemini',
+        hostIde: 'trae-cn',
+        homeDir: '/Users/tester',
+      }),
+    ).resolves.toMatchObject({
+      mode: 'cli',
+      ready: true,
+      reason: 'gemini_cli',
+    })
+  })
+})

package/tests/integration-doctor.test.ts

@@ -0,0 +1,165 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const describeIntegrationMock = vi.fn()
+const runIntegrationAutomationMock = vi.fn()
+const exitProcessMock = vi.fn()
+const logMock = {
+  header: vi.fn(),
+  info: vi.fn(),
+  success: vi.fn(),
+  warn: vi.fn(),
+  hint: vi.fn(),
+  ready: vi.fn(),
+  error: vi.fn(),
+  blank: vi.fn(),
+}
+
+vi.mock('../src/commands/integration-install.js', () => ({
+  describeIntegration: describeIntegrationMock,
+}))
+
+vi.mock('../src/commands/integration-automation.js', () => ({
+  runIntegrationAutomation: runIntegrationAutomationMock,
+}))
+
+vi.mock('../src/utils/logger.js', () => ({
+  log: logMock,
+}))
+
+vi.mock('../src/utils/process.js', () => ({
+  exitProcess: exitProcessMock,
+}))
+
+describe('integration doctor', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.spyOn(process, 'cwd').mockReturnValue('/repo')
+    describeIntegrationMock.mockReturnValue({
+      assistant: 'codex',
+      type: 'native-skill',
+      targets: ['.agents/skills/inspecto-onboarding-codex/SKILL.md'],
+      preferredInstall: 'npx @inspecto-dev/cli integrations install codex',
+      cliSupported: true,
+    })
+    runIntegrationAutomationMock.mockResolvedValue({
+      status: 'preview',
+      message:
+        'Preview complete. Inspecto did not write files or open IDE windows. Review the resolved setup below, then rerun without --preview to apply it.',
+      nextStep:
+        'Run the same command again without --preview to apply the integration and launch onboarding.',
+      details: {
+        hostIde: {
+          id: 'cursor',
+          label: 'Cursor',
+          source: 'from --host-ide',
+          confidence: 'high',
+          candidates: ['cursor'],
+        },
+        inspectoExtension: {
+          source: 'marketplace',
+          reference: 'inspecto.inspecto',
+          binaryAvailable: true,
+          status: 'preview_ready',
+        },
+        runtime: {
+          assistant: 'Codex',
+          ready: true,
+          mode: 'cli',
+        },
+        workspace: {
+          path: '/repo',
+          attempted: true,
+        },
+        onboarding: {
+          uri: 'cursor://inspecto.inspecto/send?...',
+          autoSend: true,
+        },
+      },
+    })
+  })
+
+  it('returns structured JSON diagnostics for integration preflight checks', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const { integrationDoctor } = await import('../src/commands/integration-doctor.js')
+
+    const result = await integrationDoctor('codex', { ide: 'cursor', json: true })
+
+    expect(runIntegrationAutomationMock).toHaveBeenCalledWith(
+      'codex',
+      { ide: 'cursor', preview: true, silent: true },
+      '/repo',
+    )
+    expect(result).toMatchObject({
+      schemaVersion: '1',
+      status: 'ok',
+      assistant: 'codex',
+      assets: ['.agents/skills/inspecto-onboarding-codex/SKILL.md'],
+      automation: {
+        status: 'preview',
+        details: {
+          hostIde: {
+            id: 'cursor',
+          },
+        },
+      },
+    })
+    expect(logMock.header).not.toHaveBeenCalled()
+    expect(consoleSpy).toHaveBeenCalledWith(JSON.stringify(result, null, 2))
+  })
+
+  it('prints a human-readable preflight summary in text mode', async () => {
+    const { integrationDoctor } = await import('../src/commands/integration-doctor.js')
+
+    const result = await integrationDoctor('codex', { ide: 'cursor' })
+
+    expect(result.status).toBe('ok')
+    expect(logMock.header).toHaveBeenCalledWith('Inspecto Integration Doctor')
+    expect(logMock.info).toHaveBeenCalledWith('Assistant: codex')
+    expect(logMock.info).toHaveBeenCalledWith('Host IDE: Cursor (from --host-ide)')
+    expect(logMock.info).toHaveBeenCalledWith('Inspecto extension: marketplace (inspecto.inspecto)')
+    expect(logMock.info).toHaveBeenCalledWith('Runtime: Codex via cli')
+    expect(logMock.info).toHaveBeenCalledWith('Workspace: /repo')
+    expect(logMock.info).toHaveBeenCalledWith('Onboarding URI: cursor://inspecto.inspecto/send?...')
+  })
+
+  it('prints a compact summary when compact mode is enabled', async () => {
+    const { integrationDoctor } = await import('../src/commands/integration-doctor.js')
+
+    const result = await integrationDoctor('codex', { ide: 'cursor', compact: true })
+
+    expect(result.status).toBe('ok')
+    expect(logMock.header).toHaveBeenCalledWith('Inspecto Integration Doctor')
+    expect(logMock.info).toHaveBeenCalledWith('Assistant: codex')
+    expect(logMock.info).toHaveBeenCalledWith('Host IDE: Cursor (from --host-ide)')
+    expect(logMock.info).toHaveBeenCalledWith('Runtime: Codex via cli')
+    expect(logMock.info).not.toHaveBeenCalledWith('Asset targets:')
+    expect(logMock.info).not.toHaveBeenCalledWith(
+      'Inspecto extension: marketplace (inspecto.inspecto)',
+    )
+    expect(logMock.info).not.toHaveBeenCalledWith(
+      'Onboarding URI: cursor://inspecto.inspecto/send?...',
+    )
+  })
+
+  it('exits with code 1 when failOnBlocked is enabled and the preflight is blocked', async () => {
+    runIntegrationAutomationMock.mockResolvedValue({
+      status: 'preview_blocked',
+      message:
+        'Preview blocked. Inspecto did not write files or open IDE windows because setup cannot continue until the blocking issue below is resolved.',
+      nextStep: 'Install Codex in Cursor and rerun the command.',
+      details: {
+        runtime: {
+          assistant: 'Codex',
+          ready: false,
+          mode: null,
+        },
+      },
+    })
+
+    const { integrationDoctor } = await import('../src/commands/integration-doctor.js')
+
+    await integrationDoctor('codex', { ide: 'cursor', failOnBlocked: true })
+
+    expect(exitProcessMock).toHaveBeenCalledWith(1)
+  })
+})

package/tests/integration-host-ide.test.ts

@@ -0,0 +1,172 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import * as fsUtils from '../src/utils/fs.js'
+
+vi.mock('../src/utils/fs.js', () => ({
+  exists: vi.fn(),
+  readJSON: vi.fn(),
+}))
+
+describe('resolveIntegrationHostIde', () => {
+  const originalEnv = process.env
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    process.env = { ...originalEnv }
+    delete process.env.TERM_PROGRAM
+    delete process.env.CURSOR_TRACE_DIR
+    delete process.env.CURSOR_CHANNEL
+    delete process.env.TRAE_APP_DIR
+    delete process.env.__CFBundleIdentifier
+    delete process.env.COCO_IDE_PLUGIN_TYPE
+    delete process.env.npm_config_user_agent
+    vi.mocked(fsUtils.exists).mockResolvedValue(false)
+    vi.mocked(fsUtils.readJSON).mockResolvedValue(null)
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+  })
+
+  it('prefers an explicit ide argument', async () => {
+    const { resolveIntegrationHostIde } = await import('../src/commands/integration-host-ide.js')
+
+    await expect(
+      resolveIntegrationHostIde({
+        explicitIde: 'cursor',
+        cwd: '/repo',
+      }),
+    ).resolves.toMatchObject({
+      ide: 'cursor',
+      confidence: 'high',
+      source: 'explicit',
+    })
+  })
+
+  it('accepts trae-cn as an explicit ide argument', async () => {
+    const { resolveIntegrationHostIde } = await import('../src/commands/integration-host-ide.js')
+
+    await expect(
+      resolveIntegrationHostIde({
+        explicitIde: 'trae-cn',
+        cwd: '/repo',
+      }),
+    ).resolves.toMatchObject({
+      ide: 'trae-cn',
+      confidence: 'high',
+      source: 'explicit',
+    })
+  })
+
+  it('uses .inspecto settings ide when present', async () => {
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath === '/repo/.inspecto/settings.local.json') {
+        return { ide: 'vscode' }
+      }
+      return null
+    })
+
+    const { resolveIntegrationHostIde } = await import('../src/commands/integration-host-ide.js')
+
+    await expect(
+      resolveIntegrationHostIde({
+        cwd: '/repo',
+      }),
+    ).resolves.toMatchObject({
+      ide: 'vscode',
+      confidence: 'high',
+      source: 'config',
+    })
+  })
+
+  it('uses trae-cn from .inspecto settings when present', async () => {
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath === '/repo/.inspecto/settings.local.json') {
+        return { ide: 'trae-cn' }
+      }
+      return null
+    })
+
+    const { resolveIntegrationHostIde } = await import('../src/commands/integration-host-ide.js')
+
+    await expect(
+      resolveIntegrationHostIde({
+        cwd: '/repo',
+      }),
+    ).resolves.toMatchObject({
+      ide: 'trae-cn',
+      confidence: 'high',
+      source: 'config',
+    })
+  })
+
+  it('treats a single env-detected ide as high confidence', async () => {
+    process.env.CURSOR_CHANNEL = 'stable'
+
+    const { resolveIntegrationHostIde } = await import('../src/commands/integration-host-ide.js')
+
+    await expect(
+      resolveIntegrationHostIde({
+        cwd: '/repo',
+      }),
+    ).resolves.toMatchObject({
+      ide: 'cursor',
+      confidence: 'high',
+      source: 'env',
+    })
+  })
+
+  it('treats a single project artifact as medium confidence', async () => {
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return filePath === '/repo/.cursor'
+    })
+
+    const { resolveIntegrationHostIde } = await import('../src/commands/integration-host-ide.js')
+
+    await expect(
+      resolveIntegrationHostIde({
+        cwd: '/repo',
+      }),
+    ).resolves.toMatchObject({
+      ide: 'cursor',
+      confidence: 'medium',
+      source: 'artifact',
+    })
+  })
+
+  it('treats a .trae-cn project artifact as medium confidence', async () => {
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return filePath === '/repo/.trae-cn'
+    })
+
+    const { resolveIntegrationHostIde } = await import('../src/commands/integration-host-ide.js')
+
+    await expect(
+      resolveIntegrationHostIde({
+        cwd: '/repo',
+      }),
+    ).resolves.toMatchObject({
+      ide: 'trae-cn',
+      confidence: 'medium',
+      source: 'artifact',
+    })
+  })
+
+  it('refuses to resolve an ide when project artifacts are ambiguous', async () => {
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return filePath === '/repo/.cursor' || filePath === '/repo/.vscode'
+    })
+
+    const { resolveIntegrationHostIde } = await import('../src/commands/integration-host-ide.js')
+
+    await expect(
+      resolveIntegrationHostIde({
+        cwd: '/repo',
+      }),
+    ).resolves.toMatchObject({
+      ide: null,
+      confidence: 'low',
+      source: 'ambiguous',
+      candidates: ['cursor', 'vscode'],
+    })
+  })
+})