vibefast-cli 0.1.4 → 0.2.0

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

package/src/core/hash.ts

@@ -0,0 +1,84 @@
+import { createHash } from 'crypto';
+import { readFile, stat } from 'fs/promises';
+import { log } from './log.js';
+
+/**
+ * Hash a single file using SHA-256
+ * Returns empty string if file doesn't exist or can't be read
+ */
+export async function hashFile(filePath: string): Promise<string> {
+  try {
+    const content = await readFile(filePath);
+    return createHash('sha256').update(content).digest('hex');
+  } catch (error) {
+    // File doesn't exist or can't be read
+    return '';
+  }
+}
+
+/**
+ * Hash multiple files in batches
+ * Skips binary files and large files for performance
+ */
+export async function hashFiles(
+  filePaths: string[],
+  options?: { showProgress?: boolean }
+): Promise<Map<string, string>> {
+  const hashes = new Map<string, string>();
+  
+  // Filter out files we don't need to hash
+  const filesToHash: string[] = [];
+  
+  for (const path of filePaths) {
+    // Skip binary files
+    if (/\.(png|jpg|jpeg|gif|ico|woff|woff2|ttf|eot|svg|mp4|mp3|pdf)$/i.test(path)) {
+      hashes.set(path, ''); // Store empty hash for binary files
+      continue;
+    }
+    
+    // Skip large files (>1MB)
+    try {
+      const stats = await stat(path);
+      if (stats.size > 1024 * 1024) {
+        hashes.set(path, ''); // Store empty hash for large files
+        continue;
+      }
+    } catch {
+      // File doesn't exist, skip
+      continue;
+    }
+    
+    filesToHash.push(path);
+  }
+  
+  // Show progress if many files
+  if (options?.showProgress && filesToHash.length > 20) {
+    log.info(`Computing file hashes for ${filesToHash.length} files...`);
+  }
+  
+  // Process in parallel batches
+  const batchSize = 10;
+  
+  for (let i = 0; i < filesToHash.length; i += batchSize) {
+    const batch = filesToHash.slice(i, i + batchSize);
+    
+    await Promise.all(
+      batch.map(async (path) => {
+        const hash = await hashFile(path);
+        hashes.set(path, hash);
+      })
+    );
+    
+    // Show progress
+    if (options?.showProgress && filesToHash.length > 20) {
+      const progress = Math.min(i + batchSize, filesToHash.length);
+      process.stdout.write(`\r  Progress: ${progress}/${filesToHash.length}`);
+    }
+  }
+  
+  if (options?.showProgress && filesToHash.length > 20) {
+    process.stdout.write('\n');
+  }
+  
+  return hashes;
+}

package/src/core/journal.ts

@@ -1,14 +1,25 @@
 import { readFileContent, writeFileContent, exists, ensureDir } from './fsx.js';
 import { dirname } from 'path';
