vibefast-cli 0.1.3 → 0.2.0

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);
+  });
 });

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

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promptYesNo } from '../prompt.js';
+
+describe('prompt', () => {
+  let originalIsTTY: boolean | undefined;
+  let originalCI: string | undefined;
+
+  beforeEach(() => {
+    originalIsTTY = process.stdin.isTTY;
+    originalCI = process.env.CI;
+  });
+
+  afterEach(() => {
+    if (originalIsTTY !== undefined) {
+      (process.stdin as any).isTTY = originalIsTTY;
+    }
+    if (originalCI !== undefined) {
+      process.env.CI = originalCI;
+    } else {
+      delete process.env.CI;
+    }
+  });
+
+  describe('promptYesNo', () => {
+    it('should return default value in non-TTY environment', () => {
+      (process.stdin as any).isTTY = false;
+
+      const result = promptYesNo('Continue?', true);
+      expect(result).toBe(true);
+
+      const result2 = promptYesNo('Continue?', false);
+      expect(result2).toBe(false);
+    });
+
+    it('should return default value in CI environment', () => {
+      process.env.CI = 'true';
+
+      const result = promptYesNo('Continue?', true);
+      expect(result).toBe(true);
+
+      const result2 = promptYesNo('Continue?', false);
+      expect(result2).toBe(false);
+    });
+
+    it('should detect GitHub Actions', () => {
+      process.env.GITHUB_ACTIONS = 'true';
+
+      const result = promptYesNo('Continue?', false);
+      expect(result).toBe(false);
+
+      delete process.env.GITHUB_ACTIONS;
+    });
+
+    it('should detect GitLab CI', () => {
+      process.env.GITLAB_CI = 'true';
+
+      const result = promptYesNo('Continue?', false);
+      expect(result).toBe(false);
+
+      delete process.env.GITLAB_CI;
+    });
+
+    it('should detect CircleCI', () => {
+      process.env.CIRCLECI = 'true';
+
+      const result = promptYesNo('Continue?', false);
+      expect(result).toBe(false);
+
+      delete process.env.CIRCLECI;
+    });
+  });
+});

package/src/core/fsx.ts

@@ -44,12 +44,24 @@ export async function deleteFile(path: string): Promise<void> {
   }
 }
 
+export interface CopyResult {
+  files: string[];
+  conflicts: string[];
+  skipped: string[];
+}
+
 export async function copyTree(
   src: string,
   dest: string,
-  options?: { dryRun?: boolean; force?: boolean }
-): Promise<string[]> {
+  options?: { 
+    dryRun?: boolean; 
+    force?: boolean;
+    interactive?: boolean;
+  }
+): Promise<CopyResult> {
   const copied: string[] = [];
+  const conflicts: string[] = [];
+  const skipped: string[] = [];
   
   async function copyRecursive(srcPath: string, destPath: string) {
     const stats = await stat(srcPath);
@@ -64,9 +76,30 @@ export async function copyTree(
       }
     } else {
       const destExists = await exists(destPath);
-      if (destExists && !options?.force) {
-        throw new Error(`File exists: ${destPath}. Use --force to overwrite.`);
+      
+      if (destExists) {
+        conflicts.push(destPath);
+        
+        // If not force and not interactive, throw error
+        if (!options?.force && !options?.interactive) {
+          throw new Error(`File exists: ${destPath}. Use --force to overwrite.`);
+        }
+        
+        // If interactive and not dry-run, ask user
+        if (options?.interactive && !options?.dryRun) {
+          const { promptYesNo } = await import('./prompt.js');
+          const shouldOverwrite = promptYesNo(
+            `Overwrite ${destPath}? (y/N): `,
+            false
+          );
+          
+          if (!shouldOverwrite) {
+            skipped.push(destPath);
+            return; // Skip this file
+          }
+        }
       }
+      
       if (!options?.dryRun) {
         await ensureDir(dirname(destPath));
         await copyFile(srcPath, destPath);
@@ -76,5 +109,5 @@ export async function copyTree(
   }
   
   await copyRecursive(src, dest);
-  return copied;
+  return { files: copied, conflicts, skipped };
 }