npm - @inspecto-dev/cli - Versions diffs - 0.3.4 → 0.3.6 - Mend

@inspecto-dev/cli 0.3.4 → 0.3.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

package/.turbo/turbo-build.log +7 -7
package/.turbo/turbo-test.log +205 -7275
package/CHANGELOG.md +14 -0
package/dist/bin.js +32 -1
package/dist/{chunk-2MOEVONN.js → chunk-7ABJRH3F.js} +1232 -145
package/dist/index.d.ts +62 -4
package/dist/index.js +7 -1
package/package.json +2 -2
package/src/bin.ts +45 -0
package/src/commands/dev-config.ts +109 -0
package/src/commands/doctor.ts +162 -9
package/src/commands/init.ts +10 -3
package/src/commands/integration-automation.ts +2 -0
package/src/commands/integration-host-ide.ts +18 -15
package/src/commands/integration-install.ts +1 -1
package/src/commands/onboard.ts +72 -21
package/src/detect/build-tool.ts +14 -5
package/src/detect/framework.ts +3 -0
package/src/detect/package-manager.ts +1 -1
package/src/index.ts +1 -0
package/src/inject/gitignore.ts +13 -2
package/src/instructions.ts +33 -7
package/src/onboarding/apply.ts +137 -3
package/src/onboarding/nextjs-guidance.ts +257 -0
package/src/onboarding/nuxt-guidance.ts +129 -0
package/src/onboarding/planner.ts +257 -6
package/src/onboarding/session.ts +117 -27
package/src/onboarding/target-resolution.ts +3 -3
package/src/onboarding/umi-guidance.ts +139 -0
package/src/types.ts +51 -3
package/tests/apply.test.ts +319 -0
package/tests/dev-config.test.ts +73 -0
package/tests/doctor.test.ts +89 -0
package/tests/init.test.ts +17 -0
package/tests/instructions.test.ts +10 -6
package/tests/integration-host-ide.test.ts +20 -0
package/tests/integration-install.test.ts +65 -0
package/tests/nextjs-guidance.test.ts +128 -0
package/tests/nuxt-guidance.test.ts +67 -0
package/tests/onboard.test.ts +416 -0
package/tests/plan.test.ts +181 -21
package/tests/runner-script.test.ts +120 -1
package/tests/session-resolve.test.ts +116 -0
package/tests/session.test.ts +120 -0

package/src/onboarding/nextjs-guidance.ts ADDED Viewed

