vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/interactive/core-ui.js

@@ -0,0 +1,265 @@
+const { t } = require('vibecodingmachine-core');
+const os = require('os');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Translate workflow stage names
+ */
+function translateStage(stage) {
+  const stageMap = {
+    'PREPARE': 'workflow.stage.prepare',
+    'REPRODUCE': 'workflow.stage.reproduce',
+    'CREATE UNIT TEST': 'workflow.stage.create.unit.test',
+    'ACT': 'workflow.stage.act',
+    'CLEAN UP': 'workflow.stage.clean.up',
+    'VERIFY': 'workflow.stage.verify',
+    'RUN UNIT TESTS': 'workflow.stage.run.unit.tests',
+    'DONE': 'workflow.stage.done'
+  };
+
+  const key = stageMap[stage];
+  return key ? t(key) : stage;
+}
+
+function normalizeProjectDirName(input) {
+  const s = String(input || '').trim().toLowerCase();
+  const replaced = s.replace(/\s+/g, '-');
+  const cleaned = replaced.replace(/[^a-z0-9._-]/g, '-');
+  const collapsed = cleaned.replace(/-+/g, '-').replace(/^-|-$/g, '');
+  return collapsed || 'my-project';
+}
+
+async function bootstrapProjectIfInHomeDir() {
+  let cwdResolved = path.resolve(process.cwd());
+  let homeResolved = path.resolve(os.homedir());
+
+  // Check if current directory is under home directory
+  if (cwdResolved.startsWith(homeResolved)) {
+    const relativePath = path.relative(homeResolved, cwdResolved);
+    const projectName = normalizeProjectDirName(relativePath);
+    const projectPath = path.join(homeResolved, 'vibe-coding-projects', projectName);
+
+    console.log(chalk.yellow(`\n⚠️  ${t('interactive.home.dir.warning')}`));
+    console.log(chalk.gray(`   Current: ${cwdResolved}`));
+    console.log(chalk.gray(`   Suggested: ${projectPath}`));
+
+    const { confirm } = require('inquirer');
+    const shouldCreate = await confirm({
+      message: t('interactive.create.project.dir'),
+      default: false
+    });
+
+    if (shouldCreate) {
+      const fs = require('fs-extra');
+      await fs.ensureDir(projectPath);
+      process.chdir(projectPath);
+      console.log(chalk.green(`✅ ${t('interactive.project.created')} ${projectPath}`));
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Format IDE name for display
+ * @param {string} ide - Internal IDE identifier
+ * @returns {string} Display name for IDE
+ */
+function formatIDEName(ide) {
+  const ideNames = {
+    'claude-code': 'Claude Code CLI',
+    'aider': 'Aider CLI',
+    'cline': 'Cline CLI',
+    'continue': 'Continue CLI',
+    'cursor': 'Cursor IDE',
+    'windsurf': 'Windsurf IDE',
+    'vscode': 'VS Code',
+    'replit': 'Replit',
+    'github-copilot': 'GitHub Copilot',
+    'ollama': 'Ollama',
+    'anthropic': 'Anthropic Claude',
+    'groq': 'Groq',
+    'openai': 'OpenAI GPT'
+  };
+  return ideNames[ide] || ide;
+}
+
+/**
+ * Get current AI provider name for IDEs that require it (like Cline and Continue)
+ * @param {string} ide - Internal IDE identifier
+ * @returns {string|null} Provider name or null if not applicable/configured
+ */
+function getCurrentAIProvider(ide) {
+  // Aider, Cline, and Continue require AI provider configuration
+  if (ide !== 'aider' && ide !== 'cline' && ide !== 'continue') {
+    return null;
+  }
+
+  const { getAutoConfig } = require('vibecodingmachine-core');
+  const config = getAutoConfig();
+
+  switch (ide) {
+    case 'aider':
+      return config.aiderModel || 'gpt-4';
+    case 'cline':
+      return config.anthropicModel || 'claude-3-sonnet-20240229';
+    case 'continue':
+      return config.anthropicModel || 'claude-3-sonnet-20240229';
+    default:
+      return null;
+  }
+}
+
+/**
+ * Get unified agent name (IDE or LLM-based)
+ * @param {string} agentType - Agent type (e.g., 'cursor', 'ollama', 'anthropic')
+ * @returns {string} - Display name like "Cursor IDE Agent" or "Ollama (qwen2.5-coder:32b)"
+ */
+function getAgentDisplayName(agentType) {
+  // IDE-based agents
+  if (agentType === 'cursor') return 'Cursor IDE Agent';
+  if (agentType === 'windsurf') return 'Windsurf IDE Agent';
+  if (agentType === 'vscode') return 'VS Code Agent';
+  if (agentType === 'claude-code') return 'Claude Code CLI';
+  if (agentType === 'aider') return 'Aider CLI';
+  if (agentType === 'cline') return 'Cline CLI';
+  if (agentType === 'continue') return 'Continue CLI';
+
+  // LLM-based agents
+  const { getAutoConfig } = require('vibecodingmachine-core');
+  const config = getAutoConfig();
+
+  if (agentType === 'ollama') {
+    const model = config.llmModel || config.aiderModel || 'llama3';
+    return `Ollama (${model})`;
+  }
+
+  if (agentType === 'anthropic') {
+    const model = config.anthropicModel || 'claude-3-sonnet-20240229';
+    return `Anthropic (${model})`;
+  }
+
+  if (agentType === 'groq') {
+    const model = config.groqModel || 'llama3-70b-8192';
+    return `Groq (${model})`;
+  }
+
+  if (agentType === 'openai') {
+    const model = config.openaiModel || 'gpt-4';
+    return `OpenAI (${model})`;
+  }
+
+  // Fallback to IDE formatting
+  return formatIDEName(agentType);
+}
+
+function formatPath(fullPath) {
+  const homeDir = os.homedir();
+  if (fullPath.startsWith(homeDir)) {
+    return fullPath.replace(homeDir, '~');
+  }
+  return fullPath;
+}
+
+async function countRequirements() {
+  try {
+    const { getProjectRequirementStats } = require('vibecodingmachine-core');
+    const repoPath = await getRepoPath();
+    const stats = await getProjectRequirementStats(repoPath);
+    return stats;
+  } catch (error) {
+    return { todo: 0, completed: 0, total: 0 };
+  }
+}
+
+async function getRepoPath() {
+  const { checkVibeCodingMachineExists } = require('vibecodingmachine-core');
+  const repoPath = process.cwd();
+  
+  if (!await checkVibeCodingMachineExists(repoPath)) {
+    throw new Error('Not in a Vibe Coding Machine repository');
+  }
+  
+  return repoPath;
+}
+
+async function getSyncStatus() {
+  try {
+    const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
+    const syncEngine = new SyncEngine();
+    const status = await syncEngine.getStatus();
+    return status;
+  } catch (error) {
+    return { status: 'unknown', message: 'Sync engine not available' };
+  }
+}
+
+async function getCurrentProgress() {
+  try {
+    const { getRequirementsPath } = require('vibecodingmachine-core');
+    const reqPath = await getRequirementsPath();
+    const fs = require('fs-extra');
+    
+    if (!await fs.pathExists(reqPath)) {
+      return { stage: 'NOT_STARTED', progress: 0 };
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const stageMatch = content.match(/## 🚦 Current Status\s*\n\s*\n(.+)/);
+    
+    if (stageMatch) {
+      const stage = stageMatch[1].trim();
+      const progress = getProgressPercentage(stage);
+      return { stage, progress };
+    }
+
+    return { stage: 'UNKNOWN', progress: 0 };
+  } catch (error) {
+    return { stage: 'ERROR', progress: 0 };
+  }
+}
+
+function getProgressPercentage(stage) {
+  const stageProgress = {
+    'PREPARE': 10,
+    'REPRODUCE': 20,
+    'CREATE UNIT TEST': 30,
+    'ACT': 50,
+    'CLEAN UP': 80,
+    'VERIFY': 90,
+    'DONE': 100
+  };
+  
+  return stageProgress[stage] || 0;
+}
+
+// Helper to show goodbye message
+function showGoodbyeMessage() {
+  const hour = new Date().getHours();
+  const message = hour < 21
+    ? '\n👋 ' + t('interactive.goodbye') + '\n'
+    : '\n🌙 ' + t('interactive.goodbye.night') + '\n';
+  console.log(chalk.cyan(message));
+}
+
+// Helper to convert index to letter (0->a, 1->b, etc.)
+function indexToLetter(index) {
+  return String.fromCharCode(97 + index); // 97 is 'a'
+}
+
+module.exports = {
+  translateStage,
+  normalizeProjectDirName,
+  bootstrapProjectIfInHomeDir,
+  formatIDEName,
+  getCurrentAIProvider,
+  getAgentDisplayName,
+  formatPath,
+  countRequirements,
+  getRepoPath,
+  getSyncStatus,
+  getCurrentProgress,
+  showGoodbyeMessage,
+  indexToLetter
+};

package/src/utils/interactive/file-backup.js

@@ -0,0 +1,237 @@
+/**
+ * File Backup Operations
+ * 
+ * Handles backup creation, restoration, and management for requirements files
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Create a backup of the specified file
+ * @param {string} filePath - Path to the file to backup
+ * @param {Object} options - Backup options
+ * @returns {Promise<Object>} Backup result
+ */
+async function createBackup(filePath, options = {}) {
+  try {
+    const backupDir = options.backupDir || path.join(path.dirname(filePath), '.backups');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const fileName = path.basename(filePath);
+    const backupFileName = `${fileName}.${timestamp}.backup`;
+    const backupPath = path.join(backupDir, backupFileName);
+
+    // Ensure backup directory exists
+    await fs.mkdir(backupDir, { recursive: true });
+
+    // Check if source file exists
+    const sourceExists = await fs.access(filePath).then(() => true).catch(() => false);
+    if (!sourceExists) {
+      return {
+        success: false,
+        error: `Source file not found: ${filePath}`
+      };
+    }
+
+    // Copy file to backup location
+    await fs.copyFile(filePath, backupPath);
+
+    return {
+      success: true,
+      backupPath,
+      timestamp: new Date().toISOString(),
+      originalPath: filePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Restore from a backup file
+ * @param {string} backupPath - Path to the backup file
+ * @param {string} targetPath - Path where to restore the file
+ * @returns {Promise<Object>} Restore result
+ */
+async function restoreFromBackup(backupPath, targetPath) {
+  try {
+    // Check if backup file exists
+    const backupExists = await fs.access(backupPath).then(() => true).catch(() => false);
+    if (!backupExists) {
+      return {
+        success: false,
+        error: `Backup file not found: ${backupPath}`
+      };
+    }
+
+    // Create backup of current file before restoring
+    const currentBackup = await createBackup(targetPath, {
+      backupDir: path.join(path.dirname(targetPath), '.pre-restore-backups')
+    });
+
+    // Restore from backup
+    await fs.copyFile(backupPath, targetPath);
+
+    return {
+      success: true,
+      backupPath,
+      targetPath,
+      preRestoreBackup: currentBackup.success ? currentBackup.backupPath : null
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * List all available backups for a file
+ * @param {string} filePath - Path to the original file
+ * @param {Object} options - Listing options
+ * @returns {Promise<Object>} List of backups
+ */
+async function listBackups(filePath, options = {}) {
+  try {
+    const backupDir = options.backupDir || path.join(path.dirname(filePath), '.backups');
+    const fileName = path.basename(filePath);
+    
+    // Check if backup directory exists
+    const dirExists = await fs.access(backupDir).then(() => true).catch(() => false);
+    if (!dirExists) {
+      return {
+        success: true,
+        backups: []
+      };
+    }
+
+    // Read backup directory
+    const files = await fs.readdir(backupDir);
+    const backupFiles = files
+      .filter(file => file.startsWith(fileName) && file.endsWith('.backup'))
+      .map(file => {
+        const filePath = path.join(backupDir, file);
+        return {
+          fileName: file,
+          filePath,
+          timestamp: extractTimestampFromFileName(file),
+          size: null // Will be populated if detailed option is true
+        };
+      })
+      .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+    // Get file sizes if detailed option is true
+    if (options.detailed) {
+      for (const backup of backupFiles) {
+        try {
+          const stats = await fs.stat(backup.filePath);
+          backup.size = stats.size;
+        } catch (error) {
+          backup.size = -1; // Error getting size
+        }
+      }
+    }
+
+    return {
+      success: true,
+      backups: backupFiles
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Clean up old backups
+ * @param {string} filePath - Path to the original file
+ * @param {Object} options - Cleanup options
+ * @returns {Promise<Object>} Cleanup result
+ */
+async function cleanupOldBackups(filePath, options = {}) {
+  try {
+    const maxBackups = options.maxBackups || 10;
+    const olderThan = options.olderThan || null; // Date or days
+    const backupDir = options.backupDir || path.join(path.dirname(filePath), '.backups');
+
+    const listResult = await listBackups(filePath, { backupDir });
+    if (!listResult.success) {
+      return listResult;
+    }
+
+    const { backups } = listResult;
+    if (backups.length <= maxBackups) {
+      return {
+        success: true,
+        deletedBackups: [],
+        message: `No cleanup needed. ${backups.length} backups (limit: ${maxBackups})`
+      };
+    }
+
+    // Determine which backups to delete
+    const backupsToDelete = [];
+    
+    if (olderThan) {
+      // Delete backups older than specified date
+      const cutoffDate = typeof olderThan === 'number' 
+        ? new Date(Date.now() - olderThan * 24 * 60 * 60 * 1000) // days
+        : new Date(olderThan);
+      
+      backupsToDelete.push(...backups.filter(backup => 
+        new Date(backup.timestamp) < cutoffDate
+      ));
+    } else {
+      // Keep only the most recent maxBackups
+      backupsToDelete.push(...backups.slice(maxBackups));
+    }
+
+    // Delete old backups
+    const deletedBackups = [];
+    for (const backup of backupsToDelete) {
+      try {
+        await fs.unlink(backup.filePath);
+        deletedBackups.push(backup);
+      } catch (error) {
+        console.warn(chalk.yellow(`Warning: Failed to delete backup ${backup.fileName}: ${error.message}`));
+      }
+    }
+
+    return {
+      success: true,
+      deletedBackups,
+      remainingBackups: backups.length - deletedBackups.length
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Extract timestamp from backup filename
+ * @param {string} fileName - Backup filename
+ * @returns {string} ISO timestamp
+ */
+function extractTimestampFromFileName(fileName) {
+  const match = fileName.match(/\.(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)\.backup$/);
+  if (match) {
+    return match[1].replace(/-/g, ':').replace(/(\d{2}):(\d{2}):(\d{2})-(\d{3})/, '$1:$2:$3.$4');
+  }
+  return fileName;
+}
+
+module.exports = {
+  createBackup,
+  restoreFromBackup,
+  listBackups,
+  cleanupOldBackups
+};