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

package/tests/install-wrapper.test.ts

@@ -0,0 +1,76 @@
+import { execFile } from 'node:child_process'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { promisify } from 'node:util'
+import { afterEach, describe, expect, it } from 'vitest'
+
+const execFileAsync = promisify(execFile)
+
+describe('assistant integration bootstrap wrapper', () => {
+  const tempDirs: string[] = []
+
+  afterEach(async () => {
+    await Promise.all(tempDirs.map(dir => fs.rm(dir, { recursive: true, force: true })))
+    tempDirs.length = 0
+  })
+
+  it('falls back to raw asset download and still honors --force', async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'inspecto-wrapper-'))
+    tempDirs.push(tempRoot)
+
+    const fakeBin = path.join(tempRoot, 'bin')
+    await fs.mkdir(fakeBin, { recursive: true })
+    await fs.mkdir(path.join(tempRoot, '.github'), { recursive: true })
+    await fs.writeFile(
+      path.join(tempRoot, '.github/copilot-instructions.md'),
+      'old content\n',
+      'utf8',
+    )
+
+    await fs.writeFile(path.join(fakeBin, 'npx'), '#!/usr/bin/env bash\nexit 127\n', 'utf8')
+    await fs.chmod(path.join(fakeBin, 'npx'), 0o755)
+
+    await fs.writeFile(
+      path.join(fakeBin, 'curl'),
+      [
+        '#!/usr/bin/env bash',
+        'set -euo pipefail',
+        'out=""',
+        'while [[ $# -gt 0 ]]; do',
+        '  case "$1" in',
+        '    -o)',
+        '      out="$2"',
+        '      shift 2',
+        '      ;;',
+        '    *)',
+        '      shift',
+        '      ;;',
+        '  esac',
+        'done',
+        'printf "downloaded from wrapper\n" > "$out"',
+      ].join('\n'),
+      'utf8',
+    )
+    await fs.chmod(path.join(fakeBin, 'curl'), 0o755)
+
+    const scriptPath = path.resolve(
+      __dirname,
+      '../../../assistant-integrations/scripts/install.sh',
+    )
+
+    await execFileAsync('bash', [scriptPath, 'copilot', '--force'], {
+      cwd: tempRoot,
+      env: {
+        ...process.env,
+        PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+      },
+    })
+
+    const installed = await fs.readFile(
+      path.join(tempRoot, '.github/copilot-instructions.md'),
+      'utf8',
+    )
+    expect(installed).toBe('downloaded from wrapper\n')
+  })
+})

package/tests/instructions.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest'
+import { printNextJsManualInstructions, printNuxtManualInstructions } from '../src/instructions.js'
+import { log } from '../src/utils/logger.js'
+
+vi.mock('../src/utils/logger.js', () => ({
+  log: {
+    blank: vi.fn(),
+    hint: vi.fn(),
+    copyableCodeBlock: vi.fn(),
+  },
+}))
+
+describe('manual framework instructions', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+  })
+
+  it('prints detailed Next.js instructions with step-by-step code blocks', () => {
+    printNextJsManualInstructions()
+
+    expect(log.blank).toHaveBeenCalled()
+    expect(log.hint).toHaveBeenCalledWith('Next.js requires manual setup in the current version.')
+    expect(log.hint).toHaveBeenCalledWith(
+      '1. Update `next.config.mjs` to register the Inspecto webpack plugin:',
+    )
+    expect(log.copyableCodeBlock).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        "import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'",
+        'export default nextConfig',
+      ]),
+    )
+    expect(log.hint).toHaveBeenCalledWith(
+      '2. Initialize `@inspecto-dev/core` from a client component such as `app/layout.tsx` or `pages/_app.tsx`:',
+    )
+    expect(log.hint).toHaveBeenCalledWith(
+      '3. Restart your Next.js dev server after updating the config.',
+    )
+  })
+
+  it('prints detailed Nuxt instructions with step-by-step code blocks', () => {
+    printNuxtManualInstructions()
+
+    expect(log.blank).toHaveBeenCalled()
+    expect(log.hint).toHaveBeenCalledWith('Nuxt requires manual setup in the current version.')
+    expect(log.hint).toHaveBeenCalledWith(
+      '1. Update `nuxt.config.ts` to register the Inspecto Vite plugin:',
+    )
+    expect(log.copyableCodeBlock).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        "import { vitePlugin as inspecto } from '@inspecto-dev/plugin'",
+        'export default defineNuxtConfig({',
+      ]),
+    )
+    expect(log.hint).toHaveBeenCalledWith(
+      '2. Create `plugins/inspecto.client.ts` to mount `@inspecto-dev/core` in development:',
+    )
+    expect(log.hint).toHaveBeenCalledWith(
+      '3. Restart your Nuxt dev server after updating the config.',
+    )
+  })
+})

