vibefast-cli 0.1.4 → 0.2.1

package/src/commands/checklist.ts

@@ -0,0 +1,71 @@
+import { Command } from 'commander';
+import { log } from '../core/log.js';
+import { getPaths } from '../core/paths.js';
+import { getEntry } from '../core/journal.js';
+
+export const checklistCommand = new Command('checklist')
+  .description('Show manual setup steps for an installed feature')
+  .argument('<feature>', 'Feature name')
+  .option('--target <target>', 'Target platform (native or web)', 'native')
+  .action(async (feature: string, options) => {
+    try {
+      const paths = getPaths();
+      const target = options.target as 'native' | 'web';
+      
+      // Check if feature is installed
+      const entry = await getEntry(paths.journalFile, feature, target);
+      if (!entry) {
+        log.error(`${feature} is not installed for ${target}`);
+        log.info('Run "vf status" to see installed features');
+        process.exit(1);
+      }
+      
+      // Check if feature has manual steps
+      if (!entry.manifest?.manualSteps || entry.manifest.manualSteps.length === 0) {
+        log.info(`${feature} has no manual setup steps`);
+        log.success('This feature is ready to use!');
+        return;
+      }
+      
+      // Display manual steps
+      log.info(`Manual setup steps for ${feature}:`);
+      log.plain('');
+      
+      entry.manifest.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 (entry.manifest.env && entry.manifest.env.length > 0) {
+        log.warn('⚠ REQUIRED ENVIRONMENT VARIABLES:');
+        log.plain('');
+        
+        entry.manifest.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');
+      }
+      
+    } catch (error: any) {
+      log.error(`Failed to show checklist: ${error.message}`);
+      process.exit(1);
+    }
+  });

package/src/commands/devices.ts

@@ -32,7 +32,34 @@ export const devicesCommand = new Command('devices')
         log.plain(`  • ${device.id} (${device.os}/${device.arch}) - ${device.lastSeen}`);
       });
     } catch (error: any) {
-      log.error(`Failed: ${error.message}`);
+      const errorMsg = error.message || '';
+      
+      log.plain('');
+      log.error('Failed to manage devices');
+      log.plain('');
+      
+      // Better error messages
+      if (errorMsg.includes('license_key not found') || errorMsg.includes('Invalid') || errorMsg.includes('token')) {
+        log.plain('❌ Invalid or expired license key');
+        log.plain('');
+        log.info('To fix this:');
+        log.plain('  1. Run: vf logout');
+        log.plain('  2. Run: vf login --token YOUR_LICENSE_KEY');
+        log.plain('');
+        log.info('Need help? Contact support@vibefast.pro');
+      } else if (errorMsg.includes('Network') || errorMsg.includes('connect') || errorMsg.includes('fetch')) {
+        log.plain('❌ Network error');
+        log.plain('');
+        log.info('Could not connect to VibeFast servers');
+        log.plain('');
+        log.plain(`Details: ${errorMsg}`);
+      } else {
+        log.plain(`❌ ${errorMsg}`);
+        log.plain('');
+        log.info('If this problem persists, contact support@vibefast.pro');
+      }
+      
+      log.plain('');
       process.exit(1);
     }
   });

package/src/commands/list.ts

@@ -39,7 +39,45 @@ export const listCommand = new Command('list')
 
       log.plain('\nInstall with: vf add <feature-name>');
     } catch (error: any) {
-      log.error(`Failed to list recipes: ${error.message}`);
+      const errorMsg = error.message || '';
+      
+      log.plain('');
+      log.error('Failed to list recipes');
+      log.plain('');
+      
+      // Better error messages
+      if (errorMsg.includes('license_key not found') || errorMsg.includes('Invalid') || errorMsg.includes('token')) {
+        log.plain('❌ Invalid or expired license key');
+        log.plain('');
+        log.info('Your license key may be:');
+        log.plain('  • Incorrect or mistyped');
+        log.plain('  • Expired');
+        log.plain('  • Not yet activated');
+        log.plain('');
+        log.info('To fix this:');
+        log.plain('  1. Check your license key from your purchase receipt');
+        log.plain('  2. Run: vf logout');
+        log.plain('  3. Run: vf login --token YOUR_LICENSE_KEY');
+        log.plain('');
+        log.info('Need help? Contact support@vibefast.pro');
+      } else if (errorMsg.includes('Network') || errorMsg.includes('connect') || errorMsg.includes('fetch')) {
+        log.plain('❌ Network error');
+        log.plain('');
+        log.info('Could not connect to VibeFast servers');
+        log.plain('');
+        log.info('Please check:');
+        log.plain('  • Your internet connection');
+        log.plain('  • Firewall settings');
+        log.plain('  • VPN configuration');
+        log.plain('');
+        log.plain(`Details: ${errorMsg}`);
+      } else {
+        log.plain(`❌ ${errorMsg}`);
+        log.plain('');
+        log.info('If this problem persists, contact support@vibefast.pro');
+      }
+      
+      log.plain('');
       process.exit(1);
     }
   });

