vibefast-cli 0.1.4 → 0.2.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 @@
+ /$$    /$$ /$$$$$$ /$$$$$$$  /$$$$$$$$ /$$$$$$$$ /$$$$$$   /$$$$$$  /$$$$$$$$
+| $$   | $$|_  $$_/| $$__  $$| $$_____/| $$_____//$$__  $$ /$$__  $$|__  $$__/
+| $$   | $$  | $$  | $$  \ $$| $$      | $$     | $$  \ $$| $$  \__/   | $$   
+|  $$ / $$/  | $$  | $$$$$$$ | $$$$$   | $$$$$  | $$$$$$$$|  $$$$$$    | $$   
+ \  $$ $$/   | $$  | $$__  $$| $$__/   | $$__/  | $$__  $$ \____  $$   | $$   
+  \  $$$/    | $$  | $$  \ $$| $$      | $$     | $$  | $$ /$$  \ $$   | $$   
+   \  $/    /$$$$$$| $$$$$$$/| $$$$$$$$| $$     | $$  | $$|  $$$$$$/   | $$   
+    \_/    |______/|_______/ |________/|__/     |__/  |__/ \______/    |__/   
+                                                                              
+                                                                              
+                                                                              
+                                                                              
+
+
+
+▖▖▄▖▄ ▄▖▄▖▄▖▄▖▄▖
+▌▌▐ ▙▘▙▖▙▖▌▌▚ ▐ 
+▚▘▟▖▙▘▙▖▌ ▛▌▄▌▐ 
+                
+
+██╗   ██╗██╗██████╗ ███████╗███████╗ █████╗ ███████╗████████╗
+██║   ██║██║██╔══██╗██╔════╝██╔════╝██╔══██╗██╔════╝╚══██╔══╝
+██║   ██║██║██████╔╝█████╗  █████╗  ███████║███████╗   ██║   
+╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██╔══╝  ██╔══██║╚════██║   ██║   
+ ╚████╔╝ ██║██████╔╝███████╗██║     ██║  ██║███████║   ██║   
+  ╚═══╝  ╚═╝╚═════╝ ╚══════╝╚═╝     ╚═╝  ╚═╝╚══════╝   ╚═╝   
+