vibefast-cli 0.2.4 → 0.3.1

package/src/commands/add.ts

@@ -12,6 +12,9 @@ import { ensureWithinBase } from '../core/pathGuard.js';
 import { extractZipSafe } from '../core/archive.js';
 import { hashFiles } from '../core/hash.js';
 import { promptYesNo } from '../core/prompt.js';
+import { detectTarget } from '../core/detect.js';
+import { withSpinner } from '../core/spinner.js';
+import { showCommandHint } from '../core/errors.js';
 
 interface RecipeManifest {
   name: string;
@@ -43,16 +46,145 @@ interface RecipeManifest {
 }
 
 export const addCommand = new Command('add')
-  .description('Add a VibeFast feature to your project')
-  .argument('<feature>', 'Feature name to install')
+  .description('Add VibeFast features, UI components, or integrations')
+  .argument('[feature]', 'Feature name to install (optional - will show interactive menu if omitted)')
   .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) => {
+  .option('--category <category>', 'Filter by category (feature, ui, integration)')
+  .on('--help', () => {
+    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');
+  })
+  .action(async (feature: string | undefined, options) => {
     try {
       const paths = getPaths();
-      const target = options.target as 'native' | 'web';
+      
+      // Interactive mode if no feature specified
+      if (!feature) {
+        const { RECIPES, getRecipesByCategory, formatCategory, getCategories } = await import('../core/recipes.js');
+        const { promptSelectAsync, promptMultiSelectAsync, intro, outro } = await import('../core/prompt.js');
+        
+        // Check if it's a category name
+        const categories = getCategories();
+        
+        // Show intro
+        intro('🎯 VibeFast Feature Installer');
+        
+        // Show category selection
+        const categoryChoices = categories.map((cat) => ({
+          value: cat,
+          label: formatCategory(cat),
+          description: `Browse ${formatCategory(cat).toLowerCase()}`,
+        }));
+        
+        const selectedCategory = await promptSelectAsync('What would you like to add?', categoryChoices);
+        
+        if (!selectedCategory) {
+          outro('Cancelled');
+          return;
+        }
+        
+        // Show items in selected category
+        const recipes = getRecipesByCategory(selectedCategory);
+        const recipeChoices = recipes.map((r) => ({
+          value: r.name,
+          label: `${r.icon} ${r.name}`,
+          description: r.description,
+        }));
+        
+        const selectedRecipes = await promptMultiSelectAsync(
+          `Select ${formatCategory(selectedCategory).toLowerCase()} to add:`,
+          recipeChoices
+        );
+        
+        if (selectedRecipes.length === 0) {
+          outro('No items selected');
+          return;
+        }
+        
+        // Install each selected recipe
+        for (const recipeName of selectedRecipes) {
+          log.plain('');
+          log.plain('━'.repeat(60));
+          await installFeature(recipeName, options, paths);
+        }
+        
+        outro('✨ Installation complete!');
+        return;
+      }
+      
+      // Check if feature is a category name
+      const { getCategories, getRecipesByCategory, formatCategory } = await import('../core/recipes.js');
+      const { promptMultiSelectAsync, intro, outro } = await import('../core/prompt.js');
+      const categories = getCategories();
+      
+      if (categories.includes(feature as any)) {
+        intro(`🎯 ${formatCategory(feature as any)}`);
+        
+        // Show items in this category
+        const recipes = getRecipesByCategory(feature as any);
+        const recipeChoices = recipes.map((r) => ({
+          value: r.name,
+          label: `${r.icon} ${r.name}`,
+          description: r.description,
+        }));
+        
+        const selectedRecipes = await promptMultiSelectAsync(
+          `Select ${formatCategory(feature as any).toLowerCase()} to add:`,
+          recipeChoices
+        );
+        
+        if (selectedRecipes.length === 0) {
+          outro('No items selected');
+          return;
+        }
+        
+        // Install each selected recipe
+        for (const recipeName of selectedRecipes) {
+          log.plain('');
+          log.plain('━'.repeat(60));
+          await installFeature(recipeName, options, paths);
+        }
+        
+        outro('✨ Installation complete!');
+        return;
+      }
+      
+      // Install single feature
+      await installFeature(feature, options, paths);
+    } catch (error: any) {
+      log.error(`Installation failed: ${error.message}`);
+      if (error.stack) {
+        log.plain(error.stack);
+      }
+      process.exit(1);
+    }
+  });
+
+async function installFeature(feature: string, options: any, paths: any) {
+    try {
+      let target = options.target as 'native' | 'web' | undefined;
+
+      // Smart target detection if not specified
+      if (!target) {
+        const detected = await detectTarget(paths.cwd);
+        if (detected) {
+          target = detected;
+          log.info(`Auto-detected target: ${target}`);
+        } else {
+          log.error('Could not auto-detect target (native/web)');
+          log.info('Please specify with --target native or --target web');
+          process.exit(1);
+        }
+      }
 
       // Validate setup
       const config = await validateSignature(paths.signatureFile);
@@ -78,15 +210,22 @@ export const addCommand = new Command('add')
       }
 
       // Fetch recipe
-      log.info(`Fetching ${feature} for ${target}...`);
       const device = await getDeviceInfo();
-      const response = await fetchRecipe({
-        token,
-        device,
-        feature,
-        target,
-        starter: { name: config.name, version: config.version },
-      });
+      const response = await withSpinner(
+        `Fetching ${feature} for ${target}...`,
+        async () => {
+          return await fetchRecipe({
+            token,
+            device,
+            feature,
+            target,
+            starter: { name: config.name, version: config.version },
+          });
+        },
+        {
+          successText: `✓ Recipe fetched`,
+        }
+      );
 
       if (!response.ok || (!response.signedUrl && !response.zipData)) {
         const error = response.error || 'Unknown error';
@@ -161,15 +300,25 @@ export const addCommand = new Command('add')
       }
 
       // Download and extract
-      log.info('Downloading recipe...');
-      const zipPath = response.zipData 
-        ? await downloadZip(response.zipData, true)
-        : await downloadZip(response.signedUrl!);
+      const { zipPath, extractDir } = await withSpinner(
+        'Downloading and extracting recipe...',
+        async () => {
+          const zipPath = response.zipData 
+            ? await downloadZip(response.zipData, true)
+            : await downloadZip(response.signedUrl!);
+          
+          const extractDir = zipPath.replace('.zip', '');
+          await extractZipSafe(zipPath, extractDir);
+          
+          return { zipPath, extractDir };
+        },
+        {
+          successText: '✓ Recipe downloaded',
+        }
+      );
       
-      const extractDir = zipPath.replace('.zip', '');
       const extractRoot = resolve(extractDir);
       const repoRoot = resolve(paths.cwd);
-      await extractZipSafe(zipPath, extractDir);
 
       // Read manifest
       const manifestPath = join(extractDir, 'recipe.json');
@@ -292,8 +441,8 @@ export const addCommand = new Command('add')
       log.success(`${manifest.name} installed successfully!`);
       log.info(`Files added: ${copiedFiles.length}`);
       
-      // Show required packages
-      if (manifest.dependencies) {
+      // Auto-install dependencies
+      if (manifest.dependencies && !options.dryRun) {
         log.plain('');
         log.warn('⚠ This feature requires additional packages');
         log.plain('');
@@ -307,10 +456,31 @@ export const addCommand = new Command('add')
           });
           log.plain('');
           
-          log.info('Install with:');
-          log.plain(`  npx expo install ${packages.join(' ')}`);
-          log.plain('');
-          log.info('💡 Expo will automatically pick compatible versions');
+          const shouldInstall = options.yes || await promptYesNo(
+            'Would you like to install these packages now? (Y/n) ',
+            true
+          );
+          
+          if (shouldInstall) {
+            await withSpinner(
+              'Installing packages with Expo...',
+              async () => {
+                const { execSync } = await import('child_process');
+                execSync(`npx expo install ${packages.join(' ')}`, {
+                  cwd: paths.cwd,
+                  stdio: 'inherit',
+                });
+              },
+              {
+                successText: '✓ Packages installed',
+              }
+            );
+          } else {
+            log.info('Install manually with:');
+            log.plain(`  npx expo install ${packages.join(' ')}`);
+            log.plain('');
+            log.info('💡 Expo will automatically pick compatible versions');
+          }
           
         } else if (manifest.target === 'web' && manifest.dependencies.npm) {
           const packages = manifest.dependencies.npm;
@@ -321,62 +491,165 @@ export const addCommand = new Command('add')
           });
           log.plain('');
           