package/src/commands/remove.ts

@@ -2,15 +2,19 @@ import { Command } from 'commander';
 import { log } from '../core/log.js';
 import { getPaths } from '../core/paths.js';
 import { validateSignature, validateTarget } from '../core/validate.js';
-import { getEntry, removeEntry } from '../core/journal.js';
+import { getEntry, removeEntry, FileEntry } from '../core/journal.js';
 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';
 
 export const removeCommand = new Command('remove')
   .description('Remove a VibeFast feature from your project')
   .argument('<feature>', 'Feature name to remove')
   .option('--target <target>', 'Target platform (native or web)', 'native')
   .option('--dry-run', 'Preview changes without applying')
+  .option('--force', 'Skip modification check')
+  .option('--yes', 'Answer yes to all prompts')
   .action(async (feature: string, options) => {
     try {
       const paths = getPaths();
@@ -35,8 +39,99 @@ export const removeCommand = new Command('remove')
 
       log.info(`Removing ${feature} from ${target}...`);
 
+      // Check for modifications (unless --force)
+      if (!options.force && !options.dryRun) {
+        log.info('Checking for file modifications...');
+        
+        const modifiedFiles: Array<{ path: string; status: 'modified' | 'deleted' }> = [];
+        
+        // Get file paths from entry
+        const filePaths = Array.isArray(entry.files) && entry.files.length > 0
+          ? typeof entry.files[0] === 'string'
+            ? entry.files as string[]
+            : (entry.files as FileEntry[]).map(f => f.path)
+          : [];
+        
+        const fileHashes = Array.isArray(entry.files) && entry.files.length > 0 && typeof entry.files[0] !== 'string'
+          ? new Map((entry.files as FileEntry[]).map(f => [f.path, f.hash]))
+          : new Map<string, string>();
+        
+        for (const filePath of filePaths) {
+          const originalHash = fileHashes.get(filePath);
+          
+          // Skip if we don't have original hash (old journal format)
+          if (!originalHash) continue;
+          
+          const currentHash = await hashFile(filePath);
+          
+          if (currentHash === '') {
+            // File was deleted by user
+            modifiedFiles.push({ path: filePath, status: 'deleted' });
+          } else if (currentHash !== originalHash) {
+            // File was modified by user
+            modifiedFiles.push({ path: filePath, status: 'modified' });
+          }
+        }
+        
+        // Warn about modifications
+        if (modifiedFiles.length > 0) {
+          log.plain('');
+          log.warn('⚠ WARNING: The following files were changed:');
+          log.plain('');
+          
+          const modified = modifiedFiles.filter(f => f.status === 'modified');
+          const deleted = modifiedFiles.filter(f => f.status === 'deleted');
+          
+          if (modified.length > 0) {
+            log.plain('  Modified by you:');
+            modified.slice(0, 10).forEach(f => {
+              const relativePath = f.path.replace(paths.cwd + '/', '');
+              log.plain(`    • ${relativePath}`);
+            });
+            if (modified.length > 10) {
+              log.plain(`    ... and ${modified.length - 10} more`);
+            }
+          }
+          
+          if (deleted.length > 0) {
+            log.plain('');
+            log.plain('  Already deleted:');
+            deleted.slice(0, 5).forEach(f => {
+              const relativePath = f.path.replace(paths.cwd + '/', '');
+              log.plain(`    • ${relativePath}`);
+            });
+            if (deleted.length > 5) {
+              log.plain(`    ... and ${deleted.length - 5} more`);
+            }
+          }
+          
+          log.plain('');
+          log.warn('⚠ Your changes will be LOST if you continue!');
+          log.info('💡 Make sure you have committed to Git.');
+          log.plain('');
+          
+          if (!options.yes) {
+            const shouldContinue = promptYesNo(
+              'Continue with removal? (y/N): ',
+              false
+            );
+            
+            if (!shouldContinue) {
+              log.info('Removal cancelled');
+              return;
+            }
+          }
+        }
+      }
+
       // Delete files
-      for (const file of entry.files) {
+      const filePaths = Array.isArray(entry.files) && entry.files.length > 0
+        ? typeof entry.files[0] === 'string'
+          ? entry.files as string[]
+          : (entry.files as FileEntry[]).map(f => f.path)
+        : [];
+      
+      for (const file of filePaths) {
         log.info(`Deleting ${file}`);
         if (!options.dryRun) {
           await deleteFile(file);
@@ -66,7 +161,14 @@ export const removeCommand = new Command('remove')
       }
 
       log.success(`${feature} removed successfully!`);
-      log.info(`Files deleted: ${entry.files.length}`);
+      
+      const fileCount = Array.isArray(entry.files) && entry.files.length > 0
+        ? typeof entry.files[0] === 'string'
+          ? entry.files.length
+          : (entry.files as FileEntry[]).length
+        : 0;
+      
+      log.info(`Files deleted: ${fileCount}`);
       
       if (options.dryRun) {
         log.warn('This was a dry run. Run without --dry-run to apply changes.');

package/src/commands/status.ts

@@ -0,0 +1,47 @@
+import { Command } from 'commander';
+import { log } from '../core/log.js';
+import { getPaths } from '../core/paths.js';
+import { readJournal, FileEntry } from '../core/journal.js';
+
+export const statusCommand = new Command('status')
+  .description('Show installed features and their status')
+  .action(async () => {
+    try {
+      const paths = getPaths();
+      const journal = await readJournal(paths.journalFile);
+      
+      if (journal.entries.length === 0) {
+        log.info('No features installed yet');
+        log.info('Run "vf list" to see available features');
+        return;
+      }
+      
+      log.info('Installed features:');
+      log.plain('');
+      
+      for (const entry of journal.entries) {
+        const version = entry.manifest?.version || 'unknown';
+        const fileCount = Array.isArray(entry.files) && entry.files.length > 0
+          ? typeof entry.files[0] === 'string'
+            ? entry.files.length
+            : (entry.files as FileEntry[]).length
+          : 0;
+        
+        log.plain(`  ✓ ${entry.feature} (v${version}) - ${entry.target}`);
+        log.plain(`    Files: ${fileCount}`);
+        log.plain(`    Installed: ${new Date(entry.ts).toLocaleDateString()}`);
+        
+        if (entry.manifest?.manualSteps && entry.manifest.manualSteps.length > 0) {
+          log.plain(`    ⚠ Has manual setup steps (run: vf checklist ${entry.feature})`);
+        }
+        
+        log.plain('');
+      }
+      
+      log.info(`Total: ${journal.entries.length} feature(s) installed`);
+      
+    } catch (error: any) {
+      log.error(`Failed to show status: ${error.message}`);
+      process.exit(1);
+    }
+  });

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

@@ -0,0 +1,101 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { copyTree, exists } from '../fsx.js';
+import { writeFile, mkdir, rm } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('fsx', () => {
+  let testDir: string;
+  let srcDir: string;
+  let destDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `vibefast-test-${Date.now()}`);
+    srcDir = join(testDir, 'src');
+    destDir = join(testDir, 'dest');
+    
+    await mkdir(srcDir, { recursive: true });
+    await mkdir(destDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  describe('copyTree', () => {
+    it('should copy files successfully', async () => {
+      const file1 = join(srcDir, 'file1.txt');
+      const file2 = join(srcDir, 'file2.txt');
+      
+      await writeFile(file1, 'content 1');
+      await writeFile(file2, 'content 2');
+
+      const result = await copyTree(srcDir, destDir);
+
+      expect(result.files).toHaveLength(2);
+      expect(result.conflicts).toHaveLength(0);
+      expect(result.skipped).toHaveLength(0);
+      
+      expect(await exists(join(destDir, 'file1.txt'))).toBe(true);
+      expect(await exists(join(destDir, 'file2.txt'))).toBe(true);
+    });
+
+    it('should detect conflicts', async () => {
+      const srcFile = join(srcDir, 'file.txt');
+      const destFile = join(destDir, 'file.txt');
+      
+      await writeFile(srcFile, 'new content');
+      await writeFile(destFile, 'existing content');
+
+      try {
+        await copyTree(srcDir, destDir);
+        expect.fail('Should have thrown error');
+      } catch (error: any) {
+        expect(error.message).toContain('File exists');
+      }
+    });
+
+    it('should overwrite with force flag', async () => {
+      // Create source file
+      await writeFile(join(srcDir, 'file.txt'), 'new content');
+      
+      // Create existing destination file
+      await writeFile(join(destDir, 'file.txt'), 'existing content');
+
+      const result = await copyTree(srcDir, destDir, { force: true });
+
+      expect(result.files).toHaveLength(1);
+      expect(result.conflicts).toHaveLength(1);
+      expect(result.skipped).toHaveLength(0);
+    });
+
+    it('should handle dry-run mode', async () => {
+      const file1 = join(srcDir, 'file1.txt');
+      await writeFile(file1, 'content');
+
+      const result = await copyTree(srcDir, destDir, { dryRun: true });
+
+      expect(result.files).toHaveLength(1);
+      expect(await exists(join(destDir, 'file1.txt'))).toBe(false); // Not actually copied
+    });
+
+    it('should copy nested directories', async () => {
+      const nestedDir = join(srcDir, 'nested');
+      await mkdir(nestedDir);
+      await writeFile(join(nestedDir, 'file.txt'), 'content');
+
+      const result = await copyTree(srcDir, destDir);
+
+      expect(result.files).toHaveLength(1);
+      expect(await exists(join(destDir, 'nested', 'file.txt'))).toBe(true);
+    });
+
+    it('should handle empty directory', async () => {
+      const result = await copyTree(srcDir, destDir);
+
+      expect(result.files).toHaveLength(0);
+      expect(result.conflicts).toHaveLength(0);
+      expect(result.skipped).toHaveLength(0);
+    });
+  });
+});

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

@@ -0,0 +1,112 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { hashFile, hashFiles } from '../hash.js';
+import { writeFile, unlink, mkdir, rm } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('hash', () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `vibefast-test-${Date.now()}`);
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  describe('hashFile', () => {
+    it('should hash file content correctly', async () => {
+      const testFile = join(testDir, 'test.txt');
+      await writeFile(testFile, 'hello world');
+
+      const hash = await hashFile(testFile);
+
+      // SHA-256 of "hello world"
+      expect(hash).toBe('b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9');
+    });
+
+    it('should return empty string for non-existent file', async () => {
+      const hash = await hashFile(join(testDir, 'does-not-exist.txt'));
+      expect(hash).toBe('');
+    });
+
+    it('should detect file modifications', async () => {
+      const testFile = join(testDir, 'test.txt');
+      await writeFile(testFile, 'original');
+
+      const hash1 = await hashFile(testFile);
+
+      await writeFile(testFile, 'modified');
+
+      const hash2 = await hashFile(testFile);
+
+      expect(hash1).not.toBe(hash2);
+      expect(hash1).not.toBe('');
+      expect(hash2).not.toBe('');
+    });
+
+    it('should produce same hash for same content', async () => {
+      const file1 = join(testDir, 'file1.txt');
+      const file2 = join(testDir, 'file2.txt');
+
+      await writeFile(file1, 'same content');
+      await writeFile(file2, 'same content');
+
+      const hash1 = await hashFile(file1);
+      const hash2 = await hashFile(file2);
+
+      expect(hash1).toBe(hash2);
+    });
+  });
+
+  describe('hashFiles', () => {
+    it('should hash multiple files', async () => {
+      const file1 = join(testDir, 'file1.txt');
+      const file2 = join(testDir, 'file2.txt');
+
+      await writeFile(file1, 'content 1');
+      await writeFile(file2, 'content 2');
+
+      const hashes = await hashFiles([file1, file2]);
+
+      expect(hashes.size).toBe(2);
+      expect(hashes.get(file1)).toBeTruthy();
+      expect(hashes.get(file2)).toBeTruthy();
+      expect(hashes.get(file1)).not.toBe(hashes.get(file2));
+    });
+
+    it('should skip binary files', async () => {
+      const textFile = join(testDir, 'file.txt');
+      const imageFile = join(testDir, 'image.png');
+
+      await writeFile(textFile, 'text content');
+      await writeFile(imageFile, 'fake image data');
+
+      const hashes = await hashFiles([textFile, imageFile]);
+
+      expect(hashes.size).toBe(2);
+      expect(hashes.get(textFile)).toBeTruthy();
+      expect(hashes.get(imageFile)).toBe(''); // Empty hash for binary
+    });
+
+    it('should handle empty array', async () => {
+      const hashes = await hashFiles([]);
+      expect(hashes.size).toBe(0);
+    });
+
+    it('should handle non-existent files gracefully', async () => {
+      const existingFile = join(testDir, 'exists.txt');
+      const missingFile = join(testDir, 'missing.txt');
+
+      await writeFile(existingFile, 'content');
+
+      const hashes = await hashFiles([existingFile, missingFile]);
+
+      expect(hashes.size).toBe(1);
+      expect(hashes.get(existingFile)).toBeTruthy();
+      expect(hashes.has(missingFile)).toBe(false);
+    });
+  });
+});

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

@@ -116,4 +116,80 @@ describe('journal', () => {
     expect(found).not.toBeNull();
     expect(found?.feature).toBe('test');
   });
+
+  it('should handle new format with file hashes', async () => {
+    const entry = {
+      feature: 'charts',
+      target: 'native' as const,
+      files: [
+        { path: '/file1.ts', hash: 'abc123' },
+        { path: '/file2.ts', hash: 'def456' },
+      ],
+      insertedNav: true,
+      ts: Date.now(),
+    };
+
+    await addEntry(journalPath, entry);
+    const journal = await readJournal(journalPath);
+    
+    expect(journal.entries).toHaveLength(1);
+    expect(journal.entries[0].files).toHaveLength(2);
+    expect(journal.entries[0].files[0]).toHaveProperty('path');
+    expect(journal.entries[0].files[0]).toHaveProperty('hash');
+  });
+
+  it('should migrate old format to new format', async () => {
+    // Write old format manually
+    const oldJournal = {
+      entries: [
+        {
+          feature: 'old-feature',
+          target: 'native' as const,
+          files: ['/file1.ts', '/file2.ts'], // Old format: array of strings
+          insertedNav: true,
+          ts: Date.now(),
+        },
+      ],
+    };
+
+    await writeJournal(journalPath, oldJournal as any);
+
+    // Read should auto-migrate
+    const journal = await readJournal(journalPath);
+    
+    expect(journal.entries).toHaveLength(1);
+    expect(journal.entries[0].files).toHaveLength(2);
+    
+    // Should be converted to new format
+    const firstFile = journal.entries[0].files[0];
+    expect(firstFile).toHaveProperty('path');
+    expect(firstFile).toHaveProperty('hash');
+  });
+
+  it('should store manifest data', async () => {
+    const entry = {
+      feature: 'sentry',
+      target: 'native' as const,
+      files: [{ path: '/file.ts', hash: 'abc' }],
+      insertedNav: true,
+      ts: Date.now(),
+      manifest: {
+        version: '1.0.0',
+        manualSteps: [
+          { title: 'Step 1', description: 'Do something' },
+        ],
+        env: [
+          { key: 'API_KEY', description: 'Your API key', example: 'xxx' },
+        ],
+      },
+    };
+
+    await addEntry(journalPath, entry);
+    const found = await getEntry(journalPath, 'sentry', 'native');
+    
+    expect(found?.manifest).toBeDefined();
+    expect(found?.manifest?.version).toBe('1.0.0');
+    expect(found?.manifest?.manualSteps).toHaveLength(1);
+    expect(found?.manifest?.env).toHaveLength(1);
+  });
 });