@inspecto-dev/cli 0.3.3 → 0.3.5

package/tests/build-tool.test.ts

@@ -41,4 +41,203 @@ describe('detectBuildTools', () => {
     const result = await detectBuildTools('/repo')
     expect(result.supported.some(det => det.tool === 'vite')).toBe(true)
   })
+
+  it('marks rspack versions below 0.4.0 as legacy', async () => {
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath.includes('package.json')) {
+        return { devDependencies: { '@rspack/core': '^0.3.14' } }
+      }
+      return null
+    })
+
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath =>
+      filePath.endsWith('rspack.config.ts'),
+    )
+
+    const result = await detectBuildTools('/repo')
+    expect(result.supported).toContainEqual(
+      expect.objectContaining({
+        tool: 'rspack',
+        isLegacyRspack: true,
+      }),
+    )
+  })
+
+  it('treats ranged rspack versions below 0.4.0 as legacy', async () => {
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath.includes('package.json')) {
+        return { devDependencies: { '@rspack/core': '>=0.3.0 <0.4.0' } }
+      }
+      return null
+    })
+
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath =>
+      filePath.endsWith('rspack.config.ts'),
+    )
+
+    const result = await detectBuildTools('/repo')
+    expect(result.supported).toContainEqual(
+      expect.objectContaining({
+        tool: 'rspack',
+        isLegacyRspack: true,
+      }),
+    )
+  })
+
+  it('treats webpack 4 tilde ranges as legacy', async () => {
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath.includes('package.json')) {
+        return { devDependencies: { webpack: '~4.46.0' } }
+      }
+      return null
+    })
+
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath =>
+      filePath.endsWith('webpack.config.js'),
+    )
+
+    const result = await detectBuildTools('/repo')
+    expect(result.supported).toContainEqual(
+      expect.objectContaining({
+        tool: 'webpack',
+        isLegacyWebpack: true,
+      }),
+    )
+  })
+
+  it('resolves the real rspack config path from a script entrypoint', async () => {
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath.includes('package.json')) {
+        return {
+          devDependencies: { '@rspack/core': '^0.3.14' },
+          scripts: { dev: 'node ./rspack-scripts/dev/start.js dev' },
+        }
+      }
+      return null
+    })
+
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return (
+        filePath.endsWith('rspack-scripts/dev/start.js') ||
+        filePath.endsWith('rspack-config/rspack.config.dev.ts')
+      )
+    })
+
+    vi.mocked(fsUtils.readFile).mockImplementation(async filePath => {
+      if (filePath.endsWith('rspack-scripts/dev/start.js')) {
+        return "const configPath = path.resolve(__dirname, '../../rspack-config/rspack.config.dev.ts')"
+      }
+      return null
+    })
+
+    const result = await detectBuildTools('/repo', ['finder'])
+    expect(result.supported).toContainEqual(
+      expect.objectContaining({
+        tool: 'rspack',
+        configPath: 'finder/rspack-config/rspack.config.dev.ts',
+        isLegacyRspack: true,
+      }),
+    )
+  })
+
+  it('resolves the real rspack config path from rspack serve -c inside a script wrapper', async () => {
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath.includes('package.json')) {
+        return {
+          devDependencies: { '@rspack/core': '^0.3.14' },
+          scripts: { dev: 'node ./rspack-scripts/dev/start.js dev' },
+        }
+      }
+      return null
+    })
+
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return (
+        filePath.endsWith('rspack-scripts/dev/start.js') ||
+        filePath.endsWith('rspack-config/rspack.config.dev.ts')
+      )
+    })
+
+    vi.mocked(fsUtils.readFile).mockImplementation(async filePath => {
+      if (filePath.endsWith('rspack-scripts/dev/start.js')) {
+        return 'const cli = `NODE_ENV=development rspack serve -c ./rspack-config/rspack.config.dev.ts`'
+      }
+      return null
+    })
+
+    const result = await detectBuildTools('/repo', ['finder'])
+    expect(result.supported).toContainEqual(
+      expect.objectContaining({
+        tool: 'rspack',
+        configPath: 'finder/rspack-config/rspack.config.dev.ts',
+        isLegacyRspack: true,
+      }),
+    )
+  })
+
+  it('prefers the dev webpack script and resolves a shared webpack base config', async () => {
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath.includes('package.json')) {
+        return {
+          devDependencies: { webpack: '^4.46.0', 'webpack-cli': '^3.0.8' },
+          scripts: {
+            dll_dev: 'webpack --config webpack.dll.config.js',
+            start:
+              'node ./node_modules/.bin/webpack-dev-server --hot --inline --progress --config webpack.config.esbuild.js',
+            prod: 'node ./node_modules/.bin/webpack --config webpack.config.prod.js',
+          },
+        }
+      }
+      return null
+    })
+
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return (
+        filePath.endsWith('webpack.config.esbuild.js') ||
+        filePath.endsWith('webpack.config.common.js') ||
+        filePath.endsWith('webpack.dll.config.js')
+      )
+    })
+
+    vi.mocked(fsUtils.readFile).mockImplementation(async filePath => {
+      if (filePath.endsWith('webpack.config.esbuild.js')) {
+        return "const configPath = './webpack.config.common.js'; const devConfig = require(configPath);"
+      }
+      return null
+    })
+
+    const result = await detectBuildTools('/repo')
+    expect(result.supported).toContainEqual(
+      expect.objectContaining({
+        tool: 'webpack',
+        configPath: 'webpack.config.common.js',
+        isLegacyWebpack: true,
+      }),
+    )
+  })
+
+  it('detects webpack.config.common.js without relying on package scripts', async () => {
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath.includes('package.json')) {
+        return {
+          devDependencies: { webpack: '^4.46.0', 'webpack-cli': '^3.0.8' },
+          scripts: {},
+        }
+      }
+      return null
+    })
+
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return filePath.endsWith('webpack.config.common.js')
+    })
+
+    const result = await detectBuildTools('/repo')
+    expect(result.supported).toContainEqual(
+      expect.objectContaining({
+        tool: 'webpack',
+        configPath: 'webpack.config.common.js',
+        isLegacyWebpack: true,
+      }),
+    )
+  })
 })

