@inspecto-dev/cli 0.3.3 → 0.3.5

package/src/commands/integration-host-ide.ts

@@ -12,6 +12,7 @@ export type HostIdeSource = 'explicit' | 'config' | 'env' | 'artifact' | 'ambigu
 export interface ResolveIntegrationHostIdeOptions {
   explicitIde?: string
   cwd?: string
+  ignoreProjectArtifacts?: boolean
 }
 
 export interface ResolvedIntegrationHostIde {
@@ -51,7 +52,7 @@ export async function resolveIntegrationHostIde(
   const envCandidates = detectEnvHostIdes()
   if (envCandidates.length === 1) {
     return {
-      ide: envCandidates[0],
+      ide: envCandidates[0]!,
       confidence: 'high',
       source: 'env',
       candidates: envCandidates,
@@ -67,22 +68,24 @@ export async function resolveIntegrationHostIde(
     }
   }
 
-  const artifactCandidates = await detectArtifactHostIdes(cwd)
-  if (artifactCandidates.length === 1) {
-    return {
-      ide: artifactCandidates[0],
-      confidence: 'medium',
-      source: 'artifact',
-      candidates: artifactCandidates,
+  if (!options.ignoreProjectArtifacts) {
+    const artifactCandidates = await detectArtifactHostIdes(cwd)
+    if (artifactCandidates.length === 1) {
+      return {
+        ide: artifactCandidates[0]!,
+        confidence: 'medium',
+        source: 'artifact',
+        candidates: artifactCandidates,
+      }
     }
-  }
 
-  if (artifactCandidates.length > 1) {
-    return {
-      ide: null,
-      confidence: 'low',
-      source: 'ambiguous',
-      candidates: artifactCandidates,
+    if (artifactCandidates.length > 1) {
+      return {
+        ide: null,
+        confidence: 'low',
+        source: 'ambiguous',
+        candidates: artifactCandidates,
+      }
     }
   }
 

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`)
@@ -247,7 +266,7 @@ export async function installIntegration(
 
   const automationResult = await runIntegrationAutomation(
     assistant,
-    { ...options, silent },
+    { ...options, silent, ignoreProjectArtifacts: true },
     process.cwd(),
   )
   const result: IntegrationInstallResult = {
@@ -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

@@ -5,7 +5,7 @@ import {
 } from '../onboarding/session.js'
 import { log } from '../utils/logger.js'
 import { writeCommandOutput } from '../utils/output.js'
-import type { OnboardCommandResult } from '../types.js'
+import type { OnboardCommandResult, OnboardingAssistantHandoff } from '../types.js'
 
 export interface OnboardCommandOptions {
   json?: boolean
@@ -34,33 +34,98 @@ function printManualExtensionGuidance(result: OnboardCommandResult): void {
   }
 }
 
+function buildAssistantHandoff(
+  result: OnboardCommandResult,
+): OnboardingAssistantHandoff | undefined {
+  if (
+    !result.framework &&
+    !result.metaFramework &&
+    !result.routerMode &&
+    !result.autoApplied &&
+    !result.pendingSteps &&
+    !result.assistantPrompt &&
+    !result.patches
+  ) {
+    return result.handoff
+  }
+
+  return {
+    ...(result.framework ? { framework: result.framework } : {}),
+    ...(result.metaFramework ? { metaFramework: result.metaFramework } : {}),
+    ...(result.routerMode ? { routerMode: result.routerMode } : {}),
+    ...(result.autoApplied ? { autoApplied: result.autoApplied } : {}),
+    ...(result.pendingSteps ? { pendingSteps: result.pendingSteps } : {}),
+    ...(result.assistantPrompt ? { assistantPrompt: result.assistantPrompt } : {}),
+    ...(result.patches ? { patches: result.patches } : {}),
+  }
+}
+
+function normalizeOnboardResult(result: OnboardCommandResult): OnboardCommandResult {
+  const handoff = buildAssistantHandoff(result)
+  if (!handoff) {
+    return result
+  }
+
+  return {
+    ...result,
+    handoff,
+  }
+}
+
+function collectDisplayNextSteps(result: OnboardCommandResult): string[] {
+  return Array.from(
+    new Set([...(result.diagnostics?.nextSteps ?? []), ...(result.handoff?.pendingSteps ?? [])]),
+  )
+}
+
 function printOnboardResult(result: OnboardCommandResult): void {
+  const normalized = normalizeOnboardResult(result)
   log.header('Inspecto Onboard')
-  log.info(`Status: ${result.status}`)
-  log.info(result.summary.headline)
+  log.info(`Status: ${normalized.status}`)
+  log.info(normalized.summary.headline)
 
-  for (const change of result.summary.changes) {
+  if (normalized.status === 'needs_target_selection') {
+    if (normalized.target.selectionPurpose) {
+      log.warn(normalized.target.selectionPurpose)
+    }
+    for (const candidate of normalized.target.candidates) {
+      const identifier = candidate.candidateId ?? candidate.id ?? candidate.configPath
+      const label = candidate.label ?? candidate.configPath
+      log.hint(`${identifier}: ${label}`)
+    }
+    if (normalized.target.selectionInstructions) {
+      log.hint(normalized.target.selectionInstructions)
+    }
+  }
+
+  for (const change of normalized.summary.changes) {
     log.hint(change)
   }
-  for (const step of result.diagnostics?.nextSteps ?? []) {
+  for (const step of collectDisplayNextSteps(normalized)) {
     log.warn(step)
   }
-  if (result.confirmation.required && result.confirmation.question) {
-    log.warn(result.confirmation.question)
+  for (const patch of normalized.handoff?.patches ?? []) {
+    log.hint(`Patch target: ${patch.path} (${patch.reason})`)
+  }
+  if (normalized.handoff?.assistantPrompt) {
+    log.hint(normalized.handoff.assistantPrompt)
+  }
+  if (normalized.confirmation.required && normalized.confirmation.question) {
+    log.warn(normalized.confirmation.question)
   }
 
-  printManualExtensionGuidance(result)
+  printManualExtensionGuidance(normalized)
 
   const extensionReady =
-    !result.ideExtension?.required ||
-    (result.ideExtension.installed && !result.ideExtension.manualRequired)
+    !normalized.ideExtension?.required ||
+    (normalized.ideExtension.installed && !normalized.ideExtension.manualRequired)
 
   if (
     extensionReady &&
-    (result.status === 'success' || result.status === 'partial_success') &&
-    result.verification?.message
+    (normalized.status === 'success' || normalized.status === 'partial_success') &&
+    normalized.verification?.message
   ) {
-    log.info(result.verification.message)
+    log.info(normalized.verification.message)
   }
 }
 
@@ -74,12 +139,12 @@ export async function onboard(options: OnboardCommandOptions = {}): Promise<Onbo
     session.status === 'needs_confirmation'
   ) {
     return writeCommandOutput(
-      buildDeferredOnboardResult(session),
+      normalizeOnboardResult(buildDeferredOnboardResult(session)),
       options.json ?? false,
       printOnboardResult,
     )
   }
 
-  const result = await applyResolvedOnboardingSession(session, options)
+  const result = normalizeOnboardResult(await applyResolvedOnboardingSession(session, options))
   return writeCommandOutput(result, options.json ?? false, printOnboardResult)
 }

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',
   },
   {
@@ -93,6 +139,11 @@ const SUPPORTED_PATTERNS: { tool: BuildTool; files: string[]; label: string }[]
 
 /** Recognized but unsupported meta-frameworks — detect via dep + config file */
 const UNSUPPORTED_META: { name: string; dep: string; files: string[] }[] = [
+  {
+    name: 'Umi',
+    dep: 'umi',
+    files: ['.umirc.ts', '.umirc.js', 'config/config.ts', 'config/config.js'],
+  },
   { name: 'Next.js', dep: 'next', files: ['next.config.mjs', 'next.config.js', 'next.config.ts'] },
   { name: 'Nuxt', dep: 'nuxt', files: ['nuxt.config.ts', 'nuxt.config.js'] },
   { name: 'Remix', dep: '@remix-run/dev', files: ['remix.config.js', 'remix.config.ts'] },
@@ -251,7 +302,9 @@ export async function detectBuildTools(
     }
 
     const unsupportedChecks = UNSUPPORTED_META.map(async meta => {
-      if (!(meta.dep in allDeps)) return null
+      // Check if any dependency matches (supports exact match or scoped packages if necessary, but here we do exact match)
+      const hasDep = meta.dep in allDeps || Object.keys(allDeps).some(dep => dep.includes(meta.dep))
+      if (!hasDep) return null
       for (const file of meta.files) {
         if (await exists(path.join(target.absolutePath, file))) {
           return meta.name
@@ -280,6 +333,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,
@@ -312,6 +478,8 @@ async function detectPattern({
     }
   } else if (pattern.tool === 'rsbuild') {
     hasDep = !!allDeps['@rsbuild/core'] || isPackageResolvable('@rsbuild/core', targetRoot)
+  } else if (pattern.tool === 'vite') {
+    hasDep = !!allDeps['vite'] || isPackageResolvable('vite', targetRoot)
   } else {
     hasDep = !!allDeps[pattern.tool] || isPackageResolvable(pattern.tool, targetRoot)
   }
@@ -339,13 +507,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
             }
           }
@@ -383,7 +585,7 @@ async function detectPattern({
         tool: pattern.tool,
         configPath: 'package.json (dependency)',
         label: `${pattern.label} (detected via dependency)`,
-        packagePath: packagePath || undefined,
+        ...(packagePath ? { packagePath } : {}),
       }
     }
     return null
@@ -393,16 +595,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
     }
   }
@@ -416,9 +613,9 @@ async function detectPattern({
     label: `${pattern.label} (${relativeConfig})${isLegacyRspack ? ' [Legacy]' : ''}${
       isLegacyWebpack ? ' [Webpack 4]' : ''
     }${inferredFromScripts ? ' [Scripts Detected]' : ''}`,
-    isLegacyRspack,
-    isLegacyWebpack,
-    packagePath: packagePath || undefined,
+    ...(isLegacyRspack ? { isLegacyRspack: true } : {}),
+    ...(isLegacyWebpack ? { isLegacyWebpack: true } : {}),
+    ...(packagePath ? { packagePath } : {}),
   }
 }
 

package/src/detect/framework.ts

@@ -44,9 +44,12 @@ const SUPPORTED_FRAMEWORKS: { framework: Framework; deps: string[] }[] = [
 const UNSUPPORTED_FRAMEWORKS: { name: string; dep: string }[] = [
   { name: 'Solid', dep: 'solid-js' },
   { name: 'Svelte', dep: 'svelte' },
+  { name: 'SvelteKit', dep: '@sveltejs/kit' },
   { name: 'Angular', dep: '@angular/core' },
   { name: 'Preact', dep: 'preact' },
   { name: 'Lit', dep: 'lit' },
+  { name: 'Qwik', dep: 'qwik' },
+  { name: 'Alpine', dep: 'lit-html' },
 ]
 
 /**

package/src/detect/package-manager.ts

@@ -14,8 +14,8 @@ export async function detectPackageManager(root: string): Promise<PackageManager
     ['bun.lockb', 'bun'],
     ['bun.lock', 'bun'],
     ['pnpm-lock.yaml', 'pnpm'],
-    ['yarn.lock', 'yarn'],
     ['package-lock.json', 'npm'],
+    ['yarn.lock', 'yarn'],
   ]
 
   const results = await Promise.all(

package/src/index.ts

@@ -1,5 +1,6 @@
 export { apply } from './commands/apply.js'
 export { detect } from './commands/detect.js'
+export { devLink, devStatus, devUnlink } from './commands/dev-config.js'
 export { init } from './commands/init.js'
 export { collectDoctorResult, doctor } from './commands/doctor.js'
 export { integrationDoctor } from './commands/integration-doctor.js'