-          log.info('Install with:');
-          log.plain(`  pnpm add ${packages.join(' ')}`);
-          log.plain('  OR');
-          log.plain(`  yarn add ${packages.join(' ')}`);
-          log.plain(`  OR`);
-          log.plain(`  npm install ${packages.join(' ')}`);
+          const shouldInstall = options.yes || await promptYesNo(
+            'Would you like to install these packages now? (Y/n) ',
+            true
+          );
+          
+          if (shouldInstall) {
+            const { detectPackageManager } = await import('../core/detect.js');
+            const pkgManager = detectPackageManager(paths.cwd) || 'pnpm';
+            
+            await withSpinner(
+              `Installing packages with ${pkgManager}...`,
+              async () => {
+                const { execSync } = await import('child_process');
+                const installCmd = pkgManager === 'npm' 
+                  ? `npm install ${packages.join(' ')}`
+                  : `${pkgManager} add ${packages.join(' ')}`;
+                execSync(installCmd, {
+                  cwd: paths.cwd,
+                  stdio: 'inherit',
+                });
+              },
+              {
+                successText: '✓ Packages installed',
+              }
+            );
+          } else {
+            log.info('Install manually with:');
+            log.plain(`  pnpm add ${packages.join(' ')}`);
+            log.plain('  OR');
+            log.plain(`  yarn add ${packages.join(' ')}`);
+            log.plain(`  OR`);
+            log.plain(`  npm install ${packages.join(' ')}`);
+          }
         }
         
         log.plain('');
       }
       