package/tests/dev-config.test.ts

@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import * as fsUtils from '../src/utils/fs.js'
+import * as gitignoreUtils from '../src/inject/gitignore.js'
+import { devLink, devStatus, devUnlink } from '../src/commands/dev-config.js'
+
+vi.mock('../src/utils/fs.js', () => ({
+  exists: vi.fn(),
+  readJSON: vi.fn(),
+  removeFile: vi.fn(),
+  writeJSON: vi.fn(),
+}))
+
+vi.mock('../src/inject/gitignore.js', () => ({
+  updateGitignore: vi.fn(),
+}))
+
+describe('dev config commands', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.spyOn(process, 'cwd').mockReturnValue('/repo')
+  })
+
+  it('writes cliBin into .inspecto/dev.json', async () => {
+    vi.mocked(fsUtils.readJSON).mockResolvedValue(null)
+
+    const result = await devLink({ cliBin: '/tmp/inspecto/bin.js', json: true })
+
+    expect(gitignoreUtils.updateGitignore).toHaveBeenCalledWith('/repo', false, false, true)
+    expect(fsUtils.writeJSON).toHaveBeenCalledWith('/repo/.inspecto/dev.json', {
+      cliBin: '/tmp/inspecto/bin.js',
+    })
+    expect(result.config).toEqual({ cliBin: '/tmp/inspecto/bin.js' })
+  })
+
+  it('writes devRepo into .inspecto/dev.json', async () => {
+    vi.mocked(fsUtils.readJSON).mockResolvedValue({ cliBin: '/tmp/old.js' })
+
+    const result = await devLink({ devRepo: '/tmp/inspecto', json: true })
+
+    expect(gitignoreUtils.updateGitignore).toHaveBeenCalledWith('/repo', false, false, true)
+    expect(fsUtils.writeJSON).toHaveBeenCalledWith('/repo/.inspecto/dev.json', {
+      cliBin: '/tmp/old.js',
+      devRepo: '/tmp/inspecto',
+    })
+    expect(result.config).toEqual({
+      cliBin: '/tmp/old.js',
+      devRepo: '/tmp/inspecto',
+    })
+  })
+
+  it('returns current dev config status', async () => {
+    vi.mocked(fsUtils.exists).mockResolvedValue(true)
+    vi.mocked(fsUtils.readJSON).mockResolvedValue({
+      cliBin: '/tmp/inspecto/bin.js',
+      devRepo: '/tmp/inspecto',
+    })
+
+    const result = await devStatus(true)
+
+    expect(result.status).toBe('ok')
+    expect(result.config).toEqual({
+      cliBin: '/tmp/inspecto/bin.js',
+      devRepo: '/tmp/inspecto',
+    })
+  })
+
+  it('clears the dev config on unlink', async () => {
+    const result = await devUnlink(true)
+
+    expect(fsUtils.removeFile).toHaveBeenCalledWith('/repo/.inspecto/dev.json')
+    expect(result.status).toBe('ok')
+  })
+})

package/tests/doctor.test.ts

@@ -200,6 +200,47 @@ describe('doctor command', () => {
     )
   })
 
