vibefast-cli 0.2.3 → 0.3.0

package/src/commands/init.ts

@@ -0,0 +1,390 @@
+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 { detectPackageManager } from '../core/detect.js';
+import simpleGit from 'simple-git';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+interface InitOptions {
+  license?: string;
+  branch?: 'clean' | 'main';
+  yes?: boolean;
+  skipInstall?: boolean;
+}
+
+export const initCommand = new Command('init')
+  .description('Initialize a new VibeFast project')
+  .option('--license <key>', 'Your VibeFast license key')
+  .option('--branch <branch>', 'Branch to clone (clean or main)')
+  .option('--yes', 'Skip all prompts and use defaults')
+  .option('--skip-install', 'Skip dependency installation')
+  .action(async (options: InitOptions) => {
+    try {
+      log.plain('');
+      log.info('🚀 VibeFast Project Initialization');
+      log.plain('');
+
+      // Check if already in a VibeFast project
+      if (existsSync('.vibefast-signature.json')) {
+        log.error('Already in a VibeFast project!');
+        log.info('This directory already contains a VibeFast project.');
+        process.exit(1);
+      }
+
+      // Step 1: Choose branch (always ask unless --branch provided)
+      let branch = options.branch as 'clean' | 'main';
+      
+      if (!options.branch) {
+        if (options.yes) {
+          // Default to main if --yes is used without --branch
+          branch = 'main';
+          log.info('Using default: full starter');
+        } else {
+          // Always prompt for branch selection
+          branch = await promptSelect(
+            'Which starter template would you like?',
+            [
+              {
+                name: 'Full',
+                value: 'main',
+                description: 'All features included - ready to customize',
+              },
+              {
+                name: 'Clean',
+                value: 'clean',
+                description: 'Minimal setup - add features as you need them',
+              },
+            ]
+          ) as 'clean' | 'main';
+        }
+      }
+
+      log.info(`Selected: ${branch === 'main' ? 'full' : 'clean'} starter`);
+      log.plain('');
+
+      // Step 2: Get project name
+      const defaultName = 'vibefast-app';
+      let projectName = defaultName;
+      
+      if (!options.yes) {
+        projectName = await promptInput(
+          'Project name:',
+          defaultName
+        );
+      }
+
+      // Validate project name
+      if (existsSync(projectName)) {
+        log.error(`Directory "${projectName}" already exists!`);
+        log.info('Please choose a different name or remove the existing directory.');
+        process.exit(1);
+      }
+
+      log.plain('');
+
+      // Step 3: Clone repository
+      // Note: This is a private repo, so we need GitHub credentials
+      // Users can authenticate via:
+      // 1. SSH key (recommended)
+      // 2. GitHub CLI (gh auth)
+      // 3. Personal access token in URL
+      const repoUrl = 'https://github.com/mzafarr/vibefast-pro.git';
+      
+      await withSpinner(
+        `Cloning VibeFast monorepo (${branch === 'main' ? 'full' : 'clean'} starter)...`,
+        async () => {
+          const git = simpleGit();
+          const cloneOptions = ['--depth', '1'];
+          
+          // Only specify branch if not main (main is default)
+          if (branch !== 'main') {
+            cloneOptions.unshift('--branch', branch, '--single-branch');
+          }
+          
+          try {
+            await git.clone(repoUrl, projectName, cloneOptions);
+          } catch (error: any) {
+            // Handle authentication errors
+            if (error.message.includes('Authentication failed') || 
+                error.message.includes('permission denied') ||
+                error.message.includes('fatal: could not read Username')) {
+              throw new Error(
+                'GitHub authentication failed. This is a private repository.\n\n' +
+                'To access it, you need to authenticate with GitHub:\n\n' +
+                '1. SSH Key (Recommended):\n' +
+                '   - Set up SSH: https://docs.github.com/en/authentication/connecting-to-github-with-ssh\n' +
+                '   - Then try again\n\n' +
+                '2. GitHub CLI:\n' +
+                '   - Install: https://cli.github.com\n' +
+                '   - Run: gh auth login\n' +
+                '   - Then try again\n\n' +
+                '3. Personal Access Token:\n' +
+                '   - Create token: https://github.com/settings/tokens\n' +
+                '   - Use: https://YOUR_TOKEN@github.com/mzafarr/vibefast-pro.git'
+              );
+            }
+            throw error;
+          }
+        },
+        {
+          successText: `✓ Repository cloned successfully`,
+        }
+      );
+
+      log.plain('');
+
+      // Step 4: Check for pnpm and install dependencies
+      const projectPath = join(process.cwd(), projectName);
+      
+      if (!options.skipInstall) {
+        // Check if pnpm is installed
+        log.info('Checking for pnpm...');
+        try {
+          await execAsync('pnpm --version');
+          log.info('✓ pnpm is installed');
+        } catch {
+          log.warn('pnpm is not installed');
+          log.plain('');
+          
+          const shouldInstallPnpm = options.yes || await promptConfirm(
+            'Would you like to install pnpm globally?',
+            true
+          );
+          
+          if (shouldInstallPnpm) {
+            log.plain('');
+            await withSpinner(
+              'Installing pnpm globally...',
+              async () => {
+                await execAsync('npm install -g pnpm');
+              },
+              {
+                successText: '✓ pnpm installed',
+              }
+            );
+          } else {
+            log.warn('Skipping pnpm installation. You can install it later with:');
+            log.plain('  npm install -g pnpm');
+            log.plain('');
+          }
+        }
+        
+        log.plain('');
+        
+        await withSpinner(
+          'Installing dependencies (this may take a few minutes)...',
+          async () => {
+            await execAsync('pnpm install', { cwd: projectPath });
+          },
+          {
+            successText: '✓ Dependencies installed',
+          }
+        );
+
+        log.plain('');
+      }
+
+      // Step 5: Create .env files from examples (before starter setup)
+      log.plain('');
+      log.info('📝 Setting up environment files...');
+      
+      const envFiles = [
+        { example: '.env.local.example', target: '.env.local' },
+        { example: '.env.staging.example', target: '.env.staging' },
+        { example: '.env.production.example', target: '.env.production' },
+      ];
+      
+      let envFilesCreated = 0;
+      for (const { example, target } of envFiles) {
+        const examplePath = join(projectPath, 'apps/native', example);
+        const targetPath = join(projectPath, 'apps/native', target);
+        
+        if (existsSync(examplePath) && !existsSync(targetPath)) {
+          const { copyFileSync } = await import('fs');
+          copyFileSync(examplePath, targetPath);
+          log.info(`✓ Created ${target}`);
+          envFilesCreated++;
+        }
+      }
+      
+      if (envFilesCreated > 0) {
+        log.plain('');
+        log.warn('⚠️  Environment files created with placeholder values');
+        log.info('You will need to fill in your actual API keys and credentials');
+        log.plain('');
+      } else {
+        log.info('ℹ️  No .env example files found to copy');
+        log.plain('');
+      }
+      
+      // Step 6: Run starter setup script (optional)
+      const setupScriptPath = join(projectPath, 'apps/native/scripts/starter-setup.mjs');
+      
+      if (existsSync(setupScriptPath)) {
+        log.info('📋 Starter Setup Available');
+        log.plain('');
+        log.info('The starter includes a setup script that will:');
+        log.plain('  • Fix Expo SDK dependencies');
+        log.plain('  • Set up Convex backend (if available)');
+        log.plain('  • Configure Convex Auth');
+        log.plain('');
+        
+        const runSetup = options.yes || await promptConfirm(
+          'Would you like to run the starter setup now?',
+          true
+        );
+        
+        if (runSetup) {
+          log.plain('');
+          log.info('Running starter setup...');
+          log.plain('');
+          
+          try {
+            // Use spawn instead of execAsync for interactive scripts
+            const { spawn } = await import('child_process');
+            await new Promise<void>((resolve, reject) => {
+              const child = spawn('node', ['scripts/starter-setup.mjs'], {
+                cwd: join(projectPath, 'apps/native'),
+                stdio: 'inherit',
+              });
+              child.on('close', (code) => {
+                if (code === 0) resolve();
+                else reject(new Error(`Setup script exited with code ${code}`));
+              });
+              child.on('error', reject);
+            });
+            log.plain('');
+            log.success('✓ Starter setup completed');
+          } catch (error: any) {
+            log.warn('⚠ Starter setup had some issues');
+            log.info('You can run it manually later with:');
+            log.plain(`  cd ${projectName}/apps/native`);
+            log.plain('  node scripts/starter-setup.mjs');
+          }
+        } else {
+          log.info('You can run the setup script later with:');
+          log.plain(`  cd ${projectName}/apps/native`);
+          log.plain('  node scripts/starter-setup.mjs');
+        }
+        
+        log.plain('');
+      }
+
+      // Step 7: Login with license key (REQUIRED)
+      let licenseKey = options.license;
+      
+      // Check if user already has a license key saved
+      if (!licenseKey) {
+        const { getToken } = await import('../core/auth.js');
+        const existingToken = await getToken();
+        
+        if (existingToken) {
+          log.info('✓ Using existing license key');
+          licenseKey = existingToken;
+        }
+      }
+      
+      if (!licenseKey) {
+        log.plain('');
+        log.info('🔑 VibeFast License Key Required');
+        log.plain('');
+        log.info('To use VibeFast, you need a valid license key.');
+        log.info('Get one at: https://vibefast.pro');
+        log.plain('');
+        
+        if (options.yes) {
+          log.error('License key is required. Use --license <key> or run "vf login" first');
+          process.exit(1);
+        }
+        
+        licenseKey = await promptInput('Enter your license key:');
+        
+        if (!licenseKey || licenseKey.trim() === '') {
+          log.error('License key cannot be empty');
+          process.exit(1);
+        }
+      }
+
+      log.plain('');
+      await withSpinner(
+        'Saving license key...',
+        async () => {
+          // Save token to auth file in the new project
+          const { writeFileContent } = await import('../core/fsx.js');
+          const authPath = join(projectPath, '.vibefast-auth.json');
+          await writeFileContent(
+            authPath,
+            JSON.stringify({ token: licenseKey }, null, 2),
+            { force: true }
+          );
+        },
+        {
+          successText: '✓ License key saved',
+        }
+      );
+      log.plain('');
+
+      // Success!
+      log.plain('');
+      log.success('🎉 Project initialized successfully!');
+      log.plain('');
+      log.info('Next steps:');
+      log.plain(`  1. cd ${projectName}`);
+      
+      // Check if setup script exists
+      const setupScriptExists = existsSync(join(projectPath, 'apps/native/scripts/starter-setup.mjs'));
+      
+      if (setupScriptExists && !options.skipInstall) {
+        log.plain('  2. Start developing:');
+        log.plain('     • pnpm dev:native       (start dev server)');
+        log.plain('     • pnpm native:ios       (run on iOS)');
+        log.plain('     • pnpm native:android   (run on Android)');
+      } else {
+        log.plain('  2. Run starter setup (if not done):');
+        log.plain(`     cd ${projectName}/apps/native`);
+        log.plain('     node scripts/starter-setup.mjs');
+        log.plain('  3. Start developing:');
+        log.plain('     • pnpm dev:native       (start dev server)');
+        log.plain('     • pnpm native:ios       (run on iOS)');
+        log.plain('     • pnpm native:android   (run on Android)');
+      }
+      
+      log.plain('');
+      log.info('Add features:');
+      log.plain('  • vf list              # See available features');
+      log.plain('  • vf add <feature>     # Add features to your project');
+      
+      log.plain('');
+      log.info('📚 Documentation: https://vibefast.pro/docs');
+      log.info('💬 Support: support@vibefast.pro');
+      log.plain('');
+
+    } catch (error: any) {
+      log.plain('');
+      log.error(`Initialization failed: ${error.message}`);
+      
+      if (error.message.includes('git')) {
+        log.plain('');
+        log.info('Make sure Git is installed:');
+        log.plain('  • macOS: brew install git');
+        log.plain('  • Windows: https://git-scm.com/download/win');
+        log.plain('  • Linux: sudo apt install git');
+      }
+      
+      if (error.message.includes('EACCES') || error.message.includes('permission')) {
+        log.plain('');
+        log.info('Permission denied. Try:');
+        log.plain('  • Run without sudo');
+        log.plain('  • Check directory permissions');
+      }
+      
+      log.plain('');
+      process.exit(1);
+    }
+  });