@@ -0,0 +1,257 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { OnboardingPatchPlan } from '../types.js'
+type RouterMode = 'app' | 'pages' | 'mixed' | 'unknown'
+export interface NextJsGuidance {
+  framework: 'react'
+  metaFramework: 'Next.js'
+  routerMode: RouterMode
+  autoApplied: string[]
+  pendingSteps: string[]
+  assistantPrompt: string
+  patches: OnboardingPatchPlan[]
+}
+const NEXT_CONFIG_CANDIDATES = ['next.config.ts', 'next.config.mjs', 'next.config.js'] as const
+const APP_ROUTER_LAYOUTS = [
+  'app/layout.tsx',
+  'app/layout.jsx',
+  'src/app/layout.tsx',
+  'src/app/layout.jsx',
+] as const
+const PAGES_ROUTER_APPS = [
+  'pages/_app.tsx',
+  'pages/_app.jsx',
+  'src/pages/_app.tsx',
+  'src/pages/_app.jsx',
+] as const
+const PACKAGE_JSON_PATH = 'package.json'
+function findFirstExisting(root: string, candidates: readonly string[]): string | undefined {
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(root, candidate))) {
+      return candidate
+    }
+  }
+  return undefined
+}
+function detectRouterMode(root: string): RouterMode {
+  const hasAppRouter = Boolean(findFirstExisting(root, APP_ROUTER_LAYOUTS))
+  const hasPagesRouter = Boolean(findFirstExisting(root, PAGES_ROUTER_APPS))
+  if (hasAppRouter && hasPagesRouter) return 'mixed'
+  if (hasAppRouter) return 'app'
+  if (hasPagesRouter) return 'pages'
+  return 'unknown'
+}
+function detectNextConfigPath(root: string): string | undefined {
+  return findFirstExisting(root, NEXT_CONFIG_CANDIDATES)
+}
+function readConfig(root: string, relativePath?: string): string {
+  if (!relativePath) return ''
+  const filePath = path.join(root, relativePath)
+  if (!fs.existsSync(filePath)) return ''
+  return fs.readFileSync(filePath, 'utf8')
+}
+function detectPatchShape(source: string): {
+  status: OnboardingPatchPlan['status']
+  reason: OnboardingPatchPlan['reason']
+  confidence: OnboardingPatchPlan['confidence']
+} {
+  if (
+    /export\s+default\s*\{[\s\S]*\}/m.test(source) ||
+    /module\.exports\s*=\s*\{[\s\S]*\}/m.test(source) ||
+    /const\s+[A-Za-z0-9_$]+\s*(?::[^=]+)?=\s*\{[\s\S]*\}\s*;?\s*export\s+default\s+[A-Za-z0-9_$]+\s*;?/m.test(
+      source,
+    ) ||
+    /\/\*\*[\s\S]*?@type\s*\{import\('next'\)\.NextConfig\}[\s\S]*?\*\/[\s\S]*?(export\s+default|module\.exports)\s*=?\s*\{[\s\S]*\}/m.test(
+      source,
+    )
+  ) {
+    return {
+      status: 'planned',
+      reason: 'next_config_object_export',
+      confidence: 'high',
+    }
+  }
+  if (
+    /module\.exports\s*=\s*[A-Za-z0-9_$]+\s*\(/m.test(source) ||
+    /export\s+default\s+[A-Za-z0-9_$]+\s*\(/m.test(source)
+  ) {
+    return {
+      status: 'manual_patch_required',
+      reason: 'next_config_wrapped_export',
+      confidence: 'medium',
+    }
+  }
+  if (source.trim().length === 0) {
+    return {
+      status: 'manual_patch_required',
+      reason: 'next_config_missing',
+      confidence: 'low',
+    }
+  }
+  return {
+    status: 'manual_patch_required',
+    reason: 'next_config_complex_shape',
+    confidence: 'medium',
+  }
+}
+function buildPatchSnippet(): string {
+  return [
+    "import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'",
+    '',
+    'webpack(config, { dev, isServer }) {',
+    '  if (dev) {',
+    '    config.plugins.push(inspecto())',
+    '  }',
+    '  return config',
+    '}',
+  ].join('\n')
+}
+function buildAppRouterMountSnippet(): string {
+  return [
+    "import { useEffect } from 'react'",
+    '',
+    'function InspectoProvider() {',
+    '  useEffect(() => {',
+    "    if (process.env.NODE_ENV !== 'production') {",
+    "      import('@inspecto-dev/core').then(({ mountInspector }) => {",
+    '        mountInspector()',
+    '      })',
+    '    }',
+    '  }, [])',
+    '',
+    '  return null',
+    '}',
+    '',
+    'Render <InspectoProvider /> from app/layout.tsx inside the <body> tree.',
+  ].join('\n')
+}
+function buildPagesRouterMountSnippet(): string {
+  return [
+    "import { useEffect } from 'react'",
+    '',
+    'useEffect(() => {',
+    "  if (process.env.NODE_ENV !== 'production') {",
+    "    import('@inspecto-dev/core').then(({ mountInspector }) => {",
+    '      mountInspector()',
+    '    })',
+    '  }',
+    '}, [])',
+    '',
+    'Add this effect to pages/_app.tsx without changing the existing app wrapper behavior.',
+  ].join('\n')
+}
+function detectWebpackDevScriptPatch(root: string): OnboardingPatchPlan | undefined {
+  const packageJsonSource = readConfig(root, PACKAGE_JSON_PATH)
+  if (!packageJsonSource) {
+    return undefined
+  }
+  try {
+    const packageJson = JSON.parse(packageJsonSource) as { scripts?: Record<string, string> }
+    const devScript = packageJson.scripts?.dev
+    if (!devScript || !/\bnext\s+dev\b/.test(devScript) || /--webpack\b/.test(devScript)) {
+      return undefined
+    }
+    return {
+      path: PACKAGE_JSON_PATH,
+      status: 'manual_patch_required',
+      reason: 'next_dev_script_requires_webpack',
+      confidence: 'medium',
+      snippet: '"dev": "next dev --webpack"',
+    }
+  } catch {
+    return undefined
+  }
+}
+function buildPendingSteps(
+  routerMode: RouterMode,
+  configPath: string,
+  needsWebpackDevScript: boolean,
+): string[] {
+  const routerHint =
+    routerMode === 'app'
+      ? 'Complete the remaining client-side mount step for your App Router entry.'
+      : routerMode === 'pages'
+        ? 'Complete the remaining client-side mount step for your Pages Router entry.'
+        : routerMode === 'mixed'
+          ? 'Complete the remaining client-side mount step for the router entry your team actually uses in development.'
+          : 'Complete the remaining client-side mount step in the appropriate Next.js entry file.'
+  return [
+    `Review the generated Next.js patch plan for ${configPath}.`,
+    ...(needsWebpackDevScript
+      ? ['Update the Next.js dev script to use webpack mode for Inspecto validation.']
+      : []),
+    'Keep the Inspecto webpack plugin enabled for both server and client development compilers in App Router projects.',
+    routerHint,
+  ]
+}
+export function createNextJsGuidance(root: string): NextJsGuidance {
+  const configPath = detectNextConfigPath(root) ?? 'next.config.js'
+  const configSource = readConfig(root, detectNextConfigPath(root))
+  const patchShape = detectPatchShape(configSource)
+  const routerMode = detectRouterMode(root)
+  const webpackDevScriptPatch = detectWebpackDevScriptPatch(root)
+  return {
+    framework: 'react',
+    metaFramework: 'Next.js',
+    routerMode,
+    autoApplied: ['dependencies', 'inspecto_settings'],
+    pendingSteps: buildPendingSteps(routerMode, configPath, Boolean(webpackDevScriptPatch)),
+    assistantPrompt:
+      'Complete the remaining Inspecto onboarding for this Next.js project. Use the generated patches directly, keep existing app behavior unchanged, avoid unrelated documentation searches unless a patch is insufficient, and finish the client-side mount step safely.',
+    patches: [
+      {
+        path: configPath,
+        status: patchShape.status,
+        reason: patchShape.reason,
+        confidence: patchShape.confidence,
+        snippet: buildPatchSnippet(),
+      },
+      ...(routerMode === 'app' || routerMode === 'mixed'
+        ? [
+            {
+              path: findFirstExisting(root, APP_ROUTER_LAYOUTS) ?? 'app/layout.tsx',
+              status: 'manual_patch_required' as const,
+              reason: 'next_app_router_mount',
+              confidence: 'medium' as const,
+              snippet: buildAppRouterMountSnippet(),
+            },
+          ]
+        : []),
+      ...(routerMode === 'pages' || routerMode === 'mixed'
+        ? [
+            {
+              path: findFirstExisting(root, PAGES_ROUTER_APPS) ?? 'pages/_app.tsx',
+              status: 'manual_patch_required' as const,
+              reason: 'next_pages_router_mount',
+              confidence: 'medium' as const,
+              snippet: buildPagesRouterMountSnippet(),
+            },
+          ]
+        : []),
+      ...(webpackDevScriptPatch ? [webpackDevScriptPatch] : []),
+    ],
+  }
+}

package/src/onboarding/nuxt-guidance.ts ADDED Viewed

@@ -0,0 +1,129 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { OnboardingPatchPlan } from '../types.js'
+export interface NuxtGuidance {
+  framework: 'vue'
+  metaFramework: 'Nuxt'
+  autoApplied: string[]
+  pendingSteps: string[]
+  assistantPrompt: string
+  patches: OnboardingPatchPlan[]
+}
+const NUXT_CONFIG_CANDIDATES = ['nuxt.config.ts', 'nuxt.config.js'] as const
+function findFirstExisting(root: string, candidates: readonly string[]): string | undefined {
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(root, candidate))) {
+      return candidate
+    }
+  }
+  return undefined
+}
+function readConfig(root: string, relativePath?: string): string {
+  if (!relativePath) return ''
+  const filePath = path.join(root, relativePath)
+  if (!fs.existsSync(filePath)) return ''
+  return fs.readFileSync(filePath, 'utf8')
+}
+function detectPatchShape(source: string): {
+  status: OnboardingPatchPlan['status']
+  reason: OnboardingPatchPlan['reason']
+  confidence: OnboardingPatchPlan['confidence']
+} {
+  if (/with[A-Za-z0-9_$]*\s*\(\s*defineNuxtConfig/m.test(source)) {
+    return {
+      status: 'manual_patch_required',
+      reason: 'nuxt_config_wrapped_export',
+      confidence: 'medium',
+    }
+  }
+  if (/defineNuxtConfig\s*\(\s*\{[\s\S]*\}\s*\)/m.test(source)) {
+    return {
+      status: 'planned',
+      reason: 'nuxt_config_object_export',
+      confidence: 'high',
+    }
+  }
+  if (source.trim().length === 0) {
+    return {
+      status: 'manual_patch_required',
+      reason: 'nuxt_config_missing',
+      confidence: 'low',
+    }
+  }
+  return {
+    status: 'manual_patch_required',
+    reason: 'nuxt_config_complex_shape',
+    confidence: 'medium',
+  }
+}
+function buildNuxtConfigSnippet(): string {
+  return [
+    "import { vitePlugin as inspecto } from '@inspecto-dev/plugin'",
+    '',
+    'export default defineNuxtConfig({',
+    '  vite: {',
+    '    plugins: [inspecto()],',
+    '  },',
+    '})',
+  ].join('\n')
+}
+function buildNuxtPluginSnippet(): string {
+  return [
+    'export default defineNuxtPlugin(() => {',
+    '  if (import.meta.dev) {',
+    "    import('@inspecto-dev/core').then(({ mountInspector }) => {",
+    '      mountInspector()',
+    '    })',
+    '  }',
+    '})',
+  ].join('\n')
+}
+export function createNuxtGuidance(root: string): NuxtGuidance {
+  const configPath = findFirstExisting(root, NUXT_CONFIG_CANDIDATES) ?? 'nuxt.config.ts'
+  const configSource = readConfig(root, findFirstExisting(root, NUXT_CONFIG_CANDIDATES))
+  const patchShape = detectPatchShape(configSource)
+  const hasSrcDir =
+    fs.existsSync(path.join(root, 'src')) && fs.statSync(path.join(root, 'src')).isDirectory()
+  const pluginPath = hasSrcDir ? 'src/plugins/inspecto.client.ts' : 'plugins/inspecto.client.ts'
+  return {
+    framework: 'vue',
+    metaFramework: 'Nuxt',
+    autoApplied: ['dependencies', 'inspecto_settings'],
+    pendingSteps: [
+      `Review the generated Nuxt patch plan for ${configPath}.`,
+      `Complete the remaining Nuxt client plugin mount step in ${pluginPath}.`,
+    ],
+    assistantPrompt:
+      'Complete the remaining Inspecto onboarding for this Nuxt project. Review the generated patch plan, keep existing app behavior unchanged, and finish the client plugin mount step safely.',
+    patches: [
+      {
+        path: configPath,
+        status: patchShape.status,
+        reason: patchShape.reason,
+        confidence: patchShape.confidence,
+        snippet: buildNuxtConfigSnippet(),
+      },
+      {
+        path: pluginPath,
+        status: 'manual_patch_required',
+        reason: 'nuxt_client_plugin_mount',
+        confidence: 'medium',
+        snippet: buildNuxtPluginSnippet(),
+      },
+    ],
+  }
+}

package/src/onboarding/planner.ts CHANGED Viewed

@@ -1,4 +1,8 @@
 import { buildOnboardingContext } from './context.js'
+import { getHostIdeLabel, isSupportedHostIde } from '../integrations/capabilities.js'
+import { createNextJsGuidance } from './nextjs-guidance.js'
+import { createNuxtGuidance } from './nuxt-guidance.js'
+import { createUmiGuidance } from './umi-guidance.js'
 import type {
   CommandMessage,
   CommandStatus,
@@ -37,11 +41,19 @@ function supportedIde(context: OnboardingContext): string | undefined {
   return context.ides.find(ide => ide.supported)?.ide
 }
+function shouldInstallInspectoExtension(ide?: string): boolean {
+  return Boolean(ide && isSupportedHostIde(ide))
+}
 function supportedProvider(context: OnboardingContext): string | undefined {
   return context.providers.find(provider => provider.supported)?.id
 }
 function buildToolBlockers(context: OnboardingContext): CommandMessage[] {
+  if (isGuidedMetaFrameworkScenario(context)) {
+    return []
+  }
   if (context.buildTools.unsupported.length > 0) {
     return [
       message(
@@ -214,6 +226,77 @@ function manualBuildToolActions(context: OnboardingContext): PlanResult['actions
   ]
 }
+function hasUnsupportedBuildTool(context: OnboardingContext, buildTool: string): boolean {
+  return context.buildTools.unsupported.includes(buildTool)
+}
+function isGuidedNextJsScenario(context: OnboardingContext): boolean {
+  return (
+    context.buildTools.supported.length === 0 &&
+    hasUnsupportedBuildTool(context, 'Next.js') &&
+    context.frameworks.supported.includes('react')
+  )
+}
+function isGuidedNuxtScenario(context: OnboardingContext): boolean {
+  return (
+    context.buildTools.supported.length === 0 &&
+    hasUnsupportedBuildTool(context, 'Nuxt') &&
+    context.frameworks.supported.includes('vue')
+  )
+}
+function isGuidedUmiScenario(context: OnboardingContext): boolean {
+  return hasUnsupportedBuildTool(context, 'Umi') && context.frameworks.supported.includes('react')
+}
+function isGuidedMetaFrameworkScenario(context: OnboardingContext): boolean {
+  return (
+    isGuidedNextJsScenario(context) || isGuidedNuxtScenario(context) || isGuidedUmiScenario(context)
+  )
+}
+function guidedBuildToolWarnings(
+  context: OnboardingContext,
+  guidedBuildTool: string,
+): CommandMessage[] {
+  return context.buildTools.unsupported
+    .filter(buildTool => buildTool !== guidedBuildTool)
+    .map(buildTool =>
+      message(
+        'additional-unsupported-build-tool',
+        `Additional unsupported build tool also detected: ${buildTool}`,
+      ),
+    )
+}
+function guidedFrameworkWarnings(context: OnboardingContext, framework: string): CommandMessage[] {
+  return context.frameworks.unsupported
+    .filter(item => item !== framework)
+    .map(item =>
+      message(
+        'additional-unsupported-framework',
+        `Additional unsupported framework also detected: ${item}`,
+      ),
+    )
+}
+function buildGuidedWarnings(
+  context: OnboardingContext,
+  guidedBuildTool: string,
+  guidedFramework: string,
+): CommandMessage[] {
+  return uniqueMessages([
+    ...guidedBuildToolWarnings(context, guidedBuildTool),
+    ...guidedFrameworkWarnings(context, guidedFramework),
+    ...unsupportedEnvironmentWarnings(context),
+  ]).filter(
+    warning =>
+      warning.message !==
+      `Unsupported framework(s) also detected: ${context.frameworks.unsupported.join(', ')}`,
+  )
+}
 function manualFrameworkActions(context: OnboardingContext): PlanResult['actions'] {
   if (context.frameworks.unsupported.length > 0) {
     return [
@@ -267,6 +350,170 @@ export async function createDetectionResult(root: string): Promise<DetectionResu
 }
 export function createPlanResult(context: OnboardingContext): PlanResult {
+  if (isGuidedNextJsScenario(context)) {
+    const ide = supportedIde(context)
+    const provider = supportedProvider(context)
+    const guidance = createNextJsGuidance(context.root)
+    const actions: PlanResult['actions'] = [
+      {
+        type: 'install_dependency',
+        target: '@inspecto-dev/plugin @inspecto-dev/core',
+        description: `Install the Inspecto runtime packages with ${context.packageManager}.`,
+      },
+    ]
+    if (shouldInstallInspectoExtension(ide) && ide) {
+      actions.push({
+        type: 'install_extension',
+        target: ide,
+        description: `Install the Inspecto ${getHostIdeLabel(ide as Parameters<typeof getHostIdeLabel>[0])} extension.`,
+      })
+    }
+    actions.push(
+      {
+        type: 'generate_patch_plan',
+        target: 'next.config',
+        description: 'Generate a guided patch plan for the Next.js Inspecto webpack integration.',
+      },
+      {
+        type: 'manual_confirmation',
+        target: context.root,
+        description:
+          'Complete the remaining client-side Inspecto mount step in your assistant or editor.',
+      },
+    )
+    const defaults: PlanResult['defaults'] = {
+      shared: false,
+      extension: shouldInstallInspectoExtension(ide),
+      ...(provider ? { provider } : {}),
+      ...(ide ? { ide } : {}),
+    }
+    return {
+      status: 'warning',
+      warnings: buildGuidedWarnings(context, 'Next.js', 'react'),
+      blockers: [],
+      strategy: 'guided',
+      actions,
+      defaults,
+      framework: guidance.framework,
+      metaFramework: guidance.metaFramework,
+      routerMode: guidance.routerMode,
+      autoApplied: guidance.autoApplied,
+      pendingSteps: guidance.pendingSteps,
+      assistantPrompt: guidance.assistantPrompt,
+      patches: guidance.patches,
+    }
+  }
+  if (isGuidedNuxtScenario(context)) {
+    const ide = supportedIde(context)
+    const provider = supportedProvider(context)
+    const guidance = createNuxtGuidance(context.root)
+    const actions: PlanResult['actions'] = [
+      {
+        type: 'install_dependency',
+        target: '@inspecto-dev/plugin @inspecto-dev/core',
+        description: `Install the Inspecto runtime packages with ${context.packageManager}.`,
+      },
+    ]
+    if (shouldInstallInspectoExtension(ide) && ide) {
+      actions.push({
+        type: 'install_extension',
+        target: ide,
+        description: `Install the Inspecto ${getHostIdeLabel(ide as Parameters<typeof getHostIdeLabel>[0])} extension.`,
+      })
+    }
+    actions.push(
+      {
+        type: 'generate_patch_plan',
+        target: 'nuxt.config',
+        description: 'Generate a guided patch plan for the Nuxt Inspecto Vite integration.',
+      },
+      {
+        type: 'manual_confirmation',
+        target: context.root,
+        description:
+          'Complete the remaining Nuxt client plugin mount step in your assistant or editor.',
+      },
+    )
+    const defaults: PlanResult['defaults'] = {
+      shared: false,
+      extension: shouldInstallInspectoExtension(ide),
+      ...(provider ? { provider } : {}),
+      ...(ide ? { ide } : {}),
+    }
+    return {
+      status: 'warning',
+      warnings: buildGuidedWarnings(context, 'Nuxt', 'vue'),
+      blockers: [],
+      strategy: 'guided',
+      actions,
+      defaults,
+      framework: guidance.framework,
+      metaFramework: guidance.metaFramework,
+      autoApplied: guidance.autoApplied,
+      pendingSteps: guidance.pendingSteps,
+      assistantPrompt: guidance.assistantPrompt,
+      patches: guidance.patches,
+    }
+  }
+  if (isGuidedUmiScenario(context)) {
+    const ide = supportedIde(context)
+    const provider = supportedProvider(context)
+    const guidance = createUmiGuidance(context.root)
+    const actions: PlanResult['actions'] = [
+      {
+        type: 'install_dependency',
+        target: '@inspecto-dev/plugin @inspecto-dev/core',
+        description: `Install the Inspecto runtime packages with ${context.packageManager}.`,
+      },
+    ]
+    if (shouldInstallInspectoExtension(ide) && ide) {
+      actions.push({
+        type: 'install_extension',
+        target: ide,
+        description: `Install the Inspecto ${getHostIdeLabel(ide as Parameters<typeof getHostIdeLabel>[0])} extension.`,
+      })
+    }
+    actions.push({
+      type: 'generate_patch_plan',
+      target: 'umi.config',
+      description: 'Generate a guided patch plan for the Umi Inspecto webpack integration.',
+    })
+    const defaults: PlanResult['defaults'] = {
+      shared: false,
+      extension: shouldInstallInspectoExtension(ide),
+      ...(provider ? { provider } : {}),
+      ...(ide ? { ide } : {}),
+    }
+    return {
+      status: 'warning',
+      warnings: buildGuidedWarnings(context, 'Umi', 'react'),
+      blockers: [],
+      strategy: 'guided',
+      actions,
+      defaults,
+      framework: guidance.framework,
+      metaFramework: guidance.metaFramework,
+      autoApplied: guidance.autoApplied,
+      pendingSteps: guidance.pendingSteps,
+      assistantPrompt: guidance.assistantPrompt,
+      patches: guidance.patches,
+    }
+  }
   const warnings = uniqueMessages([
     ...unsupportedEnvironmentWarnings(context),
     ...buildToolWarnings(context),
@@ -319,18 +566,19 @@ export function createPlanResult(context: OnboardingContext): PlanResult {
     }
     const ide = supportedIde(context)
-    if (ide === 'vscode') {
+    if (shouldInstallInspectoExtension(ide) && ide) {
       actions.push({
         type: 'install_extension',
-        target: 'vscode',
-        description: 'Install the Inspecto VS Code extension.',
+        target: ide,
+        description: `Install the Inspecto ${getHostIdeLabel(ide as Parameters<typeof getHostIdeLabel>[0])} extension.`,
       })
     }
   }
+  const ide = supportedIde(context)
   const defaults: PlanResult['defaults'] = {
     shared: false,
-    extension: supportedIde(context) === 'vscode',
+    extension: shouldInstallInspectoExtension(ide),
   }
   const provider = supportedProvider(context)
@@ -338,7 +586,6 @@ export function createPlanResult(context: OnboardingContext): PlanResult {
     defaults.provider = provider
   }
-  const ide = supportedIde(context)
   if (ide) {
     defaults.ide = ide
   }
@@ -355,6 +602,10 @@ export function createPlanResult(context: OnboardingContext): PlanResult {
 export function planManualFollowUp(result: PlanResult): string[] {
   return result.actions
-    .filter(action => action.type === 'manual_step')
+    .filter(action =>
+      ['manual_step', 'generate_patch_plan', 'generate_file', 'manual_confirmation'].includes(
+        action.type,
+      ),
+    )
     .map(action => action.description)
 }