+  it('warns when configured ide and detected ide differ, and explains that config wins', async () => {
+    mockFailingInstall()
+    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.local.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.local.json') {
+        return { ide: 'trae-cn', 'provider.default': 'coco.cli' }
+      }
+      return null
+    })
+    vi.mocked(ide.detectIDE).mockResolvedValue({
+      detected: [{ ide: 'trae', supported: true }],
+    })
+
+    const result = await collectDoctorResult('/repo')
+
+    expect(result.warnings).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'settings-ide-mismatch',
+          message:
+            '.inspecto/settings.local.json sets ide=trae-cn, but the current environment looks like trae. Inspecto will use the configured IDE from settings.local.json.',
+          hints: [
+            'Update .inspecto/settings.local.json if you want Inspecto to target the currently detected IDE instead.',
+          ],
+        }),
+      ]),
+    )
+  })
+
   it('preserves the human-readable doctor output in text mode', async () => {
     mockFailingInstall()
 
@@ -221,4 +262,93 @@ describe('doctor command', () => {
     expect(output).not.toContain('"status"')
     expect(output).not.toContain('"summary"')
   })
+
+  it('reports Next.js as guided onboarding instead of unsupported', async () => {
+    vi.mocked(fsUtils.exists).mockImplementation(async (filePath: string) => {
+      const existingPaths = new Set([
+        '/repo/package.json',
+        '/repo/node_modules/@inspecto-dev/plugin',
+        '/repo/next.config.ts',
+        '/repo/.inspecto/settings.local.json',
+        '/repo/.gitignore',
+      ])
+      return existingPaths.has(filePath)
+    })
+    vi.mocked(fsUtils.readJSON).mockImplementation(async (filePath: string) => {
+      if (filePath === '/repo/package.json') {
+        return { scripts: { dev: 'next dev --webpack' } }
+      }
+      if (filePath === '/repo/node_modules/@inspecto-dev/plugin/package.json') {
+        return { version: '1.2.3' }
+      }
+      if (filePath === '/repo/.inspecto/settings.local.json') {
+        return { ide: 'trae', 'provider.default': 'coco.cli' }
+      }
+      return null
+    })
+    vi.mocked(fsUtils.readFile).mockImplementation(async filePath => {
+      if (filePath === '/repo/next.config.ts') {
+        return "import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'\nexport default {}"
+      }
+      if (filePath === '/repo/.gitignore') {
+        return '.inspecto/install.lock\n.inspecto/dev.json\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: 'trae', supported: true }],
+    })
+    vi.mocked(framework.detectFrameworks).mockResolvedValue({
+      supported: ['react'],
+      unsupported: [],
+    })
+    vi.mocked(provider.detectProviders).mockResolvedValue({
+      detected: [{ label: 'Trae CLI (Coco)', providerModes: ['cli'] }],
+    })
+    vi.mocked(buildTool.detectBuildTools).mockResolvedValue({
+      supported: [],
+      unsupported: ['Next.js'],
+    })
+    vi.mocked(extension.isExtensionInstalled).mockResolvedValue(true)
+
+    const result = await collectDoctorResult('/repo')
+
+    expect(result.status).toBe('warning')
+    expect(result.errors).toEqual([])
+    expect(result.warnings).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'build-tool-guided',
+          message: 'Build tool: Next.js (guided onboarding available)',
+          hints: expect.arrayContaining([
+            'Run `inspecto onboard --json` to generate the remaining patch plan and assistant handoff.',
+            expect.stringContaining('Review the generated Next.js patch plan'),
+          ]),
+          details: expect.objectContaining({
+            metaFrameworks: ['Next.js'],
+            patchCount: expect.any(Number),
+            pendingSteps: expect.arrayContaining([
+              expect.stringContaining('Review the generated Next.js patch plan'),
+            ]),
+            assistantPrompt: expect.stringContaining(
+              'Complete the remaining Inspecto onboarding for this Next.js project.',
+            ),
+          }),
+        }),
+      ]),
+    )
+    expect(result.warnings).toEqual(
+      expect.not.arrayContaining([expect.objectContaining({ code: 'build-tool-unsupported' })]),
+    )
+    expect(result.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'guided-config-patch-pending',
+          message: 'Guided config patch still needs review in next.config.js',
+        }),
+      ]),
+    )
+  })
 })

package/tests/init.test.ts

@@ -244,6 +244,23 @@ describe('init in monorepo roots', () => {
     expect(instructionUtils.printNuxtManualInstructions).not.toHaveBeenCalled()
   })
 