package/tests/integration-install.test.ts

@@ -0,0 +1,294 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const writeFileMock = vi.fn()
+const existsMock = vi.fn()
+const chmodMock = 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/utils/fs.js', () => ({
+  writeFile: writeFileMock,
+  exists: existsMock,
+}))
+
+vi.mock('node:fs/promises', () => ({
+  default: {
+    chmod: chmodMock,
+  },
+}))
+
+vi.mock('node:os', () => ({
+  homedir: () => '/Users/tester',
+}))
+
+vi.mock('../src/utils/logger.js', () => ({
+  log: logMock,
+}))
+
+describe('integration install', () => {
+  beforeEach(() => {
+    vi.resetModules()
+    vi.clearAllMocks()
+    existsMock.mockResolvedValue(false)
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockResolvedValue({
+        ok: true,
+        text: async () => '# mock asset',
+        status: 200,
+        statusText: 'OK',
+      }),
+    )
+  })
+
+  it('installs the Claude Code skill into the user skill directory', async () => {
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('claude-code', { scope: 'user' })
+
+    expect(writeFileMock).toHaveBeenCalledWith(
+      '/Users/tester/.claude/skills/inspecto-onboarding-claude-code/SKILL.md',
+      '# mock asset',
+    )
+    expect(writeFileMock).toHaveBeenCalledWith(
+      '/Users/tester/.claude/skills/inspecto-onboarding-claude-code/agents/openai.yaml',
+      '# mock asset',
+    )
+    expect(writeFileMock).toHaveBeenCalledWith(
+      '/Users/tester/.claude/skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh',
+      '# mock asset',
+    )
+    expect(chmodMock).toHaveBeenCalledWith(
+      '/Users/tester/.claude/skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh',
+      0o755,
+    )
+  })
+
+  it('installs the Codex skill into the Codex skill directory', async () => {
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('codex')
+
+    expect(writeFileMock).toHaveBeenCalledWith(
+      '/Users/tester/.codex/skills/inspecto-onboarding-codex/SKILL.md',
+      '# mock asset',
+    )
+    expect(writeFileMock).toHaveBeenCalledWith(
+      '/Users/tester/.codex/skills/inspecto-onboarding-codex/agents/openai.yaml',
+      '# mock asset',
+    )
+    expect(writeFileMock).toHaveBeenCalledWith(
+      '/Users/tester/.codex/skills/inspecto-onboarding-codex/scripts/run-inspecto.sh',
+      '# mock asset',
+    )
+    expect(chmodMock).toHaveBeenCalledWith(
+      '/Users/tester/.codex/skills/inspecto-onboarding-codex/scripts/run-inspecto.sh',
+      0o755,
+    )
+  })
+
+  it('installs the Cursor AGENTS fallback when agents mode is selected', async () => {
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('cursor', { mode: 'agents' })
+
+    expect(writeFileMock).toHaveBeenCalledTimes(1)
+    expect(writeFileMock).toHaveBeenCalledWith('AGENTS.md', '# mock asset')
+  })
+
+  it('refuses a multi-file Claude install before writing anything when one target already exists', async () => {
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    existsMock.mockImplementation(async filePath => {
+      return (
+        filePath ===
+        '/Users/tester/.claude/skills/inspecto-onboarding-claude-code/agents/openai.yaml'
+      )
+    })
+
+    await expect(installIntegration('claude-code', { scope: 'user' })).rejects.toThrow(
+      'Refusing to overwrite existing file',
+    )
+
+    expect(writeFileMock).not.toHaveBeenCalled()
+    expect(chmodMock).not.toHaveBeenCalled()
+  })
+
+  it('downloads all Claude assets before writing any file', async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        text: async () => '# skill',
+        status: 200,
+        statusText: 'OK',
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        text: async () => '',
+        status: 503,
+        statusText: 'Unavailable',
+      })
+
+    vi.stubGlobal('fetch', fetchMock)
+
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await expect(installIntegration('claude-code', { scope: 'user' })).rejects.toThrow(
+      'Failed to download',
+    )
+
+    expect(writeFileMock).not.toHaveBeenCalled()
+    expect(chmodMock).not.toHaveBeenCalled()
+  })
+
+  it('surfaces the asset URL when fetch itself fails', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('fetch failed')))
+
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await expect(installIntegration('codex')).rejects.toThrow(
+      'Failed to download https://raw.githubusercontent.com/inspecto-dev/inspecto/main/skills/inspecto-onboarding-codex/SKILL.md: fetch failed',
+    )
+
+    expect(writeFileMock).not.toHaveBeenCalled()
+    expect(chmodMock).not.toHaveBeenCalled()
+  })
+
+  it('lists supported integrations with their preferred install targets', async () => {
+    const { listIntegrationManifests } = await import('../src/commands/integration-install.js')
+
+    expect(listIntegrationManifests()).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          assistant: 'codex',
+          type: 'native-skill',
+          installTarget: '~/.codex/skills/',
+          cliSupported: true,
+        }),
+        expect.objectContaining({
+          assistant: 'claude-code',
+          type: 'native-skill',
+          installTarget: '.claude/skills/ or ~/.claude/skills/',
+        }),
+        expect.objectContaining({
+          assistant: 'copilot',
+          type: 'instruction-template',
+          installTarget: '.github/copilot-instructions.md or AGENTS.md',
+        }),
+      ]),
+    )
+  })
+
+  it('describes the resolved install targets for a selected assistant variant', async () => {
+    const { describeIntegration } = await import('../src/commands/integration-install.js')
+
+    expect(describeIntegration('claude-code', { scope: 'user' })).toMatchObject({
+      assistant: 'claude-code',
+      targets: [
+        '/Users/tester/.claude/skills/inspecto-onboarding-claude-code/SKILL.md',
+        '/Users/tester/.claude/skills/inspecto-onboarding-claude-code/agents/openai.yaml',
+        '/Users/tester/.claude/skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh',
+      ],
+      preferredInstall: 'npx @inspecto-dev/cli integrations install claude-code --scope project',
+    })
+  })
+
+  it('describes codex using the same CLI-managed install target model', async () => {
+    const { describeIntegration } = await import('../src/commands/integration-install.js')
+
+    expect(describeIntegration('codex')).toMatchObject({
+      assistant: 'codex',
+      targets: [
+        '/Users/tester/.codex/skills/inspecto-onboarding-codex/SKILL.md',
+        '/Users/tester/.codex/skills/inspecto-onboarding-codex/agents/openai.yaml',
+        '/Users/tester/.codex/skills/inspecto-onboarding-codex/scripts/run-inspecto.sh',
+      ],
+      preferredInstall: 'npx @inspecto-dev/cli integrations install codex',
+    })
+  })
+
+  it('prints integration paths without using post-install hints', async () => {
+    const { printIntegrationPath } = await import('../src/commands/integration-install.js')
+
+    printIntegrationPath('claude-code', { scope: 'user' })
+
+    expect(logMock.info).toHaveBeenCalledWith(
+      '/Users/tester/.claude/skills/inspecto-onboarding-claude-code/SKILL.md',
+    )
+    expect(logMock.hint).toHaveBeenCalledWith(
+      'Preferred install: npx @inspecto-dev/cli integrations install claude-code --scope project',
+    )
+    expect(logMock.hint).not.toHaveBeenCalledWith('Restart Claude Code to load the new skill.')
+  })
+
+  it('rejects unsupported extra args and options for list/path', async () => {
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as never)
+
+    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() }))
+
+    const { runCli } = await import('../src/bin.js')
+
+    await runCli(['node', 'inspecto', 'integrations', 'list', 'extra'])
+    await runCli(['node', 'inspecto', 'integrations', 'path', 'claude-code', '--force'])
+
+    expect(logMock.error).toHaveBeenCalledWith(
+      'The `list` subcommand does not accept assistant names, --scope, --mode, or --force.',
+    )
+    expect(logMock.error).toHaveBeenCalledWith('The `path` subcommand does not support `--force`.')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+
+    exitSpy.mockRestore()
+  })
+
+  it('wires the nested CLI command to the integration installer', async () => {
+    const installCommand = vi.fn().mockResolvedValue(undefined)
+    const listCommand = vi.fn().mockResolvedValue(undefined)
+    const pathCommand = 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/integration-install.js', () => ({
+      installIntegration: installCommand,
+      printIntegrationList: listCommand,
+      printIntegrationPath: pathCommand,
+    }))
+
+    const { runCli } = await import('../src/bin.js')
+
+    await runCli([
+      'node',
+      'inspecto',
+      'integrations',
+      'install',
+      'copilot',
+      '--mode',
+      'agents',
+      '--force',
+    ])
+
+    await runCli(['node', 'inspecto', 'integrations', 'list'])
+    await runCli(['node', 'inspecto', 'integrations', 'path', 'claude-code', '--scope', 'user'])
+
+    expect(installCommand).toHaveBeenCalledWith('copilot', { mode: 'agents', force: true })
+    expect(listCommand).toHaveBeenCalledWith()
+    expect(pathCommand).toHaveBeenCalledWith('claude-code', { scope: 'user' })
+  })
+})

