vibefast-cli 0.4.0 → 0.5.1

package/src/commands/init.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { log } from '../core/log.js';
 import { withSpinner } from '../core/spinner.js';
-import { promptSelect, promptInput, promptConfirm } from '../core/prompts.js';
+import { promptSelectAsync, promptMultiSelectAsync, promptUser, promptYesNo } from '../core/prompt.js';
 import { detectPackageManager } from '../core/detect.js';
 import simpleGit from 'simple-git';
 import { existsSync } from 'fs';
@@ -42,17 +42,17 @@ export const initCommand = new Command('init')
       let selectedFeatures: string[] = [];
       
       if (!options.yes) {
-        starterType = await promptSelect(
+        starterType = await promptSelectAsync(
           'How would you like to start?',
           [
             {
-              name: 'Clean',
               value: 'clean',
+              label: 'Clean',
               description: 'Minimal setup - add features later with vf add',
             },
             {
-              name: 'Custom',
               value: 'custom',
+              label: 'Custom',
               description: 'Choose features now - one-shot setup',
             },
           ]
@@ -100,22 +100,22 @@ export const initCommand = new Command('init')
       let platforms: string[] = ['native', 'web'];
       
       if (!options.yes) {
-        const platformChoice = await promptSelect(
+        const platformChoice = await promptSelectAsync(
           'Which platforms do you want to include?',
           [
             {
-              name: 'Both (Native + Web)',
               value: 'both',
+              label: 'Both (Native + Web)',
               description: 'Full monorepo with mobile and web app',
             },
             {
-              name: 'Native Only (Expo)',
               value: 'native',
+              label: 'Native Only (Expo)',
               description: 'Mobile app only (iOS & Android)',
             },
             {
-              name: 'Web Only (Next.js)',
               value: 'web',
+              label: 'Web Only (Next.js)',
               description: 'Web app only',
             },
           ]
@@ -142,10 +142,9 @@ export const initCommand = new Command('init')
       let projectName = defaultName;
       
       if (!options.yes) {
-        projectName = await promptInput(
-          'Project name:',
-          defaultName
-        );
+        projectName = await promptUser(
+          'Project name: '
+        ) || defaultName;
       }
 
       // Validate project name
@@ -300,7 +299,7 @@ export const initCommand = new Command('init')
           log.warn('pnpm is not installed');
           log.plain('');
           
-          const shouldInstallPnpm = options.yes || await promptConfirm(
+          const shouldInstallPnpm = options.yes || await promptYesNo(
             'Would you like to install pnpm globally?',
             true
           );
@@ -383,7 +382,7 @@ export const initCommand = new Command('init')
         log.plain('  • Configure Convex Auth');
         log.plain('');
         
-        const runSetup = options.yes || await promptConfirm(
+        const runSetup = options.yes || await promptYesNo(
           'Would you like to run the starter setup now?',
           true
         );
@@ -567,7 +566,7 @@ export const initCommand = new Command('init')
           process.exit(1);
         }
         
-        licenseKey = await promptInput('Enter your license key:');
+        licenseKey = await promptUser('Enter your license key: ');
         
         if (!licenseKey || licenseKey.trim() === '') {
           log.error('License key cannot be empty');

package/src/commands/platform.ts

@@ -0,0 +1,309 @@
+import { Command } from 'commander';
+import { log } from '../core/log.js';
+import { withSpinner } from '../core/spinner.js';
+import { promptSelectAsync } from '../core/prompt.js';
+import { existsSync, rmSync } from 'fs';
+import { join } from 'path';
+import simpleGit from 'simple-git';
+
+interface PlatformOptions {
+  yes?: boolean;
+}
+
+export const platformCommand = new Command('platform')
+  .description('Manage platforms in your VibeFast project')
+  .addCommand(
+    new Command('add')
+      .description('Add a missing platform to your project')
+      .option('--yes', 'Skip confirmation prompts')
+      .action(async (options: PlatformOptions) => {
+        try {
+          const paths = await import('../core/paths.js').then(m => m.getPaths());
+          
+          // Check if we're in a VibeFast project
+          if (!existsSync(join(paths.cwd, '.vibefast'))) {
+            log.error('Not a VibeFast project. Run this from your VibeFast project root.');
+            process.exit(1);
+          }
+
+          // Check what platforms currently exist
+          const hasNative = existsSync(join(paths.cwd, 'apps/native'));
+          const hasWeb = existsSync(join(paths.cwd, 'apps/web'));
+
+          if (hasNative && hasWeb) {
+            log.info('✓ Both platforms already exist');
+            process.exit(0);
+          }
+
+          // Determine what can be added
+          const availablePlatforms = [];
+          if (!hasNative) availablePlatforms.push({ value: 'native', label: '📱 Native (Expo)' });
+          if (!hasWeb) availablePlatforms.push({ value: 'web', label: '🌐 Web (Next.js)' });
+
+          if (availablePlatforms.length === 0) {
+            log.info('✓ All platforms already exist');
+            process.exit(0);
+          }
+
+          log.plain('');
+          log.info('Available platforms to add:');
+          log.plain('');
+
+          const platformToAdd = await promptSelectAsync(
+            'Which platform would you like to add?',
+            availablePlatforms
+          );
+
+          if (!platformToAdd) {
+            log.info('Cancelled');
+            process.exit(0);
+          }
+
+          log.plain('');
+          log.info(`Adding ${platformToAdd === 'native' ? 'Native (Expo)' : 'Web (Next.js)'} platform...`);
+          log.plain('');
+
+          // Clone the platform from the clean branch
+          const repoUrl = 'https://github.com/mzafarr/vibefast-pro.git';
+          const tempDir = join(paths.cwd, '.temp-platform-clone');
+
+          await withSpinner(
+            `Cloning ${platformToAdd} platform...`,
+            async () => {
+              const git = simpleGit();
+              const cloneOptions = ['--depth', '1', '--branch', 'clean', '--single-branch', '--sparse'];
+              
+              try {
+                await git.clone(repoUrl, tempDir, cloneOptions);
+                
+                // Sparse checkout only the platform we need
+                const sparseGit = simpleGit(tempDir);
+                await sparseGit.raw(['sparse-checkout', 'set', `apps/${platformToAdd}`]);
+              } catch (error: any) {
+                throw new Error(`Failed to clone platform: ${error.message}`);
+              }
+            },
+            {
+              successText: `✓ Platform cloned`,
+            }
+          );
+
+          // Copy the platform to the project
+          await withSpinner(
+            `Setting up ${platformToAdd} platform...`,
+            async () => {
+              const { copyFileSync } = await import('fs');
+              const { cp } = await import('fs/promises');
+              
+              const sourcePath = join(tempDir, 'apps', platformToAdd);
+              const destPath = join(paths.cwd, 'apps', platformToAdd);
+
+              if (existsSync(sourcePath)) {
+                await cp(sourcePath, destPath, { recursive: true });
+              } else {
+                throw new Error(`Platform directory not found in clone`);
+              }
+
+              // Update package.json workspaces
+              const packageJsonPath = join(paths.cwd, 'package.json');
+              if (existsSync(packageJsonPath)) {
+                const { readFileSync, writeFileSync } = await import('fs');
+                const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+                
+                if (packageJson.workspaces && !packageJson.workspaces.includes(`apps/${platformToAdd}`)) {
+                  packageJson.workspaces.push(`apps/${platformToAdd}`);
+                  writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+                }
+              }
+
+              // Update turbo.json
+              const turboJsonPath = join(paths.cwd, 'turbo.json');
+              if (existsSync(turboJsonPath)) {
+                const { readFileSync, writeFileSync } = await import('fs');
+                const turboJson = JSON.parse(readFileSync(turboJsonPath, 'utf-8'));
+                
+                if (turboJson.pipeline) {
+                  // Add platform-specific tasks if they don't exist
+                  if (platformToAdd === 'native') {
+                    if (!turboJson.pipeline['dev:native']) {
+                      turboJson.pipeline['dev:native'] = { cache: false };
+                    }
+                    if (!turboJson.pipeline['native:*']) {
+                      turboJson.pipeline['native:*'] = { cache: false };
+                    }
+                  } else if (platformToAdd === 'web') {
+                    if (!turboJson.pipeline['dev:web']) {
+                      turboJson.pipeline['dev:web'] = { cache: false };
+                    }
+                    if (!turboJson.pipeline['web:*']) {
+                      turboJson.pipeline['web:*'] = { cache: false };
+                    }
+                  }
+                  
+                  writeFileSync(turboJsonPath, JSON.stringify(turboJson, null, 2));
+                }
+              }
+
+              // Clean up temp directory
+              if (existsSync(tempDir)) {
+                rmSync(tempDir, { recursive: true, force: true });
+              }
+            },
+            {
+              successText: `✓ Platform setup complete`,
+            }
+          );
+
+          log.plain('');
+          log.success(`✓ ${platformToAdd === 'native' ? 'Native' : 'Web'} platform added successfully!`);
+          log.plain('');
+          log.info('Next steps:');
+          log.plain('  1. Install dependencies:');
+          log.plain('     pnpm install');
+          log.plain('');
+          if (platformToAdd === 'native') {
+            log.plain('  2. Start developing:');
+            log.plain('     pnpm dev:native');
+            log.plain('     pnpm native:ios');
+            log.plain('     pnpm native:android');
+          } else {
+            log.plain('  2. Start developing:');
+            log.plain('     pnpm dev:web');
+          }
+          log.plain('');
+
+        } catch (error: any) {
+          log.plain('');
+          log.error(`Failed to add platform: ${error.message}`);
+          process.exit(1);
+        }
+      })
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Remove a platform from your project')
+      .option('--yes', 'Skip confirmation prompts')
+      .action(async (options: PlatformOptions) => {
+        try {
+          const paths = await import('../core/paths.js').then(m => m.getPaths());
+          
+          // Check if we're in a VibeFast project
+          if (!existsSync(join(paths.cwd, '.vibefast'))) {
+            log.error('Not a VibeFast project. Run this from your VibeFast project root.');
+            process.exit(1);
+          }
+
+          // Check what platforms currently exist
+          const hasNative = existsSync(join(paths.cwd, 'apps/native'));
+          const hasWeb = existsSync(join(paths.cwd, 'apps/web'));
+
+          if (!hasNative && !hasWeb) {
+            log.error('No platforms found to remove');
+            process.exit(1);
+          }
+
+          // Determine what can be removed
+          const removablePlatforms = [];
+          if (hasNative) removablePlatforms.push({ value: 'native', label: '📱 Native (Expo)' });
+          if (hasWeb) removablePlatforms.push({ value: 'web', label: '🌐 Web (Next.js)' });
+
+          if (removablePlatforms.length === 1) {
+            log.error('Cannot remove the only platform. You must have at least one platform.');
+            process.exit(1);
+          }
+
+          log.plain('');
+          log.info('Platforms you can remove:');
+          log.plain('');
+
+          const platformToRemove = await promptSelectAsync(
+            'Which platform would you like to remove?',
+            removablePlatforms
+          );
+
+          if (!platformToRemove) {
+            log.info('Cancelled');
+            process.exit(0);
+          }
+
+          log.plain('');
+          log.warn(`⚠ This will remove the ${platformToRemove === 'native' ? 'Native' : 'Web'} platform and all its files.`);
+          
+          const { promptYesNo } = await import('../core/prompt.js');
+          const confirmed = options.yes || await promptYesNo('Are you sure?', false);
+
+          if (!confirmed) {
+            log.info('Cancelled');
+            process.exit(0);
+          }
+
+          log.plain('');
+
+          await withSpinner(
+            `Removing ${platformToRemove} platform...`,
+            async () => {
+              const platformPath = join(paths.cwd, 'apps', platformToRemove);
+              
+              if (existsSync(platformPath)) {
+                rmSync(platformPath, { recursive: true, force: true });
+              }
+
+              // Update package.json workspaces
+              const packageJsonPath = join(paths.cwd, 'package.json');
+              if (existsSync(packageJsonPath)) {
+                const { readFileSync, writeFileSync } = await import('fs');
+                const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+                
+                if (packageJson.workspaces) {
+                  packageJson.workspaces = packageJson.workspaces.filter(
+                    (ws: string) => !ws.includes(`apps/${platformToRemove}`)
+                  );
+                  writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+                }
+              }
+
+              // Update turbo.json
+              const turboJsonPath = join(paths.cwd, 'turbo.json');
+              if (existsSync(turboJsonPath)) {
+                const { readFileSync, writeFileSync } = await import('fs');
+                const turboJson = JSON.parse(readFileSync(turboJsonPath, 'utf-8'));
+                
+                if (turboJson.pipeline) {
+                  const tasksToRemove: string[] = [];
+                  
+                  if (platformToRemove === 'native') {
+                    tasksToRemove.push('native:*', 'dev:native', 'build:native');
+                  } else {
+                    tasksToRemove.push('web:*', 'dev:web', 'build:web');
+                  }
+                  
+                  tasksToRemove.forEach(task => {
+                    if (turboJson.pipeline[task]) {
+                      delete turboJson.pipeline[task];
+                    }
+                  });
+                  
+                  writeFileSync(turboJsonPath, JSON.stringify(turboJson, null, 2));
+                }
+              }
+            },
+            {
+              successText: `✓ Platform removed`,
+            }
+          );
+
+          log.plain('');
+          log.success(`✓ ${platformToRemove === 'native' ? 'Native' : 'Web'} platform removed successfully!`);
+          log.plain('');
+          log.info('Next steps:');
+          log.plain('  1. Clean up dependencies:');
+          log.plain('     pnpm install');
+          log.plain('');
+
+        } catch (error: any) {
+          log.plain('');
+          log.error(`Failed to remove platform: ${error.message}`);
+          process.exit(1);
+        }
+      })
+  );

package/src/core/journal.ts

@@ -30,35 +30,52 @@ export async function readJournal(journalPath: string): Promise<Journal> {
   if (!(await exists(journalPath))) {
     return { entries: [] };
   }
-  const content = await readFileContent(journalPath);
-  const journal = JSON.parse(content) as Journal;
   
-  // Migrate old format to new format
-  let needsMigration = false;
-  
-  for (const entry of journal.entries) {
-    if (entry.files.length > 0 && typeof entry.files[0] === 'string') {
-      needsMigration = true;
-      // Old format: array of strings
-      const oldFiles = entry.files as string[];
-      
-      // Convert to new format with hashes
-      const newFiles: FileEntry[] = [];
-      for (const filePath of oldFiles) {
-        const hash = await hashFile(filePath);
-        newFiles.push({ path: filePath, hash });
+  try {
+    const content = await readFileContent(journalPath);
+    const journal = JSON.parse(content) as Journal;
+    
+    // Ensure entries is an array
+    if (!journal.entries || !Array.isArray(journal.entries)) {
+      console.warn('Invalid journal format, resetting to empty journal');
+      return { entries: [] };
+    }
+    
+    // Migrate old format to new format
+    let needsMigration = false;
+    
+    for (const entry of journal.entries) {
+      if (entry.files && entry.files.length > 0 && typeof entry.files[0] === 'string') {
+        needsMigration = true;
+        // Old format: array of strings
+        const oldFiles = entry.files as string[];
+        
+        // Convert to new format with hashes
+        const newFiles: FileEntry[] = [];
+        for (const filePath of oldFiles) {
+          try {
+            const hash = await hashFile(filePath);
+            newFiles.push({ path: filePath, hash });
+          } catch (err) {
+            // File might not exist anymore, skip it
+            console.warn(`Could not hash file ${filePath}, skipping`);
+          }
+        }
+        
+        entry.files = newFiles;
       }
-      
-      entry.files = newFiles;
     }
+    
+    // Save migrated journal
+    if (needsMigration) {
+      await writeJournal(journalPath, journal);
+    }
+    
+    return journal;
+  } catch (err) {
+    console.warn('Failed to read journal, resetting to empty journal:', err);
+    return { entries: [] };
   }
-  
-  // Save migrated journal
-  if (needsMigration) {
-    await writeJournal(journalPath, journal);
-  }
-  
-  return journal;
 }
 
 export async function writeJournal(journalPath: string, journal: Journal): Promise<void> {

package/src/core/recipes.ts

@@ -70,49 +70,17 @@ export const RECIPES: RecipeInfo[] = [
     description: 'Wake word detection with Vosk',
     icon: '🎙️',
   },
-  
-  // Advanced UI Components
   {
-    name: 'glowing-button',
-    category: 'advanced-ui',
-    description: 'Animated glowing button with shimmer effect',
-    icon: '✨',
-  },
-  {
-    name: 'animated-switch',
-    category: 'advanced-ui',
-    description: 'Smooth animated toggle switch',
-    icon: '🎚️',
-  },
-  {
-    name: 'animated-chip',
-    category: 'advanced-ui',
-    description: 'Animated chip/tag component with press effects',
-    icon: '🏷️',
-  },
-  {
-    name: 'number-stepper',
-    category: 'advanced-ui',
-    description: 'Number input with +/- buttons',
-    icon: '🔢',
-  },
-  {
-    name: 'progress-circle',
-    category: 'advanced-ui',
-    description: 'Circular progress indicator with animation',
-    icon: '⭕',
-  },
-  {
-    name: 'swipe-slider',
-    category: 'advanced-ui',
-    description: 'Interactive swipe-to-confirm slider',
-    icon: '👆',
+    name: 'ios-widget',
+    category: 'feature',
+    description: 'iOS Home Screen widgets with Live Activities',
+    icon: '📱',
   },
   {
-    name: 'timeline',
-    category: 'advanced-ui',
-    description: 'Activity timeline view for feeds',
-    icon: '📅',
+    name: 'payments',
+    category: 'feature',
+    description: 'In-app purchases and subscriptions with RevenueCat',
+    icon: '💳',
   },
 ];
 

package/src/index.ts

@@ -14,6 +14,7 @@ import { statusCommand } from './commands/status.js';
 import { checklistCommand } from './commands/checklist.js';
 import { envCommand } from './commands/env.js';
 import { healthCommand } from './commands/health.js';
+import { platformCommand } from './commands/platform.js';
 import { log } from './core/log.js';
 import { showCommandHint } from './core/errors.js';
 
@@ -32,6 +33,7 @@ program.addCommand(doctorCommand);
 program.addCommand(listCommand);
 program.addCommand(addCommand);
 program.addCommand(removeCommand);
+program.addCommand(platformCommand);
 program.addCommand(statusCommand);
 program.addCommand(checklistCommand);
 program.addCommand(envCommand);