@inspecto-dev/cli 0.3.3 → 0.3.4

package/dist/index.d.ts

@@ -49,9 +49,14 @@ interface OnboardingContext {
     providers: OnboardingProvider[];
 }
 interface OnboardingTargetCandidate {
+    id?: string;
+    candidateId?: string;
     packagePath: string;
     configPath: string;
+    label?: string;
     buildTool: BuildTool;
+    isLegacyRspack?: boolean;
+    isLegacyWebpack?: boolean;
     frameworks: string[];
     automaticInjection: boolean;
 }
@@ -60,6 +65,8 @@ interface OnboardingTargetResolution {
     selected?: OnboardingTargetCandidate;
     candidates: OnboardingTargetCandidate[];
     reason: string;
+    selectionPurpose?: string;
+    selectionInstructions?: string;
 }
 interface OnboardingSummary {
     headline: string;

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   reportCommandError,
   teardown,
   writeCommandOutput
-} from "./chunk-LJOKPCPD.js";
+} from "./chunk-2MOEVONN.js";
 export {
   apply,
   collectDoctorResult,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inspecto-dev/cli",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "CLI tools for Inspecto onboarding and lifecycle management",
   "keywords": [
     "inspecto",
@@ -20,10 +20,10 @@
     "ora": "^9.3.0",
     "picocolors": "^1.0.0",
     "prompts": "^2.4.2",
-    "@inspecto-dev/types": "0.3.3"
+    "@inspecto-dev/types": "0.3.4"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
+    "@types/node": "^20.19.39",
     "@types/prompts": "^2.4.9",
     "tsup": "^8.0.2",
     "typescript": "^5.4.5",

package/src/bin.ts

@@ -128,7 +128,10 @@ export function createCli(_argv: readonly string[] = process.argv): CAC {
   cli
     .command('onboard', 'Run assistant-oriented Inspecto onboarding in one structured flow')
     .option('--json', 'Print machine-readable JSON output', { default: false })
-    .option('--target <packagePath>', 'Select a monorepo target package explicitly')
+    .option(
+      '--target <candidateIdOrPath>',
+      'Select the build target to onboard using a returned candidateId or compatible config path',
+    )
     .option('--yes', 'Accept a lightweight confirmation gate automatically', { default: false })
     .option('--shared', 'Write shared Inspecto settings instead of local-only settings')
     .option('--skip-install', 'Skip npm dependency installation')

package/src/commands/doctor.ts

@@ -282,6 +282,33 @@ export async function collectDoctorResult(root = process.cwd()): Promise<DoctorR
     const settings = await readJSON(targetPath)
     if (settings) {
       checks.push(createDiagnostic('settings-valid', 'ok', `.inspecto/${fileName} valid`))
+
+      const configuredIde =
+        typeof (settings as Record<string, unknown>).ide === 'string'
+          ? ((settings as Record<string, unknown>).ide as string)
+          : undefined
+      const detectedIdeCandidates = ideProbe.detected.map(item => item.ide)
+      if (
+        configuredIde &&
+        detectedIdeCandidates.length > 0 &&
+        !detectedIdeCandidates.includes(configuredIde)
+      ) {
+        checks.push(
+          createDiagnostic(
+            'settings-ide-mismatch',
+            'warning',
+            `.inspecto/${fileName} sets ide=${configuredIde}, but the current environment looks like ${detectedIdeCandidates.join(', ')}. Inspecto will use the configured IDE from ${fileName}.`,
+            [
+              `Update .inspecto/${fileName} if you want Inspecto to target the currently detected IDE instead.`,
+            ],
+            {
+              configuredIde,
+              detectedIdeCandidates,
+              precedence: `configured ide from ${fileName}`,
+            },
+          ),
+        )
+      }
     } else {
       checks.push(
         createDiagnostic(

package/src/commands/integration-install.ts

@@ -2,10 +2,19 @@ import fs from 'node:fs/promises'
 import { homedir } from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { exists, writeFile } from '../utils/fs.js'
+import { exists, readJSON, writeFile, writeJSON } from '../utils/fs.js'
 import { log } from '../utils/logger.js'
 import { writeCommandOutput } from '../utils/output.js'
 import { runIntegrationAutomation } from './integration-automation.js'
+import { resolveIntegrationDispatchMode } from './integration-dispatch-mode.js'
+import { resolveIntegrationHostIde } from './integration-host-ide.js'
+import { isSupportedHostIde, type SupportedHostIde } from '../integrations/capabilities.js'
+import {
+  DEFAULT_PROVIDER_MODE,
+  VALID_MODES,
+  type Provider,
+  type ProviderMode,
+} from '@inspecto-dev/types'
 
 const REPO_RAW_BASE = 'https://raw.githubusercontent.com/inspecto-dev/inspecto/main'
 const TOTAL_STEPS = 6
@@ -55,6 +64,12 @@ interface InstallPlan {
   nextStep: string
 }
 
+interface InspectoSettingsShape {
+  ide?: string
+  'provider.default'?: string
+  [key: string]: unknown
+}
+
 export interface IntegrationInstallResult {
   status: 'launched' | 'partial' | 'blocked' | 'preview' | 'preview_blocked'
   assistant: string
@@ -117,7 +132,7 @@ const INTEGRATION_MANIFESTS: IntegrationManifest[] = [
   {
     assistant: 'coco',
     type: 'native-skill',
-    installTarget: '.traecli/skills/inspecto-onboarding/',
+    installTarget: '.trae/skills/inspecto-onboarding/',
     preferredInstall:
       'npx @inspecto-dev/cli integrations install coco --host-ide <vscode|cursor|trae|trae-cn>',
     cliSupported: true,
@@ -194,6 +209,10 @@ export async function installIntegration(
     }
   }
 
+  if (shouldPersistProjectOnboardingDefaults(options)) {
+    await persistProjectOnboardingDefaults(assistant as AssistantId, options)
+  }
+
   const stepOneMessage = options.preview
     ? formatIntegrationStep(1, `Previewing ${getAssistantLabel(assistant)} integration assets`)
     : formatIntegrationStep(1, `Installed ${getAssistantLabel(assistant)} integration assets`)
@@ -292,6 +311,70 @@ export async function installIntegration(
   return result
 }
 
+function shouldPersistProjectOnboardingDefaults(
+  options: InstallIntegrationOptions,
+): options is InstallIntegrationOptions & { ide: SupportedHostIde } {
+  return (
+    !options.preview && !shouldSkipAutomationForInstall(options) && isSupportedHostIde(options.ide)
+  )
+}
+
+function isProviderAssistant(value: string): value is Provider {
+  return Object.prototype.hasOwnProperty.call(VALID_MODES, value)
+}
+
+async function resolveProviderDefaultForAssistant(
+  assistant: AssistantId,
+  ide: SupportedHostIde,
+): Promise<string | undefined> {
+  if (!isProviderAssistant(assistant)) {
+    return undefined
+  }
+
+  let mode: ProviderMode | undefined
+  if (assistant === 'codex' || assistant === 'claude-code' || assistant === 'gemini') {
+    const dispatchMode = await resolveIntegrationDispatchMode({ assistant, hostIde: ide })
+    mode = dispatchMode.mode ?? DEFAULT_PROVIDER_MODE[assistant]
+  } else {
+    mode = DEFAULT_PROVIDER_MODE[assistant]
+  }
+
+  if (!mode || !VALID_MODES[assistant].includes(mode)) {
+    return undefined
+  }
+
+  return `${assistant}.${mode}`
+}
+
+async function persistProjectOnboardingDefaults(
+  assistant: AssistantId,
+  options: InstallIntegrationOptions & { ide: SupportedHostIde },
+): Promise<void> {
+  const settingsPath = path.join(process.cwd(), '.inspecto', 'settings.local.json')
+  const existingSettings = await readJSON<InspectoSettingsShape>(settingsPath)
+  const resolvedHostIde = await resolveIntegrationHostIde({
+    explicitIde: options.ide,
+    cwd: process.cwd(),
+  })
+  const providerDefault =
+    resolvedHostIde.ide && resolvedHostIde.confidence !== 'low'
+      ? await resolveProviderDefaultForAssistant(assistant, resolvedHostIde.ide)
+      : undefined
+  const mergedSettings =
+    existingSettings && typeof existingSettings === 'object'
+      ? {
+          ...existingSettings,
+          ide: options.ide,
+          ...(providerDefault ? { 'provider.default': providerDefault } : {}),
+        }
+      : {
+          ide: options.ide,
+          ...(providerDefault ? { 'provider.default': providerDefault } : {}),
+        }
+
+  await writeJSON(settingsPath, mergedSettings)
+}
+
 function shouldSkipAutomationForInstall(options: InstallIntegrationOptions): boolean {
   return options.scope === 'user' && !options.preview
 }
@@ -375,6 +458,12 @@ function resolveInstallPlan(assistant: string, options: InstallIntegrationOption
             target: '.trae/skills/inspecto-onboarding/SKILL.md',
             localSource: 'skills/inspecto-onboarding-trae/SKILL.md',
           },
+          {
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-trae/scripts/run-inspecto.sh`,
+            target: '.trae/skills/inspecto-onboarding/scripts/run-inspecto.sh',
+            localSource: 'skills/inspecto-onboarding-trae/scripts/run-inspecto.sh',
+            executable: true,
+          },
         ],
         successMessage: 'Installed Trae skill to .trae/skills/inspecto-onboarding/SKILL.md',
         nextStep: 'Open a new Trae chat and verify the inspecto-onboarding skill is available.',
@@ -384,11 +473,17 @@ function resolveInstallPlan(assistant: string, options: InstallIntegrationOption
         assets: [
           {
             source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-trae/SKILL.md`,
-            target: '.traecli/skills/inspecto-onboarding/SKILL.md',
+            target: '.trae/skills/inspecto-onboarding/SKILL.md',
             localSource: 'skills/inspecto-onboarding-trae/SKILL.md',
           },
+          {
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-trae/scripts/run-inspecto.sh`,
+            target: '.trae/skills/inspecto-onboarding/scripts/run-inspecto.sh',
+            localSource: 'skills/inspecto-onboarding-trae/scripts/run-inspecto.sh',
+            executable: true,
+          },
         ],
-        successMessage: 'Installed Coco skill to .traecli/skills/inspecto-onboarding/SKILL.md',
+        successMessage: 'Installed Coco skill to .trae/skills/inspecto-onboarding/SKILL.md',
         nextStep: 'Start a new Coco session.',
       }
     default:

package/src/commands/onboard.ts

@@ -39,6 +39,20 @@ function printOnboardResult(result: OnboardCommandResult): void {
   log.info(`Status: ${result.status}`)
   log.info(result.summary.headline)
 
+  if (result.status === 'needs_target_selection') {
+    if (result.target.selectionPurpose) {
+      log.warn(result.target.selectionPurpose)
+    }
+    for (const candidate of result.target.candidates) {
+      const identifier = candidate.candidateId ?? candidate.id ?? candidate.configPath
+      const label = candidate.label ?? candidate.configPath
+      log.hint(`${identifier}: ${label}`)
+    }
+    if (result.target.selectionInstructions) {
+      log.hint(result.target.selectionInstructions)
+    }
+  }
+
   for (const change of result.summary.changes) {
     log.hint(change)
   }

package/src/detect/build-tool.ts

@@ -50,6 +50,37 @@ async function getResolvedPackageVersion(pkgName: string, root: string): Promise
   }
 }
 
+function parseFirstSemver(
+  version: string | null,
+): { major: number; minor: number; patch: number } | null {
+  if (!version) return null
+
+  const match = version.match(/(\d+)\.(\d+)\.(\d+)/)
+  if (!match) {
+    return null
+  }
+
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+  }
+}
+
+function isLegacyRspackVersion(version: string | null): boolean {
+  const parsed = parseFirstSemver(version)
+  if (!parsed) return false
+
+  return parsed.major === 0 && parsed.minor < 4
+}
+
+function isLegacyWebpackVersion(version: string | null): boolean {
+  const parsed = parseFirstSemver(version)
+  if (!parsed) return false
+
+  return parsed.major === 4
+}
+
 /** Supported build tools in v1 */
 const SUPPORTED_PATTERNS: { tool: BuildTool; files: string[]; label: string }[] = [
   {
@@ -76,7 +107,22 @@ const SUPPORTED_PATTERNS: { tool: BuildTool; files: string[]; label: string }[]
   },
   {
     tool: 'webpack',
-    files: ['webpack.config.js', 'webpack.config.ts', 'webpack.config.mjs', 'webpack.config.cjs'],
+    files: [
+      'webpack.config.js',
+      'webpack.config.ts',
+      'webpack.config.mjs',
+      'webpack.config.cjs',
+      'webpack.config.common.js',
+      'webpack.config.common.ts',
+      'webpack.config.dev.js',
+      'webpack.config.dev.ts',
+      'webpack.config.prod.js',
+      'webpack.config.prod.ts',
+      'webpack.config.esbuild.js',
+      'webpack.config.esbuild.ts',
+      'webpack.config.build-pre.js',
+      'webpack.config.build-pre.ts',
+    ],
     label: 'Webpack',
   },
   {
@@ -280,6 +326,119 @@ interface PatternContext {
   scripts: Record<string, string>
 }
 
+function rankScriptCommand(name: string, command: string): number {
+  const haystack = `${name} ${command}`.toLowerCase()
+  let score = 0
+
+  if (/(^|[\s:_-])(start|dev|serve|watch)([\s:_-]|$)/.test(haystack)) score += 8
+  if (/(^|[\s:_-])(prod|build|release|stats)([\s:_-]|$)/.test(haystack)) score -= 3
+  if (/(^|[\s:_-])(dll|vendor)([\s:_-]|$)/.test(haystack)) score -= 6
+  if (haystack.includes('webpack-dev-server')) score += 3
+  if (haystack.includes('webpack')) score += 1
+  if (haystack.includes('rspack')) score += 1
+
+  return score
+}
+
+function extractConfigArgs(scriptContent: string): string[] {
+  return Array.from(scriptContent.matchAll(/(?:-c|--config)\s+([^\s'"`;]+)/g))
+    .map(match => match[1])
+    .filter((value): value is string => Boolean(value))
+}
+
+async function resolveScriptRelativeCandidate(
+  targetRoot: string,
+  scriptPath: string,
+  candidate: string,
+): Promise<string | null> {
+  const normalizedCandidate = candidate.replace(/^['"`]|['"`]$/g, '')
+  const normalizedRelativeCandidate = path.normalize(normalizedCandidate)
+  const possiblePaths: string[] = []
+
+  if (normalizedRelativeCandidate.startsWith('..')) {
+    possiblePaths.push(
+      path.normalize(path.join(path.dirname(scriptPath), normalizedRelativeCandidate)),
+    )
+  } else {
+    possiblePaths.push(normalizedRelativeCandidate)
+    possiblePaths.push(
+      path.normalize(path.join(path.dirname(scriptPath), normalizedRelativeCandidate)),
+    )
+  }
+
+  for (const possiblePath of possiblePaths) {
+    if (await exists(path.join(targetRoot, possiblePath))) {
+      return possiblePath.split(path.sep).join('/')
+    }
+  }
+
+  return null
+}
+
+async function resolveRspackConfigFromScript(
+  targetRoot: string,
+  scriptPath: string,
+): Promise<string | null> {
+  const scriptContent = await readFile(path.join(targetRoot, scriptPath))
+  if (!scriptContent) {
+    return null
+  }
+
+  for (const candidate of extractConfigArgs(scriptContent)) {
+    const resolved = await resolveScriptRelativeCandidate(targetRoot, scriptPath, candidate)
+    if (resolved) {
+      return resolved
+    }
+  }
+
+  const matches = scriptContent.matchAll(
+    /['"`]([^'"`\n]*rspack[^'"`\n]*config[^'"`\n]*\.(?:js|ts|mjs|cjs))['"`]/g,
+  )
+
+  for (const match of matches) {
+    const candidate = match[1]
+    if (!candidate) continue
+    const resolved = await resolveScriptRelativeCandidate(targetRoot, scriptPath, candidate)
+    if (resolved) {
+      return resolved
+    }
+  }
+
+  return null
+}
+
+async function resolveWebpackBaseConfigFromFile(
+  targetRoot: string,
+  configPath: string,
+): Promise<string | null> {
+  const configContent = await readFile(path.join(targetRoot, configPath))
+  if (!configContent) {
+    return null
+  }
+
+  for (const candidate of extractConfigArgs(configContent)) {
+    const resolved = await resolveScriptRelativeCandidate(targetRoot, configPath, candidate)
+    if (resolved) {
+      return resolved
+    }
+  }
+
+  const matches = configContent.matchAll(
+    /(?:configPath\s*=\s*|require\()\s*['"`]([^'"`\n]*webpack[^'"`\n]*config[^'"`\n]*\.(?:js|ts|mjs|cjs))['"`]/g,
+  )
+
+  for (const match of matches) {
+    const candidate = match[1]
+    if (!candidate) continue
+    const resolved = await resolveScriptRelativeCandidate(targetRoot, configPath, candidate)
+    if (resolved) {
+      return resolved
+    }
+  }
+
+  return null
+}
+
 async function detectPattern({
   pattern,
   workspaceRoot,
@@ -339,13 +498,47 @@ async function detectPattern({
       pattern.tool === 'rspack' ||
       pattern.tool === 'rsbuild')
   ) {
-    for (const cmd of Object.values(scripts)) {
+    const rankedScripts = Object.entries(scripts).sort(
+      ([leftName, leftCommand], [rightName, rightCommand]) =>
+        rankScriptCommand(rightName, rightCommand) - rankScriptCommand(leftName, leftCommand),
+    )
+
+    for (const [, cmd] of rankedScripts) {
+      if (pattern.tool === 'webpack' || pattern.tool === 'rspack') {
+        for (const configArg of extractConfigArgs(cmd)) {
+          const resolvedConfig = await resolveScriptRelativeCandidate(targetRoot, '', configArg)
+          if (resolvedConfig && (cmd.includes(pattern.tool) || cmd.includes(`${pattern.tool}-`))) {
+            if (pattern.tool === 'webpack') {
+              detectedFile =
+                (await resolveWebpackBaseConfigFromFile(targetRoot, resolvedConfig)) ??
+                resolvedConfig
+            } else {
+              detectedFile =
+                (await resolveRspackConfigFromScript(targetRoot, resolvedConfig)) ?? resolvedConfig
+            }
+            break
+          }
+        }
+
+        if (detectedFile) {
+          break
+        }
+      }
+
       if (cmd.includes('node ')) {
         const match = cmd.match(/node\s+([^\s]+\.(js|mjs|cjs|ts))/)
         if (match && match[1]) {
           if (await exists(path.join(targetRoot, match[1]))) {
             if (cmd.includes(pattern.tool) || match[1].includes(pattern.tool)) {
-              detectedFile = match[1]
+              if (pattern.tool === 'rspack') {
+                detectedFile =
+                  (await resolveRspackConfigFromScript(targetRoot, match[1])) ?? match[1]
+              } else if (pattern.tool === 'webpack') {
+                detectedFile =
+                  (await resolveWebpackBaseConfigFromFile(targetRoot, match[1])) ?? match[1]
+              } else {
+                detectedFile = match[1]
+              }
               break
             }
           }
@@ -393,16 +586,11 @@ async function detectPattern({
   let isLegacyWebpack = false
 
   if (pattern.tool === 'rspack') {
-    const version = resolvedVersion
-    if (
-      version &&
-      (version.includes('0.3.') || version.includes('0.2.') || version.includes('0.1.'))
-    ) {
+    if (isLegacyRspackVersion(resolvedVersion)) {
       isLegacyRspack = true
     }
   } else if (pattern.tool === 'webpack') {
-    const version = resolvedVersion
-    if ((version && version.includes('^4')) || version?.startsWith('4.')) {
+    if (isLegacyWebpackVersion(resolvedVersion)) {
       isLegacyWebpack = true
     }
   }