package/tests/logger.test.ts

@@ -0,0 +1,100 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { log } from '../src/utils/logger.js'
+import { reportCommandError, writeCommandOutput } from '../src/utils/output.js'
+
+describe('logger copyable code blocks', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('prints copyable code without box drawing characters', () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    log.copyableCodeBlock(['const answer = 42', 'console.log(answer)'])
+
+    const output = consoleSpy.mock.calls.map(call => String(call[0]))
+
+    expect(output).not.toContain(expect.stringContaining('┌'))
+    expect(output).not.toContain(expect.stringContaining('│'))
+    expect(output).not.toContain(expect.stringContaining('└'))
+    expect(output).toContain('      const answer = 42')
+    expect(output).toContain('      console.log(answer)')
+  })
+})
+
+describe('command output utility', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('prints formatted JSON and skips the plain-text renderer in json mode', () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const renderText = vi.fn()
+    const result = { status: 'ok', nested: { value: 1 } }
+
+    const returned = writeCommandOutput(result, true, renderText)
+
+    expect(returned).toBe(result)
+    expect(renderText).not.toHaveBeenCalled()
+    expect(consoleSpy).toHaveBeenCalledWith(JSON.stringify(result, null, 2))
+  })
+
+  it('uses the plain-text renderer when json mode is disabled', () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const renderText = vi.fn()
+    const result = { status: 'ok' }
+
+    const returned = writeCommandOutput(result, false, renderText)
+
+    expect(returned).toBe(result)
+    expect(renderText).toHaveBeenCalledWith(result)
+    expect(consoleSpy).not.toHaveBeenCalled()
+  })
+
+  it('prints machine-safe JSON errors when json mode is enabled', () => {
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const loggerSpy = vi.spyOn(log, 'error').mockImplementation(() => {})
+    const error = new Error('boom')
+    error.stack = 'Error: boom\n    at fake'
+
+    reportCommandError(error, { json: true })
+
+    expect(loggerSpy).not.toHaveBeenCalled()
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      JSON.stringify(
+        {
+          status: 'error',
+          error: {
+            message: 'boom',
+          },
+        },
+        null,
+        2,
+      ),
+    )
+  })
+
+  it('includes the stack in JSON error output when debug mode is enabled', () => {
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const loggerSpy = vi.spyOn(log, 'error').mockImplementation(() => {})
+    const error = new Error('boom')
+    error.stack = 'Error: boom\n    at fake'
+
+    reportCommandError(error, { json: true, debug: true })
+
+    expect(loggerSpy).not.toHaveBeenCalled()
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      JSON.stringify(
+        {
+          status: 'error',
+          error: {
+            message: 'boom',
+            stack: 'Error: boom\n    at fake',
+          },
+        },
+        null,
+        2,
+      ),
+    )
+  })
+})