+  it('prints detailed Nuxt guided instructions when Nuxt is detected', async () => {
+    vi.mocked(buildToolUtils.detectBuildTools).mockResolvedValue({
+      supported: [],
+      unsupported: ['Nuxt'],
+    })
+
+    await init({
+      shared: false,
+      skipInstall: true,
+      dryRun: true,
+      noExtension: true,
+      force: false,
+    })
+
+    expect(instructionUtils.printNuxtManualInstructions).toHaveBeenCalled()
+  })
+
   it('preserves detected preferred mode for an explicit provider override', async () => {
     vi.mocked(buildToolUtils.detectBuildTools).mockResolvedValue({
       supported: [

package/tests/install-wrapper.test.ts

@@ -111,4 +111,60 @@ describe('assistant integration bootstrap wrapper', () => {
       'project',
     ])
   })
+
+  it('installs coco raw assets into the trae skill directory', 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.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, '../../../scripts/install.sh')
+
+    await execFileAsync('bash', [scriptPath, 'coco'], {
+      cwd: tempRoot,
+      env: {
+        ...process.env,
+        PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+      },
+    })
+
+    const installed = await fs.readFile(
+      path.join(tempRoot, '.trae/skills/inspecto-onboarding/SKILL.md'),
+      'utf8',
+    )
+    expect(installed).toBe('downloaded from wrapper\n')
+
+    const launcher = await fs.readFile(
+      path.join(tempRoot, '.trae/skills/inspecto-onboarding/scripts/run-inspecto.sh'),
+      'utf8',
+    )
+    expect(launcher).toBe('downloaded from wrapper\n')
+  })
 })

package/tests/instructions.test.ts

@@ -19,7 +19,9 @@ describe('manual framework instructions', () => {
     printNextJsManualInstructions()
 
     expect(log.blank).toHaveBeenCalled()
-    expect(log.hint).toHaveBeenCalledWith('Next.js requires manual setup in the current version.')
+    expect(log.hint).toHaveBeenCalledWith(
+      'Next.js supports guided setup in the current version. Inspecto can prepare the config patch, but the client-side mount step still needs review.',
+    )
     expect(log.hint).toHaveBeenCalledWith(
       '1. Update `next.config.mjs` to register the Inspecto webpack plugin:',
     )
@@ -30,10 +32,10 @@ describe('manual framework instructions', () => {
       ]),
     )
     expect(log.hint).toHaveBeenCalledWith(
-      '2. Initialize `@inspecto-dev/core` from a client component such as `app/layout.tsx` or `pages/_app.tsx`:',
+      '2. Complete the remaining client-side mount step in `app/layout.tsx` or `pages/_app.tsx`:',
     )
     expect(log.hint).toHaveBeenCalledWith(
-      '3. Restart your Next.js dev server after updating the config.',
+      '3. Restart your Next.js dev server after applying the guided patches.',
     )
   })
 
@@ -41,7 +43,9 @@ describe('manual framework instructions', () => {
     printNuxtManualInstructions()
 
     expect(log.blank).toHaveBeenCalled()
-    expect(log.hint).toHaveBeenCalledWith('Nuxt requires manual setup in the current version.')
+    expect(log.hint).toHaveBeenCalledWith(
+      'Nuxt supports guided setup in the current version. Inspecto can prepare the config patch, but the client plugin mount step still needs review.',
+    )
     expect(log.hint).toHaveBeenCalledWith(
       '1. Update `nuxt.config.ts` to register the Inspecto Vite plugin:',
     )
@@ -52,10 +56,10 @@ describe('manual framework instructions', () => {
       ]),
     )
     expect(log.hint).toHaveBeenCalledWith(
-      '2. Create `plugins/inspecto.client.ts` to mount `@inspecto-dev/core` in development:',
+      '2. Complete the remaining client plugin mount step in `plugins/inspecto.client.ts`:',
     )
     expect(log.hint).toHaveBeenCalledWith(
-      '3. Restart your Nuxt dev server after updating the config.',
+      '3. Restart your Nuxt dev server after applying the guided patches.',
     )
   })
 })

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

@@ -169,4 +169,24 @@ describe('resolveIntegrationHostIde', () => {
       candidates: ['cursor', 'vscode'],
     })
   })
+
+  it('ignores project artifacts when requested by integration install flows', async () => {
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return filePath === '/repo/.trae'
+    })
+
+    const { resolveIntegrationHostIde } = await import('../src/commands/integration-host-ide.js')
+
+    await expect(
+      resolveIntegrationHostIde({
+        cwd: '/repo',
+        ignoreProjectArtifacts: true,
+      }),
+    ).resolves.toMatchObject({
+      ide: null,
+      confidence: 'low',
+      source: 'none',
+      candidates: [],
+    })
+  })
 })