vibefast-cli 1.2.1 → 1.3.1

package/docs/archive/IMPLEMENTATION-PLAN.md

@@ -1,1360 +0,0 @@
-# 🔧 Technical Implementation Plan
-
-## Overview
-
-This is the **exact technical plan** for making VibeFast CLI production-ready. No hand-waving, just concrete steps with code examples and gotchas.
-
----
-
-## Phase 1: Interactive Confirmation (Priority 1) 🔴
-
-### Goal
-When files exist, ask user y/n before overwriting. Show what will be lost.
-
-### Technical Approach
-
-#### Step 1.1: Add readline-sync for prompts
-
-**Why not built-in readline?**
-- Built-in readline is async and complex
-- readline-sync is simpler for CLI prompts
-- Works in both interactive and non-interactive modes
-
-```bash
-cd vibefast-cli
-npm install readline-sync
-npm install --save-dev @types/readline-sync
-```
-
-#### Step 1.2: Create prompt utility
-
-**File:** `src/core/prompt.ts`
-
-```typescript
-import readlineSync from 'readline-sync';
-
-export function promptUser(question: string): string {
-  // Check if we're in a non-interactive environment (CI, piped input)
-  if (!process.stdin.isTTY) {
-    return 'n'; // Default to no in non-interactive mode
-  }
-  
-  return readlineSync.question(question);
-}
-
-export function promptYesNo(question: string, defaultYes = false): boolean {
-  const answer = promptUser(question);
-  const normalized = answer.toLowerCase().trim();
-  
-  if (normalized === '') {
-    return defaultYes;
-  }
-  
-  return normalized === 'y' || normalized === 'yes';
-}
-```
-
-**Gotcha:** CI environments don't have TTY, so we need to handle that.
-
-#### Step 1.3: Update copyTree to detect conflicts
-
-**File:** `src/core/fsx.ts`
-
-```typescript
-export interface CopyResult {
-  files: string[];
-  conflicts: string[];
-  skipped: string[];
-}
-
-export async function copyTree(
-  src: string,
-  dest: string,
-  options?: { 
-    dryRun?: boolean; 
-    force?: boolean;
-    interactive?: boolean;
-  }
-): Promise<CopyResult> {
-  const copied: string[] = [];
-  const conflicts: string[] = [];
-  const skipped: string[] = [];
-  
-  async function copyRecursive(srcPath: string, destPath: string) {
-    const stats = await stat(srcPath);
-    
-    if (stats.isDirectory()) {
-      if (!options?.dryRun) {
-        await ensureDir(destPath);
-      }
-      const entries = await readdir(srcPath);
-      for (const entry of entries) {
-        await copyRecursive(join(srcPath, entry), join(destPath, entry));
-      }
-    } else {
-      const destExists = await exists(destPath);
-      
-      if (destExists) {
-        conflicts.push(destPath);
-        
-        // If not force and not interactive, throw error
-        if (!options?.force && !options?.interactive) {
-          throw new Error(`File exists: ${destPath}. Use --force to overwrite.`);
-        }
-        
-        // If interactive and not dry-run, ask user
-        if (options?.interactive && !options?.dryRun) {
-          const { promptYesNo } = await import('./prompt.js');
-          const shouldOverwrite = promptYesNo(
-            `Overwrite ${destPath}? (y/N): `,
-            false
-          );
-          
-          if (!shouldOverwrite) {
-            skipped.push(destPath);
-            return; // Skip this file
-          }
-        }
-      }
-      
-      if (!options?.dryRun) {
-        await ensureDir(dirname(destPath));
-        await copyFile(srcPath, destPath);
-      }
-      copied.push(destPath);
-    }
-  }
-  
-  await copyRecursive(src, dest);
-  return { files: copied, conflicts, skipped };
-}
-```
-
-
-#### Step 1.4: Update add command to use interactive mode
-
-**File:** `src/commands/add.ts`
-
-```typescript
-// After checking if already installed
-if (existing && !options.force) {
-  log.warn(`${feature} is already installed for ${target}`);
-  log.info('Use --force to reinstall');
-  return;
-}
-
-// NEW: Scan for conflicts BEFORE downloading
-if (!options.dryRun && !options.force) {
-  log.info('Checking for file conflicts...');
-  
-  // We need to know what files will be copied
-  // Problem: We don't have the recipe yet!
-  // Solution: Download recipe first, check conflicts, then ask
-}
-
-// Copy files with interactive mode
-const result = await copyTree(srcPath, destPath, {
-  dryRun: options.dryRun,
-  force: options.force,
-  interactive: !options.force && !options.dryRun, // Enable interactive if not force
-});
-
-// Show results
-if (result.conflicts.length > 0) {
-  if (options.dryRun) {
-    log.warn(`⚠ ${result.conflicts.length} files will be overwritten:`);
-    result.conflicts.slice(0, 5).forEach(f => {
-      const relativePath = f.replace(paths.cwd + '/', '');
-      log.plain(`  • ${relativePath}`);
-    });
-    if (result.conflicts.length > 5) {
-      log.plain(`  ... and ${result.conflicts.length - 5} more`);
-    }
-    log.warn('⚠ Make sure you have committed your changes to Git!');
-  }
-}
-
-if (result.skipped.length > 0) {
-  log.info(`ℹ Skipped ${result.skipped.length} files (user chose not to overwrite)`);
-}
-
-copiedFiles.push(...result.files);
-```
-
-**Gotcha:** We need the recipe to know what files will be copied, but we don't want to download it if user will cancel. Solution: Download first, show conflicts, then proceed.
-
-#### Step 1.5: Add --yes flag for automation
-
-**File:** `src/commands/add.ts`
-
-```typescript
-export const addCommand = new Command('add')
-  .description('Add a VibeFast feature to your project')
-  .argument('<feature>', 'Feature name to install')
-  .option('--target <target>', 'Target platform (native or web)', 'native')
-  .option('--dry-run', 'Preview changes without applying')
-  .option('--force', 'Overwrite existing files without asking')
-  .option('--yes', 'Answer yes to all prompts (for automation)')
-  .action(async (feature: string, options) => {
-    // ...
-    const interactive = !options.force && !options.dryRun && !options.yes;
-    // ...
-  });
-```
-
-**Testing:**
-```bash
-# Interactive mode (asks for each file)
-$ vf add charts
-
-# Force mode (overwrites all)
-$ vf add charts --force
-
-# Automation mode (assumes yes)
-$ vf add charts --yes
-
-# Dry run (shows what would happen)
-$ vf add charts --dry-run
-```
-
----
-
-## Phase 2: Package Dependency Management (Priority 2) 🔴
-
-### Goal
-Detect required packages, show them to user, optionally install them.
-
-### The Hard Part: How to Know What Packages Are Needed?
-
-**Option A: Parse imports from files** ❌
-```typescript
-// Parse all .ts/.tsx files and extract imports
-import { Chart } from 'react-native-chart-kit'; // Need to detect this
-```
-**Problems:**
-- Regex parsing is fragile
-- Need to parse TypeScript AST (complex)
-- Slow for large features
-- Can't detect dynamic imports
-- Can't determine versions
-
-**Option B: Add dependencies to recipe.json** ✅
-```json
-{
-  "name": "charts",
-  "dependencies": {
-    "npm": {
-      "react-native-chart-kit": "^6.12.0",
-      "react-native-svg": "^13.9.0"
-    }
-  }
-}
-```
-**Advantages:**
-- Explicit and clear
-- Recipe creator knows exact versions
-- Fast (no parsing needed)
-- Can specify peer dependencies
-- Can add install instructions
-
-**Decision: Use Option B** - Recipe creators must specify dependencies manually.
-
-### Technical Approach
-
-#### Step 2.1: Update recipe.json schema
-
-**File:** `src/commands/add.ts`
-
-```typescript
-interface RecipeManifest {
-  name: string;
-  version: string;
-  description: string;
-  copy: Array<{ from: string; to: string }>;
-  nav: { href: string; label: string };
-  target: 'native' | 'web';
-  
-  // NEW: Dependencies
-  dependencies?: {
-    npm?: Record<string, string>;
-    expo?: Record<string, string>;
-  };
-  
-  // NEW: Post-install instructions
-  postInstall?: {
-    message?: string;
-    commands?: string[];
-  };
-}
-```
-
-#### Step 2.2: Detect package manager
-
-**File:** `src/core/packageManager.ts`
-
-```typescript
-import { exists } from './fsx.js';
-import { join } from 'path';
-
-export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
-
-export async function detectPackageManager(cwd: string): Promise<PackageManager> {
-  // Check lock files
-  if (await exists(join(cwd, 'yarn.lock'))) {
-    return 'yarn';
-  }
-  if (await exists(join(cwd, 'pnpm-lock.yaml'))) {
-    return 'pnpm';
-  }
-  if (await exists(join(cwd, 'bun.lockb'))) {
-    return 'bun';
-  }
-  
-  // Default to npm
-  return 'npm';
-}
-
-export function getInstallCommand(
-  pm: PackageManager,
-  packages: string[]
-): string {
-  const pkgList = packages.join(' ');
-  
-  switch (pm) {
-    case 'yarn':
-      return `yarn add ${pkgList}`;
-    case 'pnpm':
-      return `pnpm add ${pkgList}`;
-    case 'bun':
-      return `bun add ${pkgList}`;
-    default:
-      return `npm install ${pkgList}`;
-  }
-}
-```
-
-**Gotcha:** Monorepos might have multiple package.json files. We need to install in the right workspace.
-
-#### Step 2.3: Install packages function
-
-**File:** `src/core/packageManager.ts`
-
-```typescript
-import { executeBash } from './shell.js';
-
-export async function installPackages(
-  packages: Record<string, string>,
-  cwd: string
-): Promise<{ success: boolean; error?: string }> {
-  const pm = await detectPackageManager(cwd);
-  
-  // Convert to array of package@version
-  const pkgList = Object.entries(packages).map(
-    ([name, version]) => `${name}@${version}`
-  );
-  
-  const command = getInstallCommand(pm, pkgList);
-  
-  try {
-    log.info(`Running: ${command}`);
-    const result = await executeBash(command, { cwd });
-    
-    if (result.exitCode !== 0) {
-      return {
-        success: false,
-        error: result.stderr || 'Installation failed'
-      };
-    }
-    
-    return { success: true };
-  } catch (error: any) {
-    return {
-      success: false,
-      error: error.message
-    };
-  }
-}
-```
-
-**File:** `src/core/shell.ts` (NEW)
-
-```typescript
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
-
-export async function executeBash(
-  command: string,
-  options?: { cwd?: string }
-): Promise<{ stdout: string; stderr: string; exitCode: number }> {
-  try {
-    const { stdout, stderr } = await execAsync(command, {
-      cwd: options?.cwd,
-      maxBuffer: 10 * 1024 * 1024, // 10MB buffer
-    });
-    
-    return { stdout, stderr, exitCode: 0 };
-  } catch (error: any) {
-    return {
-      stdout: error.stdout || '',
-      stderr: error.stderr || '',
-      exitCode: error.code || 1,
-    };
-  }
-}
-```
-
-
-#### Step 2.4: Update add command to handle dependencies
-
-**File:** `src/commands/add.ts`
-
-```typescript
-// After copying files and adding watermarks
-
-// Handle dependencies
-if (manifest.dependencies && !options.dryRun) {
-  const npmDeps = manifest.dependencies.npm || {};
-  const expoDeps = manifest.dependencies.expo || {};
-  const allDeps = { ...npmDeps, ...expoDeps };
-  
-  if (Object.keys(allDeps).length > 0) {
-    log.plain('');
-    log.warn('⚠ This feature requires additional packages:');
-    log.plain('');
-    
-    Object.entries(allDeps).forEach(([pkg, version]) => {
-      log.plain(`  • ${pkg}@${version}`);
-    });
-    
-    log.plain('');
-    
-    // Detect package manager
-    const pm = await detectPackageManager(paths.cwd);
-    const pkgList = Object.entries(allDeps).map(
-      ([name, version]) => `${name}@${version}`
-    );
-    const installCmd = getInstallCommand(pm, pkgList);
-    
-    log.info('📦 Install with:');
-    log.plain(`  ${installCmd}`);
-    log.plain('');
-    
-    // Ask if user wants to install now
-    if (!options.skipInstall && !options.yes) {
-      const shouldInstall = promptYesNo(
-        'Install packages now? (Y/n): ',
-        true // Default to yes
-      );
-      
-      if (shouldInstall) {
-        log.info('Installing packages...');
-        const result = await installPackages(allDeps, paths.cwd);
-        
-        if (result.success) {
-          log.success('✓ Packages installed successfully!');
-        } else {
-          log.error(`✗ Package installation failed: ${result.error}`);
-          log.info('You can install them manually with:');
-          log.plain(`  ${installCmd}`);
-        }
-      }
-    } else if (options.yes) {
-      // Auto-install in --yes mode
-      log.info('Installing packages...');
-      const result = await installPackages(allDeps, paths.cwd);
-      
-      if (!result.success) {
-        log.error(`✗ Package installation failed: ${result.error}`);
-        process.exit(1);
-      }
-    }
-  }
-}
-
-// Post-install instructions
-if (manifest.postInstall && !options.dryRun) {
-  log.plain('');
-  log.info('📝 Post-install steps:');
-  
-  if (manifest.postInstall.message) {
-    log.plain(`  ${manifest.postInstall.message}`);
-  }
-  
-  if (manifest.postInstall.commands) {
-    log.plain('');
-    log.info('Run these commands:');
-    manifest.postInstall.commands.forEach(cmd => {
-      log.plain(`  $ ${cmd}`);
-    });
-  }
-}
-```
-
-#### Step 2.5: Add --skip-install flag
-
-```typescript
-export const addCommand = new Command('add')
-  .description('Add a VibeFast feature to your project')
-  .argument('<feature>', 'Feature name to install')
-  .option('--target <target>', 'Target platform (native or web)', 'native')
-  .option('--dry-run', 'Preview changes without applying')
-  .option('--force', 'Overwrite existing files without asking')
-  .option('--yes', 'Answer yes to all prompts')
-  .option('--skip-install', 'Skip package installation')
-  .action(async (feature: string, options) => {
-    // ...
-  });
-```
-
-**Testing:**
-```bash
-# Interactive (asks to install)
-$ vf add charts
-
-# Auto-install
-$ vf add charts --yes
-
-# Skip install
-$ vf add charts --skip-install
-
-# Dry run (shows packages but doesn't install)
-$ vf add charts --dry-run
-```
-
-**Gotcha:** Monorepo workspaces - need to detect if we should install in root or workspace.
-
-#### Step 2.6: Handle monorepo workspaces
-
-**File:** `src/core/packageManager.ts`
-
-```typescript
-export async function findPackageJsonDir(startDir: string): Promise<string> {
-  let currentDir = startDir;
-  
-  while (currentDir !== '/') {
-    const pkgJsonPath = join(currentDir, 'package.json');
-    
-    if (await exists(pkgJsonPath)) {
-      // Check if this is a workspace root or a workspace package
-      const pkgJson = JSON.parse(await readFileContent(pkgJsonPath));
-      
-      // If it has workspaces, it's the root
-      if (pkgJson.workspaces) {
-        return currentDir;
-      }
-      
-      // Otherwise, keep looking up
-    }
-    
-    currentDir = dirname(currentDir);
-  }
-  
-  // Fallback to start directory
-  return startDir;
-}
-
-export async function installPackages(
-  packages: Record<string, string>,
-  cwd: string
-): Promise<{ success: boolean; error?: string }> {
-  // Find the correct directory to run install in
-  const installDir = await findPackageJsonDir(cwd);
-  
-  const pm = await detectPackageManager(installDir);
-  
-  // ... rest of the function
-}
-```
-
----
-
-## Phase 3: Manual Steps Support (Priority 3) 🟡
-
-### Goal
-For features like Sentry, PostHog, etc., show manual configuration steps.
-
-### Technical Approach
-
-#### Step 3.1: Extend recipe.json schema
-
-```typescript
-interface RecipeManifest {
-  // ... existing fields
-  
-  // NEW: Environment variables needed
-  env?: {
-    required?: Array<{
-      key: string;
-      description: string;
-      example: string;
-      link?: string;
-    }>;
-    optional?: Array<{
-      key: string;
-      description: string;
-      example: string;
-      default?: string;
-    }>;
-  };
-  
-  // NEW: Manual steps
-  manualSteps?: Array<{
-    step: number;
-    title: string;
-    description: string;
-    file?: string;
-    action?: 'add' | 'modify' | 'create';
-    content?: string;
-    link?: string;
-    command?: string;
-  }>;
-}
-```
-
-#### Step 3.2: Display manual steps
-
-**File:** `src/commands/add.ts`
-
-```typescript
-// After installation completes
-
-if (manifest.manualSteps && !options.dryRun) {
-  log.plain('');
-  log.warn('⚠ MANUAL STEPS REQUIRED:');
-  log.plain('');
-  log.plain('This feature requires some manual configuration:');
-  log.plain('');
-  
-  manifest.manualSteps.forEach(step => {
-    log.plain('┌─────────────────────────────────────────────────────────────┐');
-    log.plain(`│ Step ${step.step}: ${step.title.padEnd(52)} │`);
-    log.plain('│                                                             │');
-    
-    // Wrap description to fit in box
-    const descLines = wrapText(step.description, 59);
-    descLines.forEach(line => {
-      log.plain(`│ ${line.padEnd(59)} │`);
-    });
-    
-    if (step.file) {
-      log.plain('│                                                             │');
-      log.plain(`│ 📝 File: ${step.file.padEnd(51)} │`);
-    }
-    
-    if (step.content) {
-      log.plain('│                                                             │');
-      log.plain(`│ Add: ${step.content.padEnd(54)} │`);
-    }
-    
-    if (step.link) {
-      log.plain('│                                                             │');
-      log.plain(`│ 🔗 ${step.link.padEnd(57)} │`);
-    }
-    
-    if (step.command) {
-      log.plain('│                                                             │');
-      log.plain(`│ $ ${step.command.padEnd(57)} │`);
-    }
-    
-    log.plain('└─────────────────────────────────────────────────────────────┘');
-    log.plain('');
-  });
-  
-  log.info('💡 Tip: Run \'vf checklist ${manifest.name}\' to see these steps again.');
-}
-
-// Environment variables
-if (manifest.env?.required && !options.dryRun) {
-  log.plain('');
-  log.warn('⚠ REQUIRED ENVIRONMENT VARIABLES:');
-  log.plain('');
-  
-  manifest.env.required.forEach(envVar => {
-    log.plain(`  ${envVar.key}`);
-    log.plain(`    ${envVar.description}`);
-    log.plain(`    Example: ${envVar.example}`);
-    if (envVar.link) {
-      log.plain(`    Get it: ${envVar.link}`);
-    }
-    log.plain('');
-  });
-  
-  log.info('Add these to your .env file');
-}
-```
-
-**File:** `src/core/log.ts` (add helper)
-
-```typescript
-export function wrapText(text: string, maxWidth: number): string[] {
-  const words = text.split(' ');
-  const lines: string[] = [];
-  let currentLine = '';
-  
-  words.forEach(word => {
-    if ((currentLine + word).length <= maxWidth) {
-      currentLine += (currentLine ? ' ' : '') + word;
-    } else {
-      if (currentLine) lines.push(currentLine);
-      currentLine = word;
-    }
-  });
-  
-  if (currentLine) lines.push(currentLine);
-  
-  return lines;
-}
-```
-
-#### Step 3.3: Add vf checklist command
-
-**File:** `src/commands/checklist.ts` (NEW)
-
-```typescript
-import { Command } from 'commander';
-import { log } from '../core/log.js';
-import { getPaths } from '../core/paths.js';
-import { getEntry } from '../core/journal.js';
-
-export const checklistCommand = new Command('checklist')
-  .description('Show manual setup steps for an installed feature')
-  .argument('<feature>', 'Feature name')
-  .action(async (feature: string) => {
-    try {
-      const paths = getPaths();
-      
-      // Check if feature is installed
-      const entry = await getEntry(paths.journalFile, feature, 'native');
-      if (!entry) {
-        log.error(`${feature} is not installed`);
-        log.info('Run "vf list" to see installed features');
-        process.exit(1);
-      }
-      
-      // Problem: We don't have the recipe manifest in the journal!
-      // Solution: Store it in the journal when installing
-      
-      if (!entry.manifest?.manualSteps) {
-        log.info(`${feature} has no manual setup steps`);
-        return;
-      }
-      
-      // Display the steps (same code as in add.ts)
-      log.info(`Manual setup steps for ${feature}:`);
-      log.plain('');
-      
-      // ... display logic
-      
-    } catch (error: any) {
-      log.error(`Failed to show checklist: ${error.message}`);
-      process.exit(1);
-    }
-  });
-```
-
-**Gotcha:** We need to store the manifest in the journal so we can show it later.
-
-#### Step 3.4: Update journal to store manifest
-
-**File:** `src/core/journal.ts`
-
-```typescript
-export interface JournalEntry {
-  feature: string;
-  target: 'native' | 'web';
-  files: string[];
-  insertedNav: boolean;
-  navHref?: string;
-  navLabel?: string;
-  ts: number;
-  
-  // NEW: Store manifest for later reference
-  manifest?: {
-    version: string;
-    manualSteps?: any[];
-    env?: any;
-    postInstall?: any;
-  };
-}
-```
-
-**File:** `src/commands/add.ts`
-
-```typescript
-// Update journal
-if (!options.dryRun) {
-  await addEntry(paths.journalFile, {
-    feature: manifest.name,
-    target: manifest.target,
-    files: copiedFiles,
-    insertedNav: navInserted,
-    navHref,
-    navLabel,
-    ts: Date.now(),
-    
-    // NEW: Store relevant manifest data
-    manifest: {
-      version: manifest.version,
-      manualSteps: manifest.manualSteps,
-      env: manifest.env,
-      postInstall: manifest.postInstall,
-    },
-  });
-}
-```
-
-
----
-
-## Phase 4: Modification Detection (Priority 4) 🟡
-
-### Goal
-Warn users before deleting files they've modified.
-
-### Technical Approach
-
-#### Step 4.1: Hash files during installation
-
-**File:** `src/core/hash.ts` (NEW)
-
-```typescript
-import { createHash } from 'crypto';
-import { readFile } from 'fs/promises';
-
-export async function hashFile(filePath: string): Promise<string> {
-  try {
-    const content = await readFile(filePath);
-    return createHash('sha256').update(content).digest('hex');
-  } catch (error) {
-    // File doesn't exist or can't be read
-    return '';
-  }
-}
-
-export async function hashFiles(
-  filePaths: string[]
-): Promise<Map<string, string>> {
-  const hashes = new Map<string, string>();
-  
-  await Promise.all(
-    filePaths.map(async (path) => {
-      const hash = await hashFile(path);
-      hashes.set(path, hash);
-    })
-  );
-  
-  return hashes;
-}
-```
-
-#### Step 4.2: Update journal to store hashes
-
-**File:** `src/core/journal.ts`
-
-```typescript
-export interface JournalEntry {
-  feature: string;
-  target: 'native' | 'web';
-  
-  // CHANGE: files is now an array of objects with hashes
-  files: Array<{
-    path: string;
-    hash: string;
-  }>;
-  
-  insertedNav: boolean;
-  navHref?: string;
-  navLabel?: string;
-  ts: number;
-  manifest?: any;
-}
-```
-
-**Gotcha:** This is a breaking change! Need migration for existing journals.
-
-#### Step 4.3: Add migration for old journals
-
-**File:** `src/core/journal.ts`
-
-```typescript
-export async function readJournal(path: string): Promise<Journal> {
-  try {
-    const content = await readFileContent(path);
-    const journal = JSON.parse(content) as Journal;
-    
-    // Migrate old format to new format
-    journal.entries = await Promise.all(
-      journal.entries.map(async (entry) => {
-        // Check if files is old format (array of strings)
-        if (entry.files.length > 0 && typeof entry.files[0] === 'string') {
-          // Migrate to new format
-          const fileHashes = await hashFiles(entry.files as any);
-          
-          entry.files = Array.from(fileHashes.entries()).map(([path, hash]) => ({
-            path,
-            hash,
-          }));
-        }
-        
-        return entry;
-      })
-    );
-    
-    return journal;
-  } catch (err: any) {
-    if (err.code === 'ENOENT') {
-      return { entries: [] };
-    }
-    throw err;
-  }
-}
-```
-
-#### Step 4.4: Hash files during installation
-
-**File:** `src/commands/add.ts`
-
-```typescript
-// After copying files
-
-// Hash all copied files
-log.info('Computing file hashes...');
-const fileHashes = await hashFiles(copiedFiles);
-
-// Update journal with hashes
-if (!options.dryRun) {
-  await addEntry(paths.journalFile, {
-    feature: manifest.name,
-    target: manifest.target,
-    files: Array.from(fileHashes.entries()).map(([path, hash]) => ({
-      path,
-      hash,
-    })),
-    insertedNav: navInserted,
-    navHref,
-    navLabel,
-    ts: Date.now(),
-    manifest: {
-      version: manifest.version,
-      manualSteps: manifest.manualSteps,
-      env: manifest.env,
-      postInstall: manifest.postInstall,
-    },
-  });
-}
-```
-
-#### Step 4.5: Check for modifications during removal
-
-**File:** `src/commands/remove.ts`
-
-```typescript
-// After getting journal entry
-
-// Check for modifications
-log.info('Checking for file modifications...');
-
-const modifiedFiles: Array<{ path: string; status: 'modified' | 'deleted' }> = [];
-
-for (const fileEntry of entry.files) {
-  const currentHash = await hashFile(fileEntry.path);
-  
-  if (currentHash === '') {
-    // File was deleted by user
-    modifiedFiles.push({ path: fileEntry.path, status: 'deleted' });
-  } else if (currentHash !== fileEntry.hash) {
-    // File was modified by user
-    modifiedFiles.push({ path: fileEntry.path, status: 'modified' });
-  }
-}
-
-// Warn about modifications
-if (modifiedFiles.length > 0) {
-  log.plain('');
-  log.warn('⚠ WARNING: The following files were changed:');
-  log.plain('');
-  
-  const modified = modifiedFiles.filter(f => f.status === 'modified');
-  const deleted = modifiedFiles.filter(f => f.status === 'deleted');
-  
-  if (modified.length > 0) {
-    log.plain('  Modified by you:');
-    modified.slice(0, 10).forEach(f => {
-      const relativePath = f.path.replace(paths.cwd + '/', '');
-      log.plain(`    • ${relativePath}`);
-    });
-    if (modified.length > 10) {
-      log.plain(`    ... and ${modified.length - 10} more`);
-    }
-  }
-  
-  if (deleted.length > 0) {
-    log.plain('');
-    log.plain('  Already deleted:');
-    deleted.slice(0, 5).forEach(f => {
-      const relativePath = f.path.replace(paths.cwd + '/', '');
-      log.plain(`    • ${relativePath}`);
-    });
-    if (deleted.length > 5) {
-      log.plain(`    ... and ${deleted.length - 5} more`);
-    }
-  }
-  
-  log.plain('');
-  log.warn('⚠ Your changes will be LOST if you continue!');
-  log.info('💡 Make sure you have committed to Git.');
-  log.plain('');
-  
-  if (!options.force && !options.yes) {
-    const shouldContinue = promptYesNo(
-      'Continue with removal? (y/N): ',
-      false
-    );
-    
-    if (!shouldContinue) {
-      log.info('Removal cancelled');
-      return;
-    }
-  }
-}
-
-// Continue with deletion...
-```
-
-**Performance Gotcha:** Hashing large files can be slow. Need to show progress.
-
-#### Step 4.6: Add progress indicator
-
-**File:** `src/core/hash.ts`
-
-```typescript
-export async function hashFiles(
-  filePaths: string[],
-  options?: { showProgress?: boolean }
-): Promise<Map<string, string>> {
-  const hashes = new Map<string, string>();
-  
-  if (options?.showProgress && filePaths.length > 10) {
-    const { log } = await import('./log.js');
-    log.info(`Hashing ${filePaths.length} files...`);
-  }
-  
-  // Process in batches to avoid overwhelming the system
-  const batchSize = 10;
-  for (let i = 0; i < filePaths.length; i += batchSize) {
-    const batch = filePaths.slice(i, i + batchSize);
-    
-    await Promise.all(
-      batch.map(async (path) => {
-        const hash = await hashFile(path);
-        hashes.set(path, hash);
-      })
-    );
-    
-    if (options?.showProgress && filePaths.length > 10) {
-      const progress = Math.min(i + batchSize, filePaths.length);
-      process.stdout.write(`\r  Progress: ${progress}/${filePaths.length}`);
-    }
-  }
-  
-  if (options?.showProgress && filePaths.length > 10) {
-    process.stdout.write('\n');
-  }
-  
-  return hashes;
-}
-```
-
----
-
-## Phase 5: Additional Commands (Priority 5) 🟢
-
-### vf status command
-
-**File:** `src/commands/status.ts` (NEW)
-
-```typescript
-import { Command } from 'commander';
-import { log } from '../core/log.js';
-import { getPaths } from '../core/paths.js';
-import { readJournal } from '../core/journal.js';
-
-export const statusCommand = new Command('status')
-  .description('Show installed features and their status')
-  .action(async () => {
-    try {
-      const paths = getPaths();
-      const journal = await readJournal(paths.journalFile);
-      
-      if (journal.entries.length === 0) {
-        log.info('No features installed yet');
-        log.info('Run "vf list" to see available features');
-        return;
-      }
-      
-      log.info('Installed features:');
-      log.plain('');
-      
-      for (const entry of journal.entries) {
-        const version = entry.manifest?.version || 'unknown';
-        log.plain(`  ✓ ${entry.feature} (v${version}) - ${entry.target}`);
-        log.plain(`    Files: ${entry.files.length}`);
-        log.plain(`    Installed: ${new Date(entry.ts).toLocaleDateString()}`);
-        
-        if (entry.manifest?.manualSteps) {
-          log.plain(`    ⚠ Has manual setup steps (run: vf checklist ${entry.feature})`);
-        }
-        
-        log.plain('');
-      }
-      
-    } catch (error: any) {
-      log.error(`Failed to show status: ${error.message}`);
-      process.exit(1);
-    }
-  });
-```
-
----
-
-## Testing Strategy
-
-### Unit Tests
-
-**File:** `src/core/__tests__/hash.test.ts` (NEW)
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { hashFile, hashFiles } from '../hash.js';
-import { writeFile, unlink } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('hash', () => {
-  it('should hash file content', async () => {
-    const testFile = join(tmpdir(), 'test-hash.txt');
-    await writeFile(testFile, 'hello world');
-    
-    const hash = await hashFile(testFile);
-    
-    // SHA-256 of "hello world"
-    expect(hash).toBe('b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9');
-    
-    await unlink(testFile);
-  });
-  
-  it('should detect file modifications', async () => {
-    const testFile = join(tmpdir(), 'test-modify.txt');
-    await writeFile(testFile, 'original');
-    
-    const hash1 = await hashFile(testFile);
-    
-    await writeFile(testFile, 'modified');
-    
-    const hash2 = await hashFile(testFile);
-    
-    expect(hash1).not.toBe(hash2);
-    
-    await unlink(testFile);
-  });
-});
-```
-
-### Integration Tests
-
-**File:** `src/__tests__/add-with-deps.test.ts` (NEW)
-
-```typescript
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { executeBash } from '../core/shell.js';
-import { join } from 'path';
-import { mkdtemp, rm } from 'fs/promises';
-import { tmpdir } from 'os';
-
-describe('vf add with dependencies', () => {
-  let testDir: string;
-  
-  beforeEach(async () => {
-    testDir = await mkdtemp(join(tmpdir(), 'vf-test-'));
-    // Setup test repo
-  });
-  
-  afterEach(async () => {
-    await rm(testDir, { recursive: true, force: true });
-  });
-  
-  it('should show required packages', async () => {
-    const result = await executeBash(
-      'vf add charts --dry-run',
-      { cwd: testDir }
-    );
-    
-    expect(result.stdout).toContain('react-native-chart-kit');
-    expect(result.stdout).toContain('Install with:');
-  });
-  
-  it('should install packages with --yes', async () => {
-    const result = await executeBash(
-      'vf add charts --yes',
-      { cwd: testDir }
-    );
-    
-    expect(result.stdout).toContain('Installing packages');
-    expect(result.stdout).toContain('Packages installed successfully');
-  });
-});
-```
-
----
-
-## Rollout Plan
-
-### Week 1: Core Improvements
-- Day 1-2: Interactive confirmation (Phase 1)
-- Day 3-4: Package management (Phase 2)
-- Day 5: Testing and bug fixes
-
-### Week 2: Advanced Features
-- Day 1-2: Manual steps support (Phase 3)
-- Day 3-4: Modification detection (Phase 4)
-- Day 5: Additional commands (Phase 5)
-
-### Week 3: Polish & Release
-- Day 1-2: Integration testing
-- Day 3: Documentation
-- Day 4: Beta testing with real features
-- Day 5: Production release
-
----
-
-## Potential Issues & Solutions
-
-### Issue 1: Monorepo Complexity
-**Problem:** Different workspaces might need different packages
-**Solution:** Detect workspace structure, install in correct location
-
-### Issue 2: Package Installation Failures
-**Problem:** npm install might fail (network, permissions, etc.)
-**Solution:** Catch errors, show manual install command, don't fail the whole operation
-
-### Issue 3: Large Files Hashing
-**Problem:** Hashing 100+ files can be slow
-**Solution:** Batch processing, progress indicator, skip large binary files
-
-### Issue 4: Journal Migration
-**Problem:** Existing journals don't have hashes
-**Solution:** Auto-migrate on read, compute hashes for existing files
-
-### Issue 5: Non-Interactive Environments
-**Problem:** CI/CD doesn't have TTY for prompts
-**Solution:** Check process.stdin.isTTY, default to safe behavior
-
-### Issue 6: Recipe Versioning
-**Problem:** Recipe format changes over time
-**Solution:** Add schema version to recipe.json, handle migrations
-
----
-
-## Recipe Creation Guidelines
-
-### For Recipe Creators
-
-When creating a new recipe, you MUST:
-
-1. **List all dependencies explicitly**
-```json
-{
-  "dependencies": {
-    "npm": {
-      "package-name": "^1.0.0"
-    }
-  }
-}
-```
-
-2. **Add manual steps for services**
-```json
-{
-  "manualSteps": [
-    {
-      "step": 1,
-      "title": "Get API Key",
-      "description": "Sign up and get your API key",
-      "link": "https://service.com/signup"
-    }
-  ]
-}
-```
-
-3. **Document environment variables**
-```json
-{
-  "env": {
-    "required": [
-      {
-        "key": "API_KEY",
-        "description": "Your API key from service.com",
-        "example": "sk_test_123456"
-      }
-    ]
-  }
-}
-```
-
-4. **Test the recipe**
-```bash
-# Create test project
-$ git clone vibefast-starter test-project
-$ cd test-project
-
-# Test installation
-$ vf add your-feature --dry-run
-$ vf add your-feature
-
-# Verify it works
-$ npm run dev
-
-# Test removal
-$ vf remove your-feature
-
-# Verify clean removal
-$ git status
-```
-
----
-
-## Success Metrics
-
-### Before Launch
-- [ ] All 5 phases implemented
-- [ ] 90%+ test coverage
-- [ ] Tested with 5+ real features
-- [ ] Documentation complete
-- [ ] No critical bugs
-
-### After Launch
-- Monitor error rates
-- Track user feedback
-- Measure installation success rate
-- Monitor package installation failures
-
----
-
-## Summary
-
-This is a **2-3 week project** with clear phases:
-
-1. **Interactive confirmation** - Prevent accidental overwrites
-2. **Package management** - Auto-detect and install dependencies
-3. **Manual steps** - Guide users through service setup
-4. **Modification detection** - Warn before deleting user changes
-5. **Additional commands** - Better UX with status, checklist, etc.
-
-The hardest parts are:
-- Monorepo package installation (need to detect workspace structure)
-- Journal migration (breaking change to add hashes)
-- Non-interactive environments (CI/CD compatibility)
-
-But all are solvable with the approaches outlined above.