-      // Show manual steps
-      if (manifest.manualSteps && !options.dryRun) {
+      // Auto-setup Vosk model for wake-word
+      if (manifest.name === 'wake-word' && !options.dryRun) {
+        const { setupVoskModel } = await import('../core/vosk.js');
         log.plain('');
-        log.warn('⚠ MANUAL STEPS REQUIRED:');
-        log.plain('');
-        log.plain('This feature requires some manual configuration:');
-        log.plain('');
-        
-        manifest.manualSteps.forEach((step, index) => {
-          log.plain(`Step ${index + 1}: ${step.title}`);
-          log.plain(`  ${step.description}`);
-          if (step.link) {
-            log.plain(`  🔗 ${step.link}`);
+        await withSpinner(
+          'Setting up Vosk speech model...',
+          async () => {
+            return await setupVoskModel(paths.cwd, { dryRun: options.dryRun });
+          },
+          {
+            successText: '✓ Vosk model ready',
           }
-          if (step.file) {
-            log.plain(`  📝 File: ${step.file}`);
+        );
+      }
+
+      // Show manual steps with smart detection
+      if (manifest.manualSteps && !options.dryRun) {
+        const { readFileContent, exists } = await import('../core/fsx.js');
+        const { join } = await import('path');
+        
+        // Check which steps might already be done
+        const pendingSteps: typeof manifest.manualSteps = [];
+        const completedSteps: string[] = [];
+        
+        for (const step of manifest.manualSteps) {
+          let alreadyDone = false;
+          
+          // Check if file modification is already done
+          if (step.file && step.content) {
+            const filePath = join(paths.cwd, step.file);
+            if (await exists(filePath)) {
+              const content = await readFileContent(filePath);
+              // Simple check: does the file contain the content to add?
+              const contentToCheck = step.content.replace(/\s+/g, ' ').trim();
+              const fileContentNormalized = content.replace(/\s+/g, ' ').trim();
+              if (fileContentNormalized.includes(contentToCheck)) {
+                alreadyDone = true;
+                completedSteps.push(step.title);
+              }
+            }
           }
-          if (step.content) {
-            log.plain(`  Add: ${step.content}`);
+          
+          if (!alreadyDone) {
+            pendingSteps.push(step);
           }
+        }
+        
+        if (pendingSteps.length > 0) {
           log.plain('');
-        });
+          log.warn('⚠ MANUAL STEPS REQUIRED:');
+          log.plain('');
+          log.plain('This feature requires some manual configuration:');
+          log.plain('');
+          
+          pendingSteps.forEach((step, index) => {
+            log.plain(`Step ${index + 1}: ${step.title}`);
+            log.plain(`  ${step.description}`);
+            if (step.link) {
+              log.plain(`  🔗 ${step.link}`);
+            }
+            if (step.file) {
+              log.plain(`  📝 File: ${step.file}`);
+            }
+            if (step.content) {
+              log.plain(`  Add: ${step.content}`);
+            }
+            log.plain('');
+          });
+          
+          log.info(`💡 Run 'vf checklist ${manifest.name}' to see these steps again`);
+          log.plain('');
+        }
         
-        log.info(`💡 Run 'vf checklist ${manifest.name}' to see these steps again`);
-        log.plain('');
+        if (completedSteps.length > 0) {
+          log.success(`✓ Already configured: ${completedSteps.join(', ')}`);
+          log.plain('');
+        }
       }
       
-      // Show environment variables
+      // Show environment variables with smart detection
       if (manifest.env && !options.dryRun) {
-        log.plain('');
-        log.warn('⚠ REQUIRED ENVIRONMENT VARIABLES:');
-        log.plain('');
+        const { hasEnvKey } = await import('../core/env.js');
+        const { join } = await import('path');
+        const envPath = join(paths.cwd, '.env');
+        
+        const missing: typeof manifest.env = [];
+        const existing: string[] = [];
         
-        manifest.env.forEach(envVar => {
-          log.plain(`  ${envVar.key}`);
-          log.plain(`    ${envVar.description}`);
-          log.plain(`    Example: ${envVar.example}`);
-          if (envVar.link) {
-            log.plain(`    Get it: ${envVar.link}`);
+        // Check which vars already exist
+        for (const envVar of manifest.env) {
+          const exists = await hasEnvKey(envPath, envVar.key);
+          if (exists) {
+            existing.push(envVar.key);
+          } else {
+            missing.push(envVar);
           }
+        }
+        
+        if (missing.length > 0) {
           log.plain('');
-        });
+          log.warn('⚠ REQUIRED ENVIRONMENT VARIABLES:');
+          log.plain('');
+          
+          missing.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');
+          log.plain('');
+        }
         
-        log.info('Add these to your .env file');
-        log.plain('');
+        if (existing.length > 0) {
+          log.success(`✓ Already configured: ${existing.join(', ')}`);
+          log.plain('');
+        }
       }
       
       // Post-install message
@@ -385,15 +658,75 @@ export const addCommand = new Command('add')
         log.info(manifest.postInstall.message);
       }
       
+      // Final summary of what needs user attention
+      if (!options.dryRun) {
+        const needsAttention: string[] = [];
+        
+        // Check env vars
+        if (manifest.env) {
+          const { hasEnvKey } = await import('../core/env.js');
+          const { join } = await import('path');
+          const envPath = join(paths.cwd, '.env');
+          
+          for (const envVar of manifest.env) {
+            const exists = await hasEnvKey(envPath, envVar.key);
+            if (!exists) {
+              needsAttention.push(`Add ${envVar.key} to .env`);
+            }
+          }
+        }
+        
+        // Check manual steps
+        if (manifest.manualSteps) {
+          const { readFileContent, exists } = await import('../core/fsx.js');
+          const { join } = await import('path');
+          
+          for (const step of manifest.manualSteps) {
+            let alreadyDone = false;
+            
+            if (step.file && step.content) {
+              const filePath = join(paths.cwd, step.file);
+              if (await exists(filePath)) {
+                const content = await readFileContent(filePath);
+                const contentToCheck = step.content.replace(/\s+/g, ' ').trim();
+                const fileContentNormalized = content.replace(/\s+/g, ' ').trim();
+                if (fileContentNormalized.includes(contentToCheck)) {
+                  alreadyDone = true;
+                }
+              }
+            }
+            
+            if (!alreadyDone) {
+              needsAttention.push(step.title);
+            }
+          }
+        }
+        
+        // Show summary
+        if (needsAttention.length > 0) {
+          log.plain('');
+          log.plain('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          log.warn(`⚠ ACTION REQUIRED: ${needsAttention.length} item(s) need your attention`);
+          log.plain('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          log.plain('');
+          needsAttention.forEach((item, index) => {
+            log.plain(`  ${index + 1}. ${item}`);
+          });
+          log.plain('');
+          log.info(`💡 Run 'vf checklist ${manifest.name}' for detailed instructions`);
+          log.plain('');
+        } else {
+          log.plain('');
+          log.success('🎉 All set! No manual configuration needed.');
+          log.plain('');
+        }
+      }
+      
       if (options.dryRun) {
         log.plain('');
         log.warn('This was a dry run. Run without --dry-run to apply changes.');
       }
     } catch (error: any) {
-      log.error(`Installation failed: ${error.message}`);
-      if (error.stack) {
-        log.plain(error.stack);
-      }
-      process.exit(1);
+      throw error;
     }
-  });
+  }

package/src/commands/checklist.ts

@@ -2,20 +2,95 @@ import { Command } from 'commander';
 import { log } from '../core/log.js';
 import { getPaths } from '../core/paths.js';
 import { getEntry } from '../core/journal.js';
+import { showCommandHint } from '../core/errors.js';
 
 export const checklistCommand = new Command('checklist')
-  .description('Show manual setup steps for an installed feature')
+  .description('Show manual setup steps for a feature')
   .argument('<feature>', 'Feature name')
-  .option('--target <target>', 'Target platform (native or web)', 'native')
+  .option('--target <target>', 'Target platform (native, web, or service)', 'native')
+  .on('--help', () => {
+    log.plain('');
+    log.info('Examples:');
+    log.plain('  vf checklist sentry');
+    log.plain('  vf checklist charts --target native');
+    log.plain('  vf checklist chatbot --target web');
+    log.plain('  vf checklist sentry --target service');
+  })
   .action(async (feature: string, options) => {
     try {
+      if (!feature) {
+        showCommandHint('checklist');
+        process.exit(1);
+      }
       const paths = getPaths();
-      const target = options.target as 'native' | 'web';
+      const target = options.target as string;
+      
+      // First, try to get from journal (installed features)
+      let entry = await getEntry(paths.journalFile, feature, target as 'native' | 'web');
       
-      // Check if feature is installed
-      const entry = await getEntry(paths.journalFile, feature, target);
+      // If not found in journal, try to fetch from API (for services/integrations)
       if (!entry) {
-        log.error(`${feature} is not installed for ${target}`);
+        try {
+          const { getToken } = await import('../core/auth.js');
+          const { listRecipes } = await import('../core/http.js');
+          
+          const token = await getToken();
+          if (token) {
+            const response = await listRecipes(token);
+            
+            if (response.recipes) {
+              const recipe = response.recipes.find((r: any) => 
+                r.name.toLowerCase() === feature.toLowerCase()
+              );
+              
+              if (recipe && recipe.manualSteps) {
+                // Display manual steps from API recipe
+                log.info(`Setup steps for ${feature}:`);
+                log.plain('');
+                
+                recipe.manualSteps.forEach((step: any, index: number) => {
+                  log.plain(`Step ${index + 1}: ${step.title}`);
+                  log.plain(`  ${step.description}`);
+                  if (step.link) {
+                    log.plain(`  🔗 ${step.link}`);
+                  }
+                  if (step.file) {
+                    log.plain(`  📝 File: ${step.file}`);
+                  }
+                  if (step.content) {
+                    log.plain(`  Add: ${step.content}`);
+                  }
+                  log.plain('');
+                });
+                
+                // Display environment variables if any
+                if (recipe.env && recipe.env.length > 0) {
+                  log.warn('⚠ REQUIRED ENVIRONMENT VARIABLES:');
+                  log.plain('');
+                  
+                  recipe.env.forEach((envVar: any) => {
+                    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');
+                }
+                
+                return;
+              }
+            }
+          }
+        } catch {
+          // Continue to error handling below
+        }
+        
+        log.error(`${feature} not found`);
+        log.info('Run "vf list" to see available features');
         log.info('Run "vf status" to see installed features');
         process.exit(1);
       }