vibefast-cli 0.4.0 → 0.5.1

package/src/__tests__/integration.test.ts

@@ -0,0 +1,249 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { existsSync, rmSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('VibeFast CLI Integration Tests', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `vibefast-integration-${Date.now()}`);
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('Complete Workflows', () => {
+    it('should complete full init -> add features -> platform add workflow', async () => {
+      // 1. vf init (clean, native-only)
+      // 2. vf add chatbot
+      // 3. vf add image-generator
+      // 4. vf platform add (add web)
+      // 5. vf add quiz --target web
+      // Verify: All features installed correctly
+      // Verify: Both platforms exist
+      // Verify: Project is usable
+      expect(true).toBe(true);
+    });
+
+    it('should complete init with custom features workflow', async () => {
+      // 1. vf init (custom, select: chatbot, charts, image-generator)
+      // 2. Verify all features installed
+      // 3. Verify Vosk model downloaded (if wake-word selected)
+      // 4. Verify env vars detected
+      expect(true).toBe(true);
+    });
+
+    it('should complete platform removal workflow', async () => {
+      // 1. vf init (both platforms)
+      // 2. vf platform remove (remove web)
+      // 3. Verify web removed, native intact
+      // 4. vf platform add (add web back)
+      // 5. Verify web restored
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Feature Installation During Init', () => {
+    it('should install all selected features', async () => {
+      // Verify: chatbot files exist
+      // Verify: image-generator files exist
+      // Verify: charts files exist
+      // Verify: Navigation links added
+      // Verify: Dependencies listed
+      expect(true).toBe(true);
+    });
+
+    it('should handle feature installation failures', async () => {
+      // If one feature fails, others should continue
+      // Verify: Partial installation handled
+      // Verify: Error message shown
+      // Verify: User can retry
+      expect(true).toBe(true);
+    });
+
+    it('should auto-download Vosk for wake-word', async () => {
+      // Select wake-word feature
+      // Verify: Vosk model downloaded
+      // Verify: Model extracted correctly
+      // Verify: Model in correct location
+      expect(true).toBe(true);
+    });
+
+    it('should detect missing environment variables', async () => {
+      // Select chatbot (needs OPENAI_API_KEY)
+      // Verify: Missing vars detected
+      // Verify: User shown what's needed
+      // Verify: Links provided to get keys
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Configuration Management', () => {
+    it('should maintain valid package.json', async () => {
+      // After init, add, remove operations
+      // Verify: package.json is valid JSON
+      // Verify: workspaces array is correct
+      // Verify: No duplicate entries
+      expect(true).toBe(true);
+    });
+
+    it('should maintain valid turbo.json', async () => {
+      // After init, add, remove operations
+      // Verify: turbo.json is valid JSON
+      // Verify: pipeline tasks are correct
+      // Verify: No orphaned tasks
+      expect(true).toBe(true);
+    });
+
+    it('should handle concurrent operations safely', async () => {
+      // Run multiple operations in sequence
+      // Verify: No race conditions
+      // Verify: Configurations stay consistent
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('User Input Handling', () => {
+    it('should handle back navigation in menus', async () => {
+      // In init menu, select back
+      // Verify: Goes to previous menu
+      // Verify: Can navigate back multiple times
+      expect(true).toBe(true);
+    });
+
+    it('should handle Ctrl+C gracefully', async () => {
+      // During init, press Ctrl+C
+      // Verify: Process exits cleanly
+      // Verify: No partial files left
+      expect(true).toBe(true);
+    });
+
+    it('should validate user inputs', async () => {
+      // Try invalid project names
+      // Try empty selections
+      // Verify: Shows error messages
+      // Verify: Prompts again
+      expect(true).toBe(true);
+    });
+
+    it('should handle --yes flag correctly', async () => {
+      // Run with --yes flag
+      // Verify: Skips all prompts
+      // Verify: Uses defaults
+      // Verify: Completes successfully
+      expect(true).toBe(true);
+    });
+
+    it('should handle --dry-run flag', async () => {
+      // Run vf add with --dry-run
+      // Verify: Shows what would happen
+      // Verify: No files created
+      // Verify: No changes made
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('File System Operations', () => {
+    it('should create correct directory structure', async () => {
+      // After init
+      // Verify: apps/native exists (if selected)
+      // Verify: apps/web exists (if selected)
+      // Verify: packages/backend exists
+      // Verify: packages/ui exists
+      expect(true).toBe(true);
+    });
+
+    it('should handle file conflicts', async () => {
+      // Try to init in existing directory
+      // Verify: Shows error
+      // Verify: Doesn't overwrite
+      expect(true).toBe(true);
+    });
+
+    it('should clean up temporary files', async () => {
+      // After operations
+      // Verify: No .temp-* directories left
+      // Verify: No orphaned files
+      expect(true).toBe(true);
+    });
+
+    it('should handle permission errors', async () => {
+      // Try to write to read-only directory
+      // Verify: Shows error
+      // Verify: Doesn't crash
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Dependency Management', () => {
+    it('should install dependencies correctly', async () => {
+      // After init
+      // Verify: pnpm install runs
+      // Verify: node_modules created
+      // Verify: All deps installed
+      expect(true).toBe(true);
+    });
+
+    it('should handle missing pnpm', async () => {
+      // If pnpm not installed
+      // Verify: Offers to install
+      // Verify: Provides instructions
+      expect(true).toBe(true);
+    });
+
+    it('should update dependencies on platform add', async () => {
+      // After platform add
+      // Verify: New platform deps installed
+      // Verify: No conflicts
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Cross-Platform Paths', () => {
+    it('should handle Windows paths correctly', async () => {
+      // Verify: Path separators handled
+      // Verify: No hardcoded slashes
+      // Verify: Using path.join()
+      expect(true).toBe(true);
+    });
+
+    it('should handle Linux paths correctly', async () => {
+      // Verify: Paths work on Linux
+      // Verify: Permissions handled
+      expect(true).toBe(true);
+    });
+
+    it('should handle macOS paths correctly', async () => {
+      // Verify: Paths work on macOS
+      // Verify: Case sensitivity handled
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Error Recovery', () => {
+    it('should recover from network errors', async () => {
+      // Simulate network failure during download
+      // Verify: Shows error
+      // Verify: Suggests retry
+      expect(true).toBe(true);
+    });
+
+    it('should recover from corrupted downloads', async () => {
+      // Simulate corrupted zip file
+      // Verify: Shows error
+      // Verify: Cleans up
+      expect(true).toBe(true);
+    });
+
+    it('should recover from partial installations', async () => {
+      // Simulate failure mid-installation
+      // Verify: Can retry
+      // Verify: Doesn't duplicate
+      expect(true).toBe(true);
+    });
+  });
+});

package/src/__tests__/recipes.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect } from 'vitest';
+import { RECIPES, getRecipesByCategory, getRecipeInfo } from '../core/recipes.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+describe('Recipe System', () => {
+  describe('Recipe Metadata', () => {
+    it('should have all 10 features defined', () => {
+      const features = getRecipesByCategory('feature');
+      expect(features).toHaveLength(10);
+    });
+
+    it('should include ios-widget in features', () => {
+      const features = getRecipesByCategory('feature');
+      const widget = features.find(f => f.name === 'ios-widget');
+      
+      expect(widget).toBeDefined();
+      expect(widget?.name).toBe('ios-widget');
+      expect(widget?.description).toBe('iOS Home Screen widgets with Live Activities');
+      expect(widget?.icon).toBe('📱');
+      expect(widget?.category).toBe('feature');
+    });
+
+    it('should have all expected features', () => {
+      const features = getRecipesByCategory('feature');
+      const featureNames = features.map(f => f.name);
+      
+      expect(featureNames).toContain('audio-recorder');
+      expect(featureNames).toContain('charts');
+      expect(featureNames).toContain('chatbot');
+      expect(featureNames).toContain('image-analysis');
+      expect(featureNames).toContain('image-generator');
+      expect(featureNames).toContain('quiz');
+      expect(featureNames).toContain('tracker-app');
+      expect(featureNames).toContain('voice-bot');
+      expect(featureNames).toContain('wake-word');
+      expect(featureNames).toContain('ios-widget');
+    });
+
+    it('should get recipe info by name', () => {
+      const widget = getRecipeInfo('ios-widget');
+      expect(widget).toBeDefined();
+      expect(widget?.name).toBe('ios-widget');
+    });
+
+    it('should return undefined for non-existent recipe', () => {
+      const fake = getRecipeInfo('non-existent-feature');
+      expect(fake).toBeUndefined();
+    });
+  });
+
+  describe('Recipe Files', () => {
+    const getRecipesDir = () => {
+      // When running from vibefast-cli directory
+      if (existsSync(join(process.cwd(), 'recipes'))) {
+        return join(process.cwd(), 'recipes');
+      }
+      // When running from monorepo root
+      return join(process.cwd(), 'vibefast-cli/recipes');
+    };
+
+    it('should have recipe.json for ios-widget', () => {
+      const recipesDir = getRecipesDir();
+      const recipePath = join(recipesDir, 'ios-widget/recipe.json');
+      expect(existsSync(recipePath)).toBe(true);
+    });
+
+    it('should have zip file for ios-widget', () => {
+      const recipesDir = getRecipesDir();
+      const zipPath = join(recipesDir, 'ios-widget@latest.zip');
+      expect(existsSync(zipPath)).toBe(true);
+    });
+
+    it('should have recipe.json for all features', () => {
+      const recipesDir = getRecipesDir();
+      const features = getRecipesByCategory('feature');
+      
+      for (const feature of features) {
+        const recipePath = join(recipesDir, `${feature.name}/recipe.json`);
+        expect(existsSync(recipePath), `${feature.name} recipe.json should exist`).toBe(true);
+      }
+    });
+
+    it('should have zip files for all features', () => {
+      const recipesDir = getRecipesDir();
+      const features = getRecipesByCategory('feature');
+      
+      for (const feature of features) {
+        const zipPath = join(recipesDir, `${feature.name}@latest.zip`);
+        expect(existsSync(zipPath), `${feature.name} zip should exist`).toBe(true);
+      }
+    });
+  });
+
+  describe('Recipe Content', () => {
+    const getRecipesDir = () => {
+      if (existsSync(join(process.cwd(), 'recipes'))) {
+        return join(process.cwd(), 'recipes');
+      }
+      return join(process.cwd(), 'vibefast-cli/recipes');
+    };
+
+    it('should have valid recipe.json for ios-widget', () => {
+      const { readFileSync } = require('fs');
+      const recipesDir = getRecipesDir();
+      const recipePath = join(recipesDir, 'ios-widget/recipe.json');
+      const content = readFileSync(recipePath, 'utf-8');
+      const recipe = JSON.parse(content);
+      
+      expect(recipe.name).toBe('ios-widget');
+      expect(recipe.version).toBe('1.0.0');
+      expect(recipe.description).toBe('iOS Home Screen widgets with Live Activities');
+      expect(recipe.platforms).toContain('native');
+      expect(recipe.files).toBeDefined();
+      expect(recipe.files.length).toBeGreaterThan(0);
+    });
+
+    it('should have dependencies for ios-widget', () => {
+      const { readFileSync } = require('fs');
+      const recipesDir = getRecipesDir();
+      const recipePath = join(recipesDir, 'ios-widget/recipe.json');
+      const content = readFileSync(recipePath, 'utf-8');
+      const recipe = JSON.parse(content);
+      
+      expect(recipe.dependencies).toBeDefined();
+      expect(recipe.dependencies.npm).toContain('@bacons/apple-targets');
+    });
+
+    it('should have manual steps for ios-widget', () => {
+      const { readFileSync } = require('fs');
+      const recipesDir = getRecipesDir();
+      const recipePath = join(recipesDir, 'ios-widget/recipe.json');
+      const content = readFileSync(recipePath, 'utf-8');
+      const recipe = JSON.parse(content);
+      
+      expect(recipe.manualSteps).toBeDefined();
+      expect(recipe.manualSteps.length).toBeGreaterThan(0);
+      
+      const pluginStep = recipe.manualSteps.find((s: any) => s.title.includes('Widget Plugin'));
+      expect(pluginStep).toBeDefined();
+      expect(pluginStep.file).toBe('apps/native/app.config.ts');
+    });
+
+    it('should have post-install instructions for ios-widget', () => {
+      const { readFileSync } = require('fs');
+      const recipesDir = getRecipesDir();
+      const recipePath = join(recipesDir, 'ios-widget/recipe.json');
+      const content = readFileSync(recipePath, 'utf-8');
+      const recipe = JSON.parse(content);
+      
+      expect(recipe.postInstall).toBeDefined();
+      expect(recipe.postInstall.instructions).toBeDefined();
+      expect(recipe.postInstall.instructions.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Recipe Categories', () => {
+    it('should only have feature category (no advanced-ui yet)', () => {
+      const advancedUI = getRecipesByCategory('advanced-ui');
+      expect(advancedUI).toHaveLength(0);
+    });
+
+    it('should have all recipes in RECIPES array', () => {
+      expect(RECIPES.length).toBeGreaterThan(0);
+      expect(RECIPES.length).toBe(10); // 10 features
+    });
+  });
+});

package/src/commands/__tests__/init.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { existsSync, rmSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// Mock the external dependencies
+vi.mock('simple-git');
+vi.mock('../core/log.js');
+vi.mock('../core/spinner.js');
+vi.mock('../core/prompt.js');
+
+describe('vf init command', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `vibefast-test-${Date.now()}`);
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('Clean Mode', () => {
+    it('should create clean native-only project', async () => {
+      // This would be tested with mocked git clone
+      // Verify: apps/native exists, apps/web doesn't
+      expect(true).toBe(true); // Placeholder
+    });
+
+    it('should create clean web-only project', async () => {
+      // Verify: apps/web exists, apps/native doesn't
+      expect(true).toBe(true);
+    });
+
+    it('should create clean both-platforms project', async () => {
+      // Verify: both apps/native and apps/web exist
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Custom Mode', () => {
+    it('should select and install features', async () => {
+      // Verify: selected features are installed
+      // Verify: feature files exist in correct locations
+      expect(true).toBe(true);
+    });
+
+    it('should handle feature installation failures gracefully', async () => {
+      // Verify: continues with other features if one fails
+      // Verify: shows error message
+      expect(true).toBe(true);
+    });
+
+    it('should auto-download Vosk model for wake-word', async () => {
+      // Verify: Vosk model is downloaded
+      // Verify: model is extracted to correct location
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Configuration Updates', () => {
+    it('should update package.json workspaces correctly', async () => {
+      // Verify: workspaces array contains correct platforms
+      expect(true).toBe(true);
+    });
+
+    it('should update turbo.json with platform tasks', async () => {
+      // Verify: turbo.json has correct pipeline tasks
+      expect(true).toBe(true);
+    });
+
+    it('should remove unwanted platform tasks from turbo.json', async () => {
+      // Verify: web tasks removed if web-only
+      // Verify: native tasks removed if native-only
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Environment Setup', () => {
+    it('should create .env files from examples', async () => {
+      // Verify: .env.local, .env.staging, .env.production created
+      expect(true).toBe(true);
+    });
+
+    it('should detect missing environment variables', async () => {
+      // Verify: shows missing vars for selected features
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle invalid project names', async () => {
+      // Verify: error message shown
+      // Verify: process exits gracefully
+      expect(true).toBe(true);
+    });
+
+    it('should handle existing directory conflicts', async () => {
+      // Verify: error message shown
+      // Verify: doesn't overwrite
+      expect(true).toBe(true);
+    });
+
+    it('should handle missing license key', async () => {
+      // Verify: prompts for license key
+      // Verify: validates key format
+      expect(true).toBe(true);
+    });
+  });
+});

package/src/commands/__tests__/platform.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { existsSync, rmSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+vi.mock('simple-git');
+vi.mock('../core/log.js');
+vi.mock('../core/spinner.js');
+vi.mock('../core/prompt.js');
+
+describe('vf platform command', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `vibefast-platform-test-${Date.now()}`);
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('platform add', () => {
+    it('should add web platform to native-only project', async () => {
+      // Setup: Create native-only project
+      // Action: vf platform add (choose web)
+      // Verify: apps/web exists
+      // Verify: package.json has both workspaces
+      // Verify: turbo.json has web tasks
+      expect(true).toBe(true);
+    });
+
+    it('should add native platform to web-only project', async () => {
+      // Setup: Create web-only project
+      // Action: vf platform add (choose native)
+      // Verify: apps/native exists
+      // Verify: package.json has both workspaces
+      // Verify: turbo.json has native tasks
+      expect(true).toBe(true);
+    });
+
+    it('should show error if both platforms exist', async () => {
+      // Setup: Create both-platform project
+      // Action: vf platform add
+      // Verify: Shows "Both platforms already exist"
+      expect(true).toBe(true);
+    });
+
+    it('should update configurations correctly', async () => {
+      // Verify: package.json workspaces updated
+      // Verify: turbo.json pipeline updated
+      // Verify: No duplicate entries
+      expect(true).toBe(true);
+    });
+
+    it('should handle clone failures gracefully', async () => {
+      // Verify: Shows error message
+      // Verify: No partial files left
+      // Verify: Cleans up temp directory
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('platform remove', () => {
+    it('should remove web platform from both-platform project', async () => {
+      // Setup: Create both-platform project
+      // Action: vf platform remove (choose web)
+      // Verify: apps/web removed
+      // Verify: apps/native still exists
+      // Verify: package.json updated
+      // Verify: turbo.json updated
+      expect(true).toBe(true);
+    });
+
+    it('should remove native platform from both-platform project', async () => {
+      // Setup: Create both-platform project
+      // Action: vf platform remove (choose native)
+      // Verify: apps/native removed
+      // Verify: apps/web still exists
+      // Verify: Configurations updated
+      expect(true).toBe(true);
+    });
+
+    it('should prevent removing only platform', async () => {
+      // Setup: Create native-only project
+      // Action: vf platform remove
+      // Verify: Shows error "Cannot remove the only platform"
+      // Verify: No changes made
+      expect(true).toBe(true);
+    });
+
+    it('should require confirmation before removing', async () => {
+      // Setup: Create both-platform project
+      // Action: vf platform remove (choose web, then cancel)
+      // Verify: Platform not removed
+      // Verify: Shows confirmation prompt
+      expect(true).toBe(true);
+    });
+
+    it('should skip confirmation with --yes flag', async () => {
+      // Setup: Create both-platform project
+      // Action: vf platform remove --yes
+      // Verify: Platform removed without prompt
+      expect(true).toBe(true);
+    });
+
+    it('should clean up configurations', async () => {
+      // Verify: Removed platform tasks from turbo.json
+      // Verify: Removed platform from package.json workspaces
+      // Verify: No orphaned entries
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle non-VibeFast projects', async () => {
+      // Setup: Create regular directory
+      // Action: vf platform add
+      // Verify: Shows "Not a VibeFast project"
+      expect(true).toBe(true);
+    });
+
+    it('should handle missing .vibefast directory', async () => {
+      // Verify: Shows appropriate error
+      expect(true).toBe(true);
+    });
+
+    it('should handle corrupted package.json', async () => {
+      // Verify: Shows error
+      // Verify: Doesn't crash
+      expect(true).toBe(true);
+    });
+
+    it('should handle corrupted turbo.json', async () => {
+      // Verify: Shows error
+      // Verify: Doesn't crash
+      expect(true).toBe(true);
+    });
+  });
+});

package/src/commands/add.ts

@@ -57,11 +57,10 @@ export const addCommand = new Command('add')
     log.plain('');
     log.info('Examples:');
     log.plain('  vf add                    # Interactive menu');
-    log.plain('  vf add feature            # Show all features');
-    log.plain('  vf add integration        # Show all integrations');
-    log.plain('  vf add charts             # Add specific feature');
-    log.plain('  vf add sentry --target native');
-    log.plain('  vf add chatbot --dry-run');
+    log.plain('  vf add chatbot            # Add specific feature');
+    log.plain('  vf add chatbot --dry-run  # Preview changes');
+    log.plain('  vf add chatbot --force    # Force reinstall');
+    log.plain('  vf add chatbot --yes      # Skip prompts');
   })
   .action(async (feature: string | undefined, options) => {
     try {