@inspecto-dev/cli 0.3.3 → 0.3.4

package/tests/apply.test.ts

@@ -166,6 +166,173 @@ describe('apply onboarding flow', () => {
     })
   })
 
+  it('only injects the explicitly selected build target', async () => {
+    const rspackBuild: BuildToolDetection = {
+      tool: 'rspack',
+      configPath: 'finder/rspack.config.ts',
+      label: 'Rspack (finder/rspack.config.ts)',
+      packagePath: 'finder',
+    }
+
+    const result = await applyOnboardingPlan({
+      repoRoot: '/repo',
+      projectRoot: '/repo/finder',
+      packageManager: 'pnpm',
+      supportedBuildTargets: [rspackBuild],
+      options: {
+        shared: false,
+        skipInstall: false,
+        dryRun: false,
+        noExtension: false,
+      },
+      selectedIDE: { ide: 'vscode', supported: true },
+      providerDefault: 'codex.extension',
+      plan: {
+        status: 'ok',
+        warnings: [],
+        blockers: [],
+        strategy: 'supported',
+        actions: [],
+        defaults: {
+          shared: false,
+          extension: true,
+          provider: 'codex',
+          ide: 'vscode',
+        },
+      },
+    })
+
+    expect(astInjectorUtils.injectPlugin).toHaveBeenCalledTimes(1)
+    expect(astInjectorUtils.injectPlugin).toHaveBeenCalledWith('/repo', rspackBuild, false, false)
+    expect(result.postInstall.injectionFailed).toBe(false)
+  })
+
+  it('supports legacy rspack partial onboarding without attempting automatic injection', async () => {
+    const legacyRspackBuild: BuildToolDetection = {
+      tool: 'rspack',
+      configPath: 'finder/rspack-config/rspack.config.dev.ts',
+      label: 'Rspack (finder/rspack-config/rspack.config.dev.ts) [Legacy]',
+      packagePath: 'finder',
+      isLegacyRspack: true,
+    }
+
+    const result = await applyOnboardingPlan({
+      repoRoot: '/repo',
+      projectRoot: '/repo/finder',
+      packageManager: 'pnpm',
+      supportedBuildTargets: [legacyRspackBuild],
+      options: {
+        shared: false,
+        skipInstall: false,
+        dryRun: false,
+        noExtension: false,
+      },
+      selectedIDE: { ide: 'trae', supported: true },
+      providerDefault: 'coco.cli',
+      plan: {
+        status: 'warning',
+        warnings: [
+          {
+            code: 'legacy-rspack-requires-manual-config',
+            message:
+              'Legacy Rspack detected at finder/rspack-config/rspack.config.dev.ts. Inspecto must use the legacy Rspack plugin entry and manual config steps.',
+          },
+        ],
+        blockers: [],
+        strategy: 'manual',
+        actions: [
+          {
+            type: 'install_dependency',
+            target: '@inspecto-dev/plugin @inspecto-dev/core',
+            description: 'Install the Inspecto runtime packages with pnpm.',
+          },
+          {
+            type: 'manual_step',
+            target: 'finder/rspack-config/rspack.config.dev.ts',
+            description:
+              'Update finder/rspack-config/rspack.config.dev.ts to import `rspackPlugin` from `@inspecto-dev/plugin/legacy/rspack` and add it to the Rspack plugins array.',
+          },
+        ],
+        defaults: {
+          shared: false,
+          extension: true,
+          provider: 'coco',
+          ide: 'trae',
+        },
+      },
+      allowManualPlanApply: true,
+    })
+
+    expect(astInjectorUtils.injectPlugin).not.toHaveBeenCalled()
+    expect(result.status).toBe('warning')
+    expect(result.postInstall.nextSteps).toContain(
+      'Update finder/rspack-config/rspack.config.dev.ts to import `rspackPlugin` from `@inspecto-dev/plugin/legacy/rspack` and add it to the Rspack plugins array.',
+    )
+  })
+
+  it('supports webpack 4 partial onboarding without attempting automatic injection', async () => {
+    const legacyWebpackBuild: BuildToolDetection = {
+      tool: 'webpack',
+      configPath: 'app/webpack.config.js',
+      label: 'Webpack (app/webpack.config.js) [Webpack 4]',
+      packagePath: 'app',
+      isLegacyWebpack: true,
+    }
+
+    const result = await applyOnboardingPlan({
+      repoRoot: '/repo',
+      projectRoot: '/repo/app',
+      packageManager: 'pnpm',
+      supportedBuildTargets: [legacyWebpackBuild],
+      options: {
+        shared: false,
+        skipInstall: false,
+        dryRun: false,
+        noExtension: false,
+      },
+      selectedIDE: { ide: 'cursor', supported: true },
+      providerDefault: 'copilot.extension',
+      plan: {
+        status: 'warning',
+        warnings: [
+          {
+            code: 'legacy-webpack4-requires-manual-config',
+            message:
+              'Webpack 4 detected at app/webpack.config.js. Inspecto must use the legacy Webpack 4 plugin entry and manual config steps.',
+          },
+        ],
+        blockers: [],
+        strategy: 'manual',
+        actions: [
+          {
+            type: 'install_dependency',
+            target: '@inspecto-dev/plugin @inspecto-dev/core',
+            description: 'Install the Inspecto runtime packages with pnpm.',
+          },
+          {
+            type: 'manual_step',
+            target: 'app/webpack.config.js',
+            description:
+              'Update app/webpack.config.js to import `webpackPlugin` from `@inspecto-dev/plugin/legacy/webpack4` and add it to the Webpack plugins array.',
+          },
+        ],
+        defaults: {
+          shared: false,
+          extension: true,
+          provider: 'copilot',
+          ide: 'cursor',
+        },
+      },
+      allowManualPlanApply: true,
+    })
+
+    expect(astInjectorUtils.injectPlugin).not.toHaveBeenCalled()
+    expect(result.status).toBe('warning')
+    expect(result.postInstall.nextSteps).toContain(
+      'Update app/webpack.config.js to import `webpackPlugin` from `@inspecto-dev/plugin/legacy/webpack4` and add it to the Webpack plugins array.',
+    )
+  })
+
   it('uses onboarding context and planner output and prints JSON from the apply command', async () => {
     const context: OnboardingContext = {
       root: '/repo',
@@ -540,6 +707,73 @@ describe('apply onboarding flow', () => {
     expect(fsUtils.writeJSON).toHaveBeenCalledWith('/repo/.inspecto/prompts.local.json', [])
   })
 
+  it('merges missing defaults into an existing valid local settings file', async () => {
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return filePath === '/repo/.inspecto/settings.local.json'
+    })
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath === '/repo/.inspecto/settings.local.json') {
+        return { ide: 'trae-cn' }
+      }
+      return null
+    })
+
+    await applyOnboardingPlan({
+      repoRoot: '/repo',
+      projectRoot: '/repo',
+      packageManager: 'pnpm',
+      supportedBuildTargets: [],
+      options: {
+        shared: false,
+        skipInstall: true,
+        dryRun: false,
+        noExtension: true,
+      },
+      selectedIDE: { ide: 'trae-cn', supported: true },
+      providerDefault: 'coco.cli',
+    })
+
+    expect(fsUtils.writeJSON).toHaveBeenCalledWith('/repo/.inspecto/settings.local.json', {
+      ide: 'trae-cn',
+      'provider.default': 'coco.cli',
+    })
+  })
+
+  it('inherits root inspecto defaults when writing package-local settings for a selected subproject', async () => {
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return filePath === '/repo/.inspecto/settings.local.json'
+    })
+    vi.mocked(fsUtils.readJSON).mockImplementation(async filePath => {
+      if (filePath === '/repo/.inspecto/settings.local.json') {
+        return {
+          ide: 'vscode',
+          'provider.default': 'codex.extension',
+        }
+      }
+      return null
+    })
+
+    await applyOnboardingPlan({
+      repoRoot: '/repo',
+      projectRoot: '/repo/finder',
+      packageManager: 'pnpm',
+      supportedBuildTargets: [],
+      options: {
+        shared: false,
+        skipInstall: true,
+        dryRun: false,
+        noExtension: true,
+      },
+      selectedIDE: { ide: 'cursor', supported: true },
+      providerDefault: 'codex.extension',
+    })
+
+    expect(fsUtils.writeJSON).toHaveBeenCalledWith('/repo/finder/.inspecto/settings.local.json', {
+      ide: 'vscode',
+      'provider.default': 'codex.extension',
+    })
+  })
+
   it('prints the same short 3-step success guide when apply finishes cleanly', async () => {
     const context: OnboardingContext = {
       root: '/repo',

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/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()
 

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')
+  })
 })