package/src/commands/list.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 import { log } from '../core/log.js';
 import { getToken } from '../core/auth.js';
 import { listRecipes } from '../core/http.js';
+import { withSpinner } from '../core/spinner.js';
 
 export const listCommand = new Command('list')
   .description('List available VibeFast features')
@@ -13,31 +14,56 @@ export const listCommand = new Command('list')
         process.exit(1);
       }
 
-      const response = await listRecipes(token);
+      const response = await withSpinner(
+        'Fetching available features...',
+        async () => await listRecipes(token),
+        {
+          successText: '✓ Features loaded',
+        }
+      );
+      
+      log.plain('');
       
       if (!response.recipes || response.recipes.length === 0) {
         log.info('No recipes available');
         return;
       }
 
-      const native = response.recipes.filter((r: any) => r.target === 'native');
-      const web = response.recipes.filter((r: any) => r.target === 'web');
+      // Categorize by target type
+      const categories: Record<string, any[]> = {};
+      
+      response.recipes.forEach((recipe: any) => {
+        const target = recipe.target || 'other';
+        if (!categories[target]) {
+          categories[target] = [];
+        }
+        categories[target].push(recipe);
+      });
 
-      if (native.length > 0) {
-        log.info('Native (Expo) features:');
-        native.forEach((recipe: any) => {
-          log.plain(`  • ${recipe.name} - ${recipe.description}`);
-        });
-      }
+      // Display by category
+      const categoryLabels: Record<string, string> = {
+        'native': '📱 Native (Expo) Features',
+        'web': '🌐 Web (Next.js) Features',
+        'service': '⚙️  Services & Integrations',
+        'integration': '🔗 Integrations',
+        'other': '📦 Other Features',
+      };
 