+import { hashFile } from './hash.js';
+
+export interface FileEntry {
+  path: string;
+  hash: string;
+}
 
 export interface JournalEntry {
   feature: string;
   target: 'native' | 'web';
-  files: string[];
+  files: FileEntry[] | string[]; // Support both old and new format
   insertedNav: boolean;
   ts: number;
   navHref?: string;
   navLabel?: string;
+  manifest?: {
+    version?: string;
+    manualSteps?: any[];
+    env?: any[];
+  };
 }
 
 export interface Journal {
@@ -20,7 +31,34 @@ export async function readJournal(journalPath: string): Promise<Journal> {
     return { entries: [] };
   }
   const content = await readFileContent(journalPath);
-  return JSON.parse(content);
+  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 });
+      }
+      
+      entry.files = newFiles;
+    }
+  }
+  
+  // Save migrated journal
+  if (needsMigration) {
+    await writeJournal(journalPath, journal);
+  }
+  
+  return journal;
 }
 
 export async function writeJournal(journalPath: string, journal: Journal): Promise<void> {

package/src/core/prompt.ts

@@ -0,0 +1,40 @@
+import readlineSync from 'readline-sync';
+
+/**
+ * Prompt user for input
+ * Returns empty string in non-interactive environments (CI/CD)
+ */
+export function promptUser(question: string): string {
+  // Check if we're in a non-interactive environment
+  if (!process.stdin.isTTY) {
+    return '';
+  }
+  
+  // Check for CI environment variables
+  const isCI = process.env.CI === 'true' || 
+               process.env.GITHUB_ACTIONS === 'true' ||
+               process.env.GITLAB_CI === 'true' ||
+               process.env.CIRCLECI === 'true';
+  
+  if (isCI) {
+    return '';
+  }
+  
+  return readlineSync.question(question);
+}
+
+/**
+ * Prompt user for yes/no confirmation
+ * Returns defaultValue in non-interactive environments
+ */
+export function promptYesNo(question: string, defaultYes = false): boolean {
+  const answer = promptUser(question);
+  
+  // Empty answer (non-interactive or just pressed enter)
+  if (answer === '') {
+    return defaultYes;
+  }
+  
+  const normalized = answer.toLowerCase().trim();
+  return normalized === 'y' || normalized === 'yes';
+}

package/src/index.ts

@@ -9,6 +9,8 @@ import { doctorCommand } from './commands/doctor.js';
 import { loginCommand } from './commands/login.js';
 import { devicesCommand } from './commands/devices.js';
 import { logoutCommand } from './commands/logout.js';
+import { statusCommand } from './commands/status.js';
+import { checklistCommand } from './commands/checklist.js';
 
 const program = new Command();
 
@@ -24,5 +26,7 @@ program.addCommand(doctorCommand);
 program.addCommand(listCommand);
 program.addCommand(addCommand);
 program.addCommand(removeCommand);
+program.addCommand(statusCommand);
+program.addCommand(checklistCommand);
 
 program.parse();

package/text.md

@@ -0,0 +1,27 @@
+ /$$    /$$ /$$$$$$ /$$$$$$$  /$$$$$$$$ /$$$$$$$$ /$$$$$$   /$$$$$$  /$$$$$$$$
+| $$   | $$|_  $$_/| $$__  $$| $$_____/| $$_____//$$__  $$ /$$__  $$|__  $$__/
+| $$   | $$  | $$  | $$  \ $$| $$      | $$     | $$  \ $$| $$  \__/   | $$   
+|  $$ / $$/  | $$  | $$$$$$$ | $$$$$   | $$$$$  | $$$$$$$$|  $$$$$$    | $$   
+ \  $$ $$/   | $$  | $$__  $$| $$__/   | $$__/  | $$__  $$ \____  $$   | $$   
+  \  $$$/    | $$  | $$  \ $$| $$      | $$     | $$  | $$ /$$  \ $$   | $$   
+   \  $/    /$$$$$$| $$$$$$$/| $$$$$$$$| $$     | $$  | $$|  $$$$$$/   | $$   
+    \_/    |______/|_______/ |________/|__/     |__/  |__/ \______/    |__/   
+                                                                              
+                                                                              
+                                                                              
+                                                                              
+
+
+
+▖▖▄▖▄ ▄▖▄▖▄▖▄▖▄▖
+▌▌▐ ▙▘▙▖▙▖▌▌▚ ▐ 
+▚▘▟▖▙▘▙▖▌ ▛▌▄▌▐ 
+                
+
+██╗   ██╗██╗██████╗ ███████╗███████╗ █████╗ ███████╗████████╗
+██║   ██║██║██╔══██╗██╔════╝██╔════╝██╔══██╗██╔════╝╚══██╔══╝
+██║   ██║██║██████╔╝█████╗  █████╗  ███████║███████╗   ██║   
+╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██╔══╝  ██╔══██║╚════██║   ██║   
+ ╚████╔╝ ██║██████╔╝███████╗██║     ██║  ██║███████║   ██║   
+  ╚═══╝  ╚═╝╚═════╝ ╚══════╝╚═╝     ╚═╝  ╚═╝╚══════╝   ╚═╝   
+