@metabob/minibob 0.1.2

package/src/cli/burrow.ts

@@ -0,0 +1,896 @@
+/**
+ * Burrow Command
+ *
+ * Inject minibob into an existing codebase, making it a vessel.
+ *
+ * Steps:
+ * 1. Analyze codebase structure (frameworks, entry points)
+ * 2. Add @metabob/minibob as dependency
+ * 3. Create minibob.json config file
+ * 4. Create .minibob/ directory for local state
+ * 5. Optionally inject vessel bootstrap into entry point
+ * 6. Generate initial activities based on detected patterns
+ */
+
+import { parseArgs, formatHelp, printSuccess, printWarning, printInfo, exitWithError } from './index'
+import { CodeExplorer } from '../understanding'
+import type { CodeStructure } from '../understanding/types'
+import {
+  registerVessel,
+  registerVesselWithSync,
+  updateVesselMapping,
+  getVesselByPath,
+  type Vessel,
+  type VesselActivity,
+  type VesselImpulse,
+  type VesselHook,
+  type VesselTool,
+  type VesselComposition,
+} from '../vessel-registry'
+import {
+  analyzeCodebase as analyzeCodebaseMapping,
+  inferIntent,
+  type CodebaseAnalysis,
+} from '../runtime-mapping'
+
+export interface BurrowOptions {
+  dryRun?: boolean
+  configOnly?: boolean
+  analyze?: boolean
+  force?: boolean
+  entry?: string
+  noInject?: boolean
+}
+
+interface BurrowPlan {
+  targetDir: string
+  structure: CodeStructure
+  codebaseAnalysis?: CodebaseAnalysis
+  packageManager: 'npm' | 'yarn' | 'pnpm' | 'bun'
+  entryPoints: string[]
+  primaryEntry?: string
+  framework?: string
+  actions: BurrowAction[]
+  vesselName?: string
+  vesselDescription?: string
+}
+
+interface BurrowAction {
+  type: 'add-dep' | 'create-config' | 'create-dir' | 'inject-bootstrap' | 'create-activity' | 'register-vessel' | 'create-mapping'
+  description: string
+  path?: string
+  content?: string
+  vessel?: Partial<Vessel>
+  analysis?: CodebaseAnalysis
+}
+
+/**
+ * Run burrow command
+ */
+export async function burrow(args: string[]): Promise<void> {
+  const { flags, values, positional } = parseArgs(args)
+
+  // Show help
+  if (flags.help || flags.h) {
+    console.log(formatHelp('burrow', 'Inject minibob into a codebase', [
+      { flag: '--dry-run', description: 'Show what would be done without making changes' },
+      { flag: '--config-only', description: 'Only create config file, no injection' },
+      { flag: '--analyze', description: 'Show detailed codebase analysis' },
+      { flag: '--force', description: 'Overwrite existing minibob config' },
+      { flag: '--entry <file>', description: 'Specify entry point (auto-detected by default)' },
+      { flag: '--no-inject', description: 'Skip injecting bootstrap code' },
+      { flag: '--help, -h', description: 'Show this help message' },
+    ]))
+    return
+  }
+
+  const targetDir = positional[0] || '.'
+  const options: BurrowOptions = {
+    dryRun: flags['dry-run'],
+    configOnly: flags['config-only'],
+    analyze: flags.analyze,
+    force: flags.force,
+    entry: values.entry,
+    noInject: flags['no-inject'],
+  }
+
+  // Validate target directory
+  const fs = await import('fs/promises')
+  const path = await import('path')
+  const absoluteTarget = path.resolve(targetDir)
+
+  try {
+    await fs.access(absoluteTarget)
+  } catch {
+    exitWithError(`Target directory not found: ${absoluteTarget}`)
+  }
+
+  // Check for existing config
+  if (!options.force) {
+    const existingConfig = await checkExistingConfig(absoluteTarget)
+    if (existingConfig) {
+      exitWithError(
+        `minibob config already exists at ${existingConfig}\nUse --force to overwrite`
+      )
+    }
+  }
+
+  printInfo(`Analyzing codebase: ${absoluteTarget}`)
+
+  // Analyze codebase
+  const plan = await analyzeCodebase(absoluteTarget, options)
+
+  // Show analysis if requested
+  if (options.analyze) {
+    printAnalysis(plan)
+  }
+
+  // Show planned actions
+  console.log('\nPlanned actions:')
+  for (const action of plan.actions) {
+    console.log(`  - ${action.description}`)
+    if (options.dryRun && action.path) {
+      console.log(`    Path: ${action.path}`)
+    }
+  }
+
+  // Execute if not dry run
+  if (options.dryRun) {
+    console.log('\n[Dry run] No changes made.')
+    return
+  }
+
+  console.log('\nExecuting...\n')
+  await executePlan(plan, options)
+
+  // Save local mapping summary
+  const vessel = getVesselByPath(absoluteTarget)
+  if (vessel) {
+    const mappingSummary = {
+      vesselId: vessel.id,
+      vesselName: vessel.name,
+      createdAt: new Date().toISOString(),
+      functionsAnalyzed: plan.codebaseAnalysis?.functions.length || 0,
+      classesAnalyzed: plan.codebaseAnalysis?.classes.length || 0,
+      activitiesGenerated: vessel.activities.length,
+    }
+    await Bun.write(`${absoluteTarget}/.minibob/vessel-mapping.json`, JSON.stringify(mappingSummary, null, 2))
+  }
+
+  printSuccess('Burrow complete!')
+  console.log('\nVessel registered successfully!')
+  if (vessel) {
+    console.log(`  Vessel ID: ${vessel.id}`)
+    console.log(`  Vessel Name: ${vessel.name}`)
+  }
+  console.log('\nNext steps:')
+  console.log('  1. Review minibob.json configuration')
+  console.log('  2. Set ANTHROPIC_API_KEY environment variable')
+  console.log('  3. Run: minibob doctor')
+  console.log('  4. Run: minibob goal "your first goal"')
+  console.log('')
+  console.log('The vessel is now tracked in the registry. Use:')
+  console.log('  minibob vessel list    - to see all registered vessels')
+  console.log('  minibob vessel info    - to see this vessel\'s details')
+  console.log('')
+}
+
+/**
+ * Check for existing minibob configuration
+ */
+async function checkExistingConfig(targetDir: string): Promise<string | null> {
+  const configFiles = ['minibob.json', '.minibob.json', '.minibob/config.json']
+
+  for (const configFile of configFiles) {
+    const configPath = `${targetDir}/${configFile}`
+    try {
+      const file = Bun.file(configPath)
+      if (await file.exists()) {
+        return configPath
+      }
+    } catch {
+      // File doesn't exist
+    }
+  }
+
+  return null
+}
+
+/**
+ * Analyze codebase and create burrow plan
+ */
+async function analyzeCodebase(targetDir: string, options: BurrowOptions): Promise<BurrowPlan> {
+  const explorer = new CodeExplorer(targetDir)
+  const structure = await explorer.explore('.')
+
+  // Deep analysis for runtime mapping
+  printInfo('Performing deep code analysis for runtime mapping...')
+  const codebaseAnalysis = await analyzeCodebaseMapping(targetDir)
+  printInfo(`Found ${codebaseAnalysis.functions.length} functions, ${codebaseAnalysis.classes.length} classes`)
+
+  // Detect package manager
+  const packageManager = await detectPackageManager(targetDir)
+
+  // Detect framework
+  const framework = detectFramework(structure)
+
+  // Determine entry points
+  let entryPoints = structure.entryPoints
+  if (options.entry) {
+    entryPoints = [options.entry]
+  }
+
+  // Extract vessel name from package.json or directory name
+  const path = await import('path')
+  let vesselName = path.basename(targetDir)
+  let vesselDescription: string | undefined
+
+  try {
+    const packageJsonPath = `${targetDir}/package.json`
+    const file = Bun.file(packageJsonPath)
+    if (await file.exists()) {
+      const pkg = JSON.parse(await file.text())
+      if (pkg.name) vesselName = pkg.name
+      if (pkg.description) vesselDescription = pkg.description
+    }
+  } catch {
+    // Use directory name as fallback
+  }
+
+  // Create plan
+  const plan: BurrowPlan = {
+    targetDir,
+    structure,
+    codebaseAnalysis,
+    packageManager,
+    entryPoints,
+    primaryEntry: entryPoints[0],
+    framework,
+    vesselName,
+    vesselDescription,
+    actions: [],
+  }
+
+  // Plan: Add dependency
+  plan.actions.push({
+    type: 'add-dep',
+    description: `Add @metabob/minibob to ${packageManager === 'bun' ? 'dependencies' : 'devDependencies'}`,
+    path: `${targetDir}/package.json`,
+  })
+
+  // Plan: Create .minibob directory
+  plan.actions.push({
+    type: 'create-dir',
+    description: 'Create .minibob/ directory for local state',
+    path: `${targetDir}/.minibob`,
+  })
+
+  plan.actions.push({
+    type: 'create-dir',
+    description: 'Create .minibob/impulses/ for local impulse storage',
+    path: `${targetDir}/.minibob/impulses`,
+  })
+
+  plan.actions.push({
+    type: 'create-dir',
+    description: 'Create .minibob/traces/ for execution trace cache',
+    path: `${targetDir}/.minibob/traces`,
+  })
+
+  plan.actions.push({
+    type: 'create-dir',
+    description: 'Create .minibob/activities/ for local activity templates',
+    path: `${targetDir}/.minibob/activities`,
+  })
+
+  plan.actions.push({
+    type: 'create-dir',
+    description: 'Create .minibob/mappings/ for runtime-to-source mappings',
+    path: `${targetDir}/.minibob/mappings`,
+  })
+
+  // Plan: Create config file
+  const config = generateConfig(plan)
+  plan.actions.push({
+    type: 'create-config',
+    description: 'Create minibob.json configuration',
+    path: `${targetDir}/minibob.json`,
+    content: JSON.stringify(config, null, 2),
+  })
+
+  // Plan: Inject bootstrap (unless disabled)
+  if (!options.configOnly && !options.noInject && plan.primaryEntry) {
+    plan.actions.push({
+      type: 'inject-bootstrap',
+      description: `Inject vessel bootstrap into ${plan.primaryEntry}`,
+      path: `${targetDir}/${plan.primaryEntry}`,
+    })
+  }
+
+  // Plan: Generate initial activities based on detected patterns
+  const activities = generateInitialActivities(plan)
+  for (const activity of activities) {
+    plan.actions.push({
+      type: 'create-activity',
+      description: `Create activity: ${activity.name}`,
+      path: `${targetDir}/.minibob/activities/${activity.id}.json`,
+      content: JSON.stringify(activity, null, 2),
+    })
+  }
+
+  // Plan: Register vessel in registry
+  const vesselActivities: VesselActivity[] = activities.map(a => ({
+    id: a.id,
+    name: a.name,
+    origin: 'defined' as const,
+    executions: 0,
+    successRate: 0,
+    avgDuration: 0,
+    thompson: { alpha: 1, beta: 1 },
+  }))
+
+  // Create vessel impulses for configuration
+  const vesselImpulses: VesselImpulse[] = [
+    {
+      id: 'config-provider',
+      type: 'config',
+      description: 'LLM provider configuration',
+      defaultValue: 'anthropic',
+    },
+    {
+      id: 'config-model',
+      type: 'config',
+      description: 'LLM model configuration',
+      defaultValue: 'claude-sonnet-4-20250514',
+    },
+  ]
+
+  // Create default hooks
+  const vesselHooks: VesselHook[] = [
+    {
+      id: 'startup',
+      type: 'startup',
+      handler: 'vessel-bootstrap.ts::initializeVessel',
+      enabled: true,
+    },
+  ]
+
+  // Create default tools
+  const vesselTools: VesselTool[] = [
+    {
+      name: 'build',
+      description: 'Build the project',
+      invocation: { type: 'command', target: `${packageManager} run build` },
+    },
+    {
+      name: 'test',
+      description: 'Run tests',
+      invocation: { type: 'command', target: `${packageManager} test` },
+    },
+  ]
+
+  plan.actions.push({
+    type: 'register-vessel',
+    description: `Register ${vesselName} as a vessel in the registry`,
+    vessel: {
+      name: vesselName,
+      path: targetDir,
+      description: vesselDescription,
+      activities: vesselActivities,
+      impulses: vesselImpulses,
+      hooks: vesselHooks,
+      tools: vesselTools,
+      composition: { compositions: [], sequences: [] },
+    },
+  })
+
+  // Plan: Create runtime mappings from code analysis
+  if (codebaseAnalysis.functions.length > 0 || codebaseAnalysis.classes.length > 0) {
+    plan.actions.push({
+      type: 'create-mapping',
+      description: `Create runtime mappings for ${codebaseAnalysis.functions.length} functions and ${codebaseAnalysis.classes.length} classes`,
+      analysis: codebaseAnalysis,
+    })
+  }
+
+  return plan
+}
+
+/**
+ * Detect package manager
+ */
+async function detectPackageManager(targetDir: string): Promise<'npm' | 'yarn' | 'pnpm' | 'bun'> {
+  const lockFiles = [
+    { file: 'bun.lockb', manager: 'bun' as const },
+    { file: 'pnpm-lock.yaml', manager: 'pnpm' as const },
+    { file: 'yarn.lock', manager: 'yarn' as const },
+    { file: 'package-lock.json', manager: 'npm' as const },
+  ]
+
+  for (const { file, manager } of lockFiles) {
+    try {
+      const lockFile = Bun.file(`${targetDir}/${file}`)
+      if (await lockFile.exists()) {
+        return manager
+      }
+    } catch {
+      // File doesn't exist
+    }
+  }
+
+  return 'npm'
+}
+
+/**
+ * Detect framework from dependencies
+ */
+function detectFramework(structure: CodeStructure): string | undefined {
+  const frameworks = structure.dependencies.frameworks
+  if (frameworks.length > 0) {
+    return frameworks[0]
+  }
+  return undefined
+}
+
+/**
+ * Generate minibob config
+ */
+function generateConfig(plan: BurrowPlan): Record<string, any> {
+  const config: Record<string, any> = {
+    $schema: 'https://minibob.dev/schema/config.json',
+    provider: 'anthropic',
+    model: 'claude-sonnet-4-20250514',
+    templatesDir: './.minibob/activities',
+    autoCommit: false,
+  }
+
+  // Add framework-specific settings
+  if (plan.framework) {
+    config.vesselType = plan.framework.toLowerCase()
+  }
+
+  // Add vessel configuration for MCP backend
+  config.vessels = {
+    metabob: {
+      type: 'http',
+      endpoint: process.env.MINIBOB_MCP_ENDPOINT || 'http://api.minibob.local',
+      capabilities: ['activities', 'impulses', 'executions', 'thompson-sampling'],
+    },
+  }
+
+  return config
+}
+
+/**
+ * Generate initial activities based on detected patterns
+ */
+function generateInitialActivities(plan: BurrowPlan): Array<{
+  id: string
+  name: string
+  description: string
+  category: string
+  tasks: any[]
+}> {
+  const activities: Array<{
+    id: string
+    name: string
+    description: string
+    category: string
+    tasks: any[]
+  }> = []
+
+  // Build activity
+  activities.push({
+    id: 'build',
+    name: 'Build Project',
+    description: 'Build the project using the detected package manager',
+    category: 'infrastructure',
+    tasks: [
+      {
+        id: 'build-1',
+        description: 'Run build command',
+        prompt: {
+          template: `Run the build command for this ${plan.framework || 'project'}`,
+        },
+        validation: {
+          requiredFiles: [],
+        },
+      },
+    ],
+  })
+
+  // Test activity
+  activities.push({
+    id: 'test',
+    name: 'Run Tests',
+    description: 'Run the test suite',
+    category: 'infrastructure',
+    tasks: [
+      {
+        id: 'test-1',
+        description: 'Run test command',
+        prompt: {
+          template: 'Run the test suite and report results',
+        },
+        validation: {
+          requiredFiles: [],
+        },
+      },
+    ],
+  })
+
+  // Framework-specific activities
+  if (plan.framework === 'React' || plan.framework === 'Next.js') {
+    activities.push({
+      id: 'create-component',
+      name: 'Create React Component',
+      description: 'Create a new React component',
+      category: 'feature',
+      tasks: [
+        {
+          id: 'create-component-1',
+          description: 'Create component file',
+          prompt: {
+            template:
+              'Create a new React component named {{componentName}} in {{path}}',
+            variables: [
+              { name: 'componentName', type: 'string', required: true },
+              { name: 'path', type: 'string', default: 'src/components' },
+            ],
+          },
+          validation: {
+            requiredPatterns: ['export', 'function', 'return'],
+          },
+        },
+      ],
+    })
+  }
+
+  if (plan.framework === 'Hono' || plan.framework === 'Express') {
+    activities.push({
+      id: 'create-endpoint',
+      name: 'Create API Endpoint',
+      description: 'Create a new API endpoint',
+      category: 'feature',
+      tasks: [
+        {
+          id: 'create-endpoint-1',
+          description: 'Create endpoint handler',
+          prompt: {
+            template:
+              'Create a new {{method}} endpoint at {{path}} that {{description}}',
+            variables: [
+              { name: 'method', type: 'string', default: 'GET' },
+              { name: 'path', type: 'string', required: true },
+              { name: 'description', type: 'string', required: true },
+            ],
+          },
+          validation: {
+            requiredPatterns: ['app.', 'router.', 'async', 'Request', 'Response'],
+          },
+        },
+      ],
+    })
+  }
+
+  return activities
+}
+
+/**
+ * Print analysis
+ */
+function printAnalysis(plan: BurrowPlan): void {
+  const { structure, codebaseAnalysis } = plan
+
+  console.log('\n=== Codebase Analysis ===\n')
+  console.log(`Target: ${plan.targetDir}`)
+  console.log(`Vessel Name: ${plan.vesselName || 'unnamed'}`)
+  console.log(`Package Manager: ${plan.packageManager}`)
+  console.log(`Framework: ${plan.framework || 'none detected'}`)
+  console.log(`Total Files: ${structure.totalFiles}`)
+  console.log(`Lines of Code: ${structure.totalLoc.toLocaleString()}`)
+  console.log(`Size: ${(structure.totalSize / 1024).toFixed(2)} KB`)
+
+  console.log('\nFile Types:')
+  const sortedTypes = Object.entries(structure.filesByType)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 5)
+  for (const [ext, count] of sortedTypes) {
+    console.log(`  .${ext}: ${count}`)
+  }
+
+  console.log('\nEntry Points:')
+  for (const entry of structure.entryPoints) {
+    const isPrimary = entry === plan.primaryEntry ? ' (primary)' : ''
+    console.log(`  ${entry}${isPrimary}`)
+  }
+
+  if (structure.dependencies.runtime && Object.keys(structure.dependencies.runtime).length > 0) {
+    console.log('\nKey Dependencies:')
+    const deps = Object.entries(structure.dependencies.runtime).slice(0, 10)
+    for (const [dep, version] of deps) {
+      console.log(`  ${dep}: ${version}`)
+    }
+  }
+
+  // Show runtime mapping analysis
+  if (codebaseAnalysis) {
+    console.log('\n=== Runtime Mapping Analysis ===\n')
+    console.log(`Functions: ${codebaseAnalysis.functions.length}`)
+    console.log(`Classes: ${codebaseAnalysis.classes.length}`)
+    console.log(`Modules: ${codebaseAnalysis.modules.length}`)
+    console.log(`Documentation blocks: ${codebaseAnalysis.documentation.length}`)
+
+    // Show some function intents
+    if (codebaseAnalysis.functions.length > 0) {
+      console.log('\nSample Function Intents:')
+      const sampleFuncs = codebaseAnalysis.functions.slice(0, 5)
+      for (const func of sampleFuncs) {
+        const intent = inferIntent(func, codebaseAnalysis.classes, codebaseAnalysis.documentation)
+        console.log(`  ${func.name}: ${intent.purpose} (${Math.round(intent.confidence * 100)}% confidence)`)
+      }
+    }
+
+    // Show classes
+    if (codebaseAnalysis.classes.length > 0) {
+      console.log('\nClasses Found:')
+      for (const cls of codebaseAnalysis.classes.slice(0, 5)) {
+        const methodCount = cls.methods.length
+        console.log(`  ${cls.name}: ${methodCount} methods${cls.extends ? ` (extends ${cls.extends})` : ''}`)
+      }
+    }
+  }
+
+  console.log('')
+}
+
+/**
+ * Execute burrow plan
+ */
+async function executePlan(plan: BurrowPlan, options: BurrowOptions): Promise<void> {
+  const fs = await import('fs/promises')
+
+  for (const action of plan.actions) {
+    switch (action.type) {
+      case 'add-dep':
+        await addDependency(plan)
+        printSuccess('Added @metabob/minibob dependency')
+        break
+
+      case 'create-dir':
+        if (action.path) {
+          await fs.mkdir(action.path, { recursive: true })
+          printSuccess(`Created ${action.path}`)
+        }
+        break
+
+      case 'create-config':
+        if (action.path && action.content) {
+          await Bun.write(action.path, action.content)
+          printSuccess(`Created ${action.path}`)
+        }
+        break
+
+      case 'inject-bootstrap':
+        if (action.path) {
+          await injectBootstrap(action.path, plan)
+          printSuccess(`Injected vessel bootstrap into ${action.path}`)
+        }
+        break
+
+      case 'create-activity':
+        if (action.path && action.content) {
+          await Bun.write(action.path, action.content)
+          printSuccess(`Created activity: ${action.path}`)
+        }
+        break
+
+      case 'register-vessel':
+        if (action.vessel) {
+          const existingVessel = getVesselByPath(plan.targetDir)
+          if (existingVessel) {
+            printWarning(`Vessel already registered: ${existingVessel.id}`)
+          } else {
+            // Collect function mappings for backend sync
+            const functionMappings: Array<{
+              functionName: string
+              file: string
+              line: number
+              className?: string
+              intent?: { purpose: string; confidence: number; source: string }
+            }> = []
+
+            if (plan.codebaseAnalysis) {
+              for (const func of plan.codebaseAnalysis.functions) {
+                const intent = inferIntent(func, plan.codebaseAnalysis.classes, plan.codebaseAnalysis.documentation)
+                functionMappings.push({
+                  functionName: func.name,
+                  file: func.file,
+                  line: func.line,
+                  intent: {
+                    purpose: intent.purpose,
+                    confidence: intent.confidence,
+                    source: intent.source,
+                  },
+                })
+              }
+
+              for (const cls of plan.codebaseAnalysis.classes) {
+                for (const method of cls.methods) {
+                  const intent = inferIntent(method, plan.codebaseAnalysis.classes, plan.codebaseAnalysis.documentation)
+                  functionMappings.push({
+                    functionName: `${cls.name}.${method.name}`,
+                    file: method.file,
+                    line: method.line,
+                    className: cls.name,
+                    intent: {
+                      purpose: intent.purpose,
+                      confidence: intent.confidence,
+                      source: intent.source,
+                    },
+                  })
+                }
+              }
+            }
+
+            // Register with backend sync
+            printInfo('Syncing vessel to backend...')
+            const vessel = await registerVesselWithSync({
+              name: action.vessel.name || 'unnamed',
+              path: plan.targetDir,
+              description: action.vessel.description,
+              version: action.vessel.version,
+              activities: action.vessel.activities || [],
+              impulses: action.vessel.impulses || [],
+              hooks: action.vessel.hooks || [],
+              tools: action.vessel.tools || [],
+              composition: action.vessel.composition || { compositions: [], sequences: [] },
+            }, functionMappings)
+            printSuccess(`Registered vessel: ${vessel.name} (${vessel.id})`)
+          }
+        }
+        break
+
+      case 'create-mapping':
+        if (action.analysis) {
+          const vessel = getVesselByPath(plan.targetDir)
+          if (vessel) {
+            // Map functions to source locations and infer intent (local storage)
+            for (const func of action.analysis.functions) {
+              const intent = inferIntent(func, action.analysis.classes, action.analysis.documentation)
+
+              // Store function mapping locally
+              updateVesselMapping(vessel.id, 'function', func.name, {
+                file: func.file,
+                line: func.line,
+                functionName: func.name,
+              })
+
+              // Store inferred intent locally
+              updateVesselMapping(vessel.id, 'intent', func.name, intent)
+            }
+
+            // Map class methods too
+            for (const cls of action.analysis.classes) {
+              for (const method of cls.methods) {
+                const intent = inferIntent(method, action.analysis.classes, action.analysis.documentation)
+
+                updateVesselMapping(vessel.id, 'function', `${cls.name}.${method.name}`, {
+                  file: method.file,
+                  line: method.line,
+                  functionName: method.name,
+                  className: cls.name,
+                })
+
+                updateVesselMapping(vessel.id, 'intent', `${cls.name}.${method.name}`, intent)
+              }
+            }
+
+            printSuccess(`Created runtime mappings for ${action.analysis.functions.length} functions`)
+          } else {
+            printWarning('Cannot create mappings: vessel not registered')
+          }
+        }
+        break
+    }
+  }
+}
+
+/**
+ * Add minibob dependency to package.json
+ */
+async function addDependency(plan: BurrowPlan): Promise<void> {
+  const packageJsonPath = `${plan.targetDir}/package.json`
+
+  try {
+    const content = await Bun.file(packageJsonPath).text()
+    const packageJson = JSON.parse(content)
+
+    // Add to devDependencies
+    if (!packageJson.devDependencies) {
+      packageJson.devDependencies = {}
+    }
+
+    packageJson.devDependencies['@metabob/minibob'] = '^0.1.0'
+
+    await Bun.write(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n')
+  } catch (error) {
+    printWarning(`Could not update package.json: ${error}`)
+  }
+}
+
+/**
+ * Inject vessel bootstrap into entry point
+ */
+async function injectBootstrap(entryPath: string, plan: BurrowPlan): Promise<void> {
+  try {
+    const content = await Bun.file(entryPath).text()
+
+    // Check if already injected
+    if (content.includes('@metabob/minibob') || content.includes('initializeVessel')) {
+      printWarning('Bootstrap already present, skipping injection')
+      return
+    }
+
+    // Determine injection point and code
+    const isTypeScript = entryPath.endsWith('.ts') || entryPath.endsWith('.tsx')
+    const appName = plan.framework?.toLowerCase() || 'app'
+
+    const importStatement = `import { initializeVessel } from '@metabob/minibob/vessel-bootstrap'\n`
+    const initCode = `
+// Initialize minibob vessel
+const __vessel = await initializeVessel({
+  workingDirectory: import.meta.dir || __dirname,
+  provider: (process.env.MINIBOB_PROVIDER as 'anthropic' | 'openai') || 'anthropic',
+  apiKey: process.env.ANTHROPIC_API_KEY!,
+  model: process.env.MINIBOB_MODEL || 'claude-sonnet-4-20250514',
+  vesselType: '${appName}',
+  enableSelfImprovement: false // Enable when ready
+})
+
+// Export vessel for runtime access
+export { __vessel }
+`
+
+    // Find injection point
+    // Look for existing imports and inject after them
+    const importMatch = content.match(/^(import\s+.*?\n)+/m)
+    let newContent: string
+
+    if (importMatch) {
+      const importEnd = importMatch.index! + importMatch[0].length
+      newContent =
+        content.slice(0, importEnd) +
+        importStatement +
+        content.slice(importEnd)
+    } else {
+      // No imports, add at beginning
+      newContent = importStatement + content
+    }
+
+    // Add init code after imports
+    const lastImportIndex = newContent.lastIndexOf('import ')
+    if (lastImportIndex >= 0) {
+      const lineEnd = newContent.indexOf('\n', lastImportIndex)
+      newContent =
+        newContent.slice(0, lineEnd + 1) +
+        initCode +
+        newContent.slice(lineEnd + 1)
+    } else {
+      newContent = importStatement + initCode + content
+    }
+
+    await Bun.write(entryPath, newContent)
+  } catch (error) {
+    printWarning(`Could not inject bootstrap: ${error}`)
+  }
+}
+
+// CLI entry point
+if (import.meta.main) {
+  const args = process.argv.slice(2)
+  burrow(args).catch((error) => {
+    console.error('Burrow failed:', error)
+    process.exit(1)
+  })
+}