-      if (web.length > 0) {
-        log.info('\nWeb (Next.js) features:');
-        web.forEach((recipe: any) => {
-          log.plain(`  • ${recipe.name} - ${recipe.description}`);
-        });
-      }
+      Object.entries(categories).forEach(([target, recipes]) => {
+        if (recipes.length > 0) {
+          const label = categoryLabels[target] || `${target} Features`;
+          log.info(label);
+          recipes.forEach((recipe: any) => {
+            log.plain(`  • ${recipe.name} - ${recipe.description}`);
+          });
+          log.plain('');
+        }
+      });
 
-      log.plain('\nInstall with: vf add <feature-name>');
+      log.info('Commands:');
+      log.plain('  vf add <feature>       Install a feature');
+      log.plain('  vf checklist <feature> View setup steps');
+      log.plain('  vf status              Show installed features');
     } catch (error: any) {
       const errorMsg = error.message || '';
       

package/src/commands/login.ts

@@ -1,10 +1,16 @@
 import { Command } from 'commander';
 import { log } from '../core/log.js';
 import { saveToken } from '../core/auth.js';
+import { showCommandHint } from '../core/errors.js';
 
 export const loginCommand = new Command('login')
   .description('Authenticate with your VibeFast token')
   .requiredOption('--token <token>', 'Your VibeFast license token')
+  .on('--help', () => {
+    log.plain('');
+    log.info('Example:');
+    log.plain('  vf login --token your-license-key-here');
+  })
   .action(async (options) => {
     try {
       const token = options.token.trim();

package/src/commands/remove.ts

@@ -7,6 +7,7 @@ import { deleteFile } from '../core/fsx.js';
 import { removeNavLinkNative, removeNavLinkWeb } from '../core/codemod.js';
 import { hashFile } from '../core/hash.js';
 import { promptYesNo } from '../core/prompt.js';
+import { showCommandHint } from '../core/errors.js';
 
 export const removeCommand = new Command('remove')
   .description('Remove a VibeFast feature from your project')
@@ -15,8 +16,19 @@ export const removeCommand = new Command('remove')
   .option('--dry-run', 'Preview changes without applying')
   .option('--force', 'Skip modification check')
   .option('--yes', 'Answer yes to all prompts')
+  .on('--help', () => {
+    log.plain('');
+    log.info('Examples:');
+    log.plain('  vf remove charts --target native');
+    log.plain('  vf remove sentry --target web');
+  })
   .action(async (feature: string, options) => {
     try {
+      if (!feature) {
+        showCommandHint('remove');
+        process.exit(1);
+      }
+
       const paths = getPaths();
       const target = options.target as 'native' | 'web';
 

package/src/core/__tests__/detect.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { detectTarget, detectPackageManager } from '../detect.js';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+
+describe('detect', () => {
+  const testDir = join(process.cwd(), 'test-detect-temp');
+
+  beforeEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('detectTarget', () => {
+    it('should detect native when only native dir exists', async () => {
+      const nativeDir = join(testDir, 'apps', 'native');
+      mkdirSync(nativeDir, { recursive: true });
+
+      const result = await detectTarget(testDir);
+      expect(result).toBe('native');
+    });
+
+    it('should detect web when only web dir exists', async () => {
+      const webDir = join(testDir, 'apps', 'web');
+      mkdirSync(webDir, { recursive: true });
+
+      const result = await detectTarget(testDir);
+      expect(result).toBe('web');
+    });
+
+    it('should return null when neither exists', async () => {
+      const result = await detectTarget(testDir);
+      expect(result).toBeNull();
+    });
+
+    it('should detect native when both exist and native has expo', async () => {
+      const nativeDir = join(testDir, 'apps', 'native');
+      const webDir = join(testDir, 'apps', 'web');
+      mkdirSync(nativeDir, { recursive: true });
+      mkdirSync(webDir, { recursive: true });
+
+      const nativePkg = join(nativeDir, 'package.json');
+      writeFileSync(
+        nativePkg,
+        JSON.stringify({ dependencies: { expo: '^50.0.0' } })
+      );
+
+      const result = await detectTarget(testDir);
+      expect(result).toBe('native');
+    });
+  });
+
+  describe('detectPackageManager', () => {
+    it('should detect pnpm', () => {
+      writeFileSync(join(testDir, 'pnpm-lock.yaml'), '');
+      const result = detectPackageManager(testDir);
+      expect(result).toBe('pnpm');
+    });
+
+    it('should detect npm', () => {
+      writeFileSync(join(testDir, 'package-lock.json'), '');
+      const result = detectPackageManager(testDir);
+      expect(result).toBe('npm');
+    });
+
+    it('should detect yarn', () => {
+      writeFileSync(join(testDir, 'yarn.lock'), '');
+      const result = detectPackageManager(testDir);
+      expect(result).toBe('yarn');
+    });
+
+    it('should detect bun', () => {
+      writeFileSync(join(testDir, 'bun.lockb'), '');
+      const result = detectPackageManager(testDir);
+      expect(result).toBe('bun');
+    });
+
+    it('should return null when no lockfile exists', () => {
+      const result = detectPackageManager(testDir);
+      expect(result).toBeNull();
+    });
+  });
+});

package/src/core/detect.ts

@@ -0,0 +1,60 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { readFileContent } from './fsx.js';
+
+export type Target = 'native' | 'web';
+
+/**
+ * Auto-detect project target (native/web) based on directory structure
+ */
+export async function detectTarget(cwd: string = process.cwd()): Promise<Target | null> {
+  // Check for native directory
+  const nativeDir = join(cwd, 'apps', 'native');
+  const webDir = join(cwd, 'apps', 'web');
+  
+  const hasNative = existsSync(nativeDir);
+  const hasWeb = existsSync(webDir);
+  
+  // If only one exists, return that
+  if (hasNative && !hasWeb) return 'native';
+  if (hasWeb && !hasNative) return 'web';
+  
+  // If both exist, check package.json for hints
+  if (hasNative && hasWeb) {
+    try {
+      const nativePkgPath = join(nativeDir, 'package.json');
+      const webPkgPath = join(webDir, 'package.json');
+      
+      if (existsSync(nativePkgPath)) {
+        const content = await readFileContent(nativePkgPath);
+        const pkg = JSON.parse(content);
+        if (pkg.dependencies?.expo || pkg.dependencies?.['expo-router']) {
+          return 'native';
+        }
+      }
+      
+      if (existsSync(webPkgPath)) {
+        const content = await readFileContent(webPkgPath);
+        const pkg = JSON.parse(content);
+        if (pkg.dependencies?.next || pkg.dependencies?.['next-auth']) {
+          return 'web';
+        }
+      }
+    } catch {
+      // Ignore parsing errors
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Detect package manager based on lockfile
+ */
+export function detectPackageManager(cwd: string = process.cwd()): 'pnpm' | 'npm' | 'yarn' | 'bun' | null {
+  if (existsSync(join(cwd, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (existsSync(join(cwd, 'package-lock.json'))) return 'npm';
+  if (existsSync(join(cwd, 'yarn.lock'))) return 'yarn';
+  if (existsSync(join(cwd, 'bun.lockb'))) return 'bun';
+  return null;
+}