vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/interactive/file-import-export.js

@@ -0,0 +1,305 @@
+const { getRequirementsPath, getVibeCodingMachineDir } = require('vibecodingmachine-core');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Export requirements to different formats
+ */
+async function exportRequirements(format = 'json') {
+  const reqPath = await getRequirementsPath();
+  const stats = await getRequirementsStats();
+  
+  if (!stats) {
+    console.error(chalk.red('❌ Could not read requirements file'));
+    return;
+  }
+  
+  const exportData = {
+    exportedAt: new Date().toISOString(),
+    stats,
+    requirements: {
+      todo: [],
+      verify: [],
+      clarification: [],
+      recycled: []
+    }
+  };
+  
+  try {
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    let currentSection = null;
+    
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      if (trimmed.includes('Requirements not yet completed')) {
+        currentSection = 'todo';
+      } else if (trimmed.includes('Verified by AI screenshot')) {
+        currentSection = 'verify';
+      } else if (trimmed.includes('Needs clarification')) {
+        currentSection = 'clarification';
+      } else if (trimmed.includes('Recycled')) {
+        currentSection = 'recycled';
+      } else if (trimmed.startsWith('- ')) {
+        exportData.requirements[currentSection].push(trimmed.substring(2));
+      }
+    }
+    
+    let fileName;
+    let exportContent;
+    
+    switch (format.toLowerCase()) {
+      case 'json':
+        fileName = `requirements-export-${Date.now()}.json`;
+        exportContent = JSON.stringify(exportData, null, 2);
+        break;
+        
+      case 'csv':
+        fileName = `requirements-export-${Date.now()}.csv`;
+        exportContent = convertToCSV(exportData);
+        break;
+        
+      case 'txt':
+        fileName = `requirements-export-${Date.now()}.txt`;
+        exportContent = convertToText(exportData);
+        break;
+        
+      default:
+        console.error(chalk.red('❌ Unsupported export format'));
+        return;
+    }
+    
+    const exportPath = path.join(path.dirname(reqPath), fileName);
+    await fs.writeFile(exportPath, exportContent);
+    
+    console.log(chalk.green(`✅ Requirements exported to: ${exportPath}`));
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Error exporting requirements:'), error.message);
+  }
+}
+
+function convertToCSV(data) {
+  const csvLines = ['Section,Requirement,ExportedAt'];
+  
+  Object.entries(data.requirements).forEach(([section, requirements]) => {
+    requirements.forEach(req => {
+      csvLines.push(`"${section}","${req.replace(/"/g, '""')}","${data.exportedAt}"`);
+    });
+  });
+  
+  return csvLines.join('\n');
+}
+
+function convertToText(data) {
+  let text = `Requirements Export\n`;
+  text += `Exported at: ${data.exportedAt}\n`;
+  text += `Total requirements: ${data.stats.totalRequirements}\n\n`;
+  
+  Object.entries(data.requirements).forEach(([section, requirements]) => {
+    if (requirements.length > 0) {
+      text += `${section.toUpperCase()} (${requirements.length}):\n`;
+      requirements.forEach((req, index) => {
+        text += `${index + 1}. ${req}\n`;
+      });
+      text += '\n';
+    }
+  });
+  
+  return text;
+}
+
+/**
+ * Import requirements from file
+ */
+async function importRequirements(importPath) {
+  if (!await fs.pathExists(importPath)) {
+    console.error(chalk.red('❌ Import file not found'));
+    return;
+  }
+  
+  try {
+    const ext = path.extname(importPath).toLowerCase();
+    let requirements = [];
+    
+    switch (ext) {
+      case '.json':
+        const data = await fs.readJson(importPath);
+        requirements = Object.values(data.requirements).flat();
+        break;
+        
+      case '.csv':
+        const csvContent = await fs.readFile(importPath, 'utf8');
+        const lines = csvContent.split('\n');
+        for (let i = 1; i < lines.length; i++) { // Skip header
+          const cols = lines[i].split(',');
+          if (cols.length >= 2) {
+            const requirement = cols[1].replace(/^"|"$/g, '').replace(/""/g, '"');
+            requirements.push(requirement);
+          }
+        }
+        break;
+        
+      case '.txt':
+        const txtContent = await fs.readFile(importPath, 'utf8');
+        const txtLines = txtContent.split('\n');
+        for (const line of txtLines) {
+          const trimmed = line.trim();
+          if (trimmed && /^\d+\./.test(trimmed)) {
+            requirements.push(trimmed.replace(/^\d+\.\s*/, ''));
+          }
+        }
+        break;
+        
+      default:
+        console.error(chalk.red('❌ Unsupported import format'));
+        return;
+    }
+    
+    if (requirements.length === 0) {
+      console.log(chalk.yellow('⚠️  No requirements found in import file'));
+      return;
+    }
+    
+    console.log(chalk.green(`✅ Found ${requirements.length} requirements to import`));
+    
+    const reqPath = await getRequirementsPath();
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    // Find TODO section
+    const todoIndex = lines.findIndex(line => line.includes('Requirements not yet completed'));
+    if (todoIndex === -1) {
+      console.error(chalk.red('❌ TODO section not found in requirements file'));
+      return;
+    }
+    
+    // Insert requirements at the end of TODO section
+    let insertIndex = todoIndex + 1;
+    while (insertIndex < lines.length && !lines[insertIndex].startsWith('##') && lines[insertIndex].trim() !== '') {
+      insertIndex++;
+    }
+    
+    // Add a blank line if needed
+    if (insertIndex < lines.length && lines[insertIndex].trim() !== '') {
+      lines.splice(insertIndex, 0, '');
+      insertIndex++;
+    }
+    
+    // Add imported requirements
+    const importedRequirements = requirements.map(req => `- ${req}`);
+    lines.splice(insertIndex, 0, ...importedRequirements);
+    
+    await fs.writeFile(reqPath, lines.join('\n'));
+    console.log(chalk.green(`✅ Imported ${requirements.length} requirements`));
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Error importing requirements:'), error.message);
+  }
+}
+
+/**
+ * Get requirements stats (re-exported from validation module)
+ */
+async function getRequirementsStats() {
+  const { getRequirementsStats: getStats } = require('./file-validation');
+  return await getStats();
+}
+
+/**
+ * Export requirements with custom filters
+ */
+async function exportFilteredRequirements(filters = {}) {
+  const reqPath = await getRequirementsPath();
+  const stats = await getRequirementsStats();
+  
+  if (!stats) {
+    console.error(chalk.red('❌ Could not read requirements file'));
+    return;
+  }
+  
+  try {
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    const filteredData = {
+      exportedAt: new Date().toISOString(),
+      filters,
+      requirements: {
+        todo: [],
+        verify: [],
+        clarification: [],
+        recycled: []
+      }
+    };
+    
+    let currentSection = null;
+    
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      if (trimmed.includes('Requirements not yet completed')) {
+        currentSection = 'todo';
+      } else if (trimmed.includes('Verified by AI screenshot')) {
+        currentSection = 'verify';
+      } else if (trimmed.includes('Needs clarification')) {
+        currentSection = 'clarification';
+      } else if (trimmed.includes('Recycled')) {
+        currentSection = 'recycled';
+      } else if (trimmed.startsWith('- ')) {
+        const requirement = trimmed.substring(2);
+        
+        // Apply filters
+        let includeRequirement = true;
+        
+        if (filters.section && filters.section !== currentSection) {
+          includeRequirement = false;
+        }
+        
+        if (filters.keyword && !requirement.toLowerCase().includes(filters.keyword.toLowerCase())) {
+          includeRequirement = false;
+        }
+        
+        if (filters.minLength && requirement.length < filters.minLength) {
+          includeRequirement = false;
+        }
+        
+        if (filters.maxLength && requirement.length > filters.maxLength) {
+          includeRequirement = false;
+        }
+        
+        if (includeRequirement) {
+          filteredData.requirements[currentSection].push(requirement);
+        }
+      }
+    }
+    
+    // Count total filtered requirements
+    const totalFiltered = Object.values(filteredData.requirements).reduce((sum, reqs) => sum + reqs.length, 0);
+    
+    console.log(chalk.green(`✅ Exported ${totalFiltered} filtered requirements`));
+    
+    // Export as JSON by default for filtered exports
+    const fileName = `requirements-filtered-export-${Date.now()}.json`;
+    const exportPath = path.join(path.dirname(reqPath), fileName);
+    const exportContent = JSON.stringify(filteredData, null, 2);
+    
+    await fs.writeFile(exportPath, exportContent);
+    console.log(chalk.green(`✅ Filtered export saved to: ${exportPath}`));
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Error exporting filtered requirements:'), error.message);
+  }
+}
+
+module.exports = {
+  exportRequirements,
+  importRequirements,
+  getRequirementsStats,
+  exportFilteredRequirements,
+  convertToCSV,
+  convertToText
+};

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

@@ -0,0 +1,49 @@
+/**
+ * File Operations - Orchestrates file I/O operations
+ * 
+ * This module coordinates between backup, validation, and import/export operations.
+ * It serves as the main entry point for file-related operations.
+ */
+
+const chalk = require('chalk');
+
+// Import split modules
+const {
+  createBackup,
+  restoreFromBackup,
+  listBackups,
+  cleanupOldBackups
+} = require('./file-backup');
+
+const {
+  validateRequirementsFile,
+  getRequirementsStats,
+  checkDuplicateRequirements,
+  checkOrphanedResponses
+} = require('./file-validation');
+
+const {
+  exportRequirements,
+  importRequirements,
+  exportFilteredRequirements
+} = require('./file-import-export');
+
+// Re-export all functions for backward compatibility
+module.exports = {
+  // Backup operations
+  createBackup,
+  restoreFromBackup,
+  listBackups,
+  cleanupOldBackups,
+  
+  // Validation operations
+  validateRequirementsFile,
+  getRequirementsStats,
+  checkDuplicateRequirements,
+  checkOrphanedResponses,
+  
+  // Import/Export operations
+  exportRequirements,
+  importRequirements,
+  exportFilteredRequirements
+};

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

@@ -0,0 +1,276 @@
+const { getRequirementsPath } = require('vibecodingmachine-core');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+
+/**
+ * Validate requirements file format
+ */
+async function validateRequirementsFile() {
+  const reqPath = await getRequirementsPath();
+  
+  if (!await fs.pathExists(reqPath)) {
+    console.log(chalk.red('❌ Requirements file not found'));
+    return false;
+  }
+  
+  try {
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    const issues = [];
+    let hasTodoSection = false;
+    let hasVerifySection = false;
+    let hasStatusSection = false;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line.includes('Requirements not yet completed')) {
+        hasTodoSection = true;
+      }
+      
+      if (line.includes('Verified by AI screenshot')) {
+        hasVerifySection = true;
+      }
+      
+      if (line.includes('🚦 Current Status')) {
+        hasStatusSection = true;
+      }
+      
+      // Check for malformed requirement lines
+      if (line && !line.startsWith('#') && !line.startsWith('-') && !line.startsWith('[') && !line.startsWith('```')) {
+        if (i > 0 && !lines[i-1].trim().startsWith('#')) {
+          issues.push(`Line ${i + 1}: Unexpected content - "${line.substring(0, 50)}..."`);
+        }
+      }
+    }
+    
+    console.log(chalk.bold('\n🔍 Requirements File Validation\n'));
+    
+    if (!hasTodoSection) {
+      issues.push('Missing TODO section');
+    }
+    
+    if (!hasVerifySection) {
+      issues.push('Missing verification section');
+    }
+    
+    if (!hasStatusSection) {
+      issues.push('Missing status section');
+    }
+    
+    if (issues.length === 0) {
+      console.log(chalk.green('✅ Requirements file format is valid\n'));
+      return true;
+    } else {
+      console.log(chalk.yellow('⚠️  Issues found:\n'));
+      issues.forEach(issue => console.log(chalk.gray(`  • ${issue}`)));
+      console.log();
+      return false;
+    }
+  } catch (error) {
+    console.error(chalk.red('❌ Error validating requirements file:'), error.message);
+    return false;
+  }
+}
+
+/**
+ * Get requirements file statistics
+ */
+async function getRequirementsStats() {
+  const reqPath = await getRequirementsPath();
+  
+  if (!await fs.pathExists(reqPath)) {
+    return null;
+  }
+  
+  try {
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    const stats = {
+      totalLines: lines.length,
+      todoCount: 0,
+      verifyCount: 0,
+      recycledCount: 0,
+      clarificationCount: 0,
+      totalRequirements: 0,
+      lastModified: (await fs.stat(reqPath)).mtime
+    };
+    
+    let currentSection = null;
+    
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      if (trimmed.includes('Requirements not yet completed')) {
+        currentSection = 'todo';
+      } else if (trimmed.includes('Verified by AI screenshot')) {
+        currentSection = 'verify';
+      } else if (trimmed.includes('Needs clarification')) {
+        currentSection = 'clarification';
+      } else if (trimmed.includes('Recycled')) {
+        currentSection = 'recycled';
+      } else if (trimmed.startsWith('- ')) {
+        stats.totalRequirements++;
+        
+        switch (currentSection) {
+          case 'todo':
+            stats.todoCount++;
+            break;
+          case 'verify':
+            stats.verifyCount++;
+            break;
+          case 'clarification':
+            stats.clarificationCount++;
+            break;
+          case 'recycled':
+            stats.recycledCount++;
+            break;
+        }
+      }
+    }
+    
+    return stats;
+  } catch (error) {
+    console.error(chalk.red('❌ Error getting requirements stats:'), error.message);
+    return null;
+  }
+}
+
+/**
+ * Check for duplicate requirements
+ */
+async function checkDuplicateRequirements() {
+  const reqPath = await getRequirementsPath();
+  
+  if (!await fs.pathExists(reqPath)) {
+    console.log(chalk.red('❌ Requirements file not found'));
+    return [];
+  }
+  
+  try {
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    const requirements = [];
+    const duplicates = [];
+    
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('- ')) {
+        const requirement = trimmed.substring(2);
+        const normalized = requirement.toLowerCase().replace(/\s+/g, ' ').trim();
+        
+        if (requirements[normalized]) {
+          duplicates.push({
+            requirement,
+            originalLine: requirements[normalized].line,
+            duplicateLine: lines.indexOf(line) + 1
+          });
+        } else {
+          requirements[normalized] = {
+            requirement,
+            line: lines.indexOf(line) + 1
+          };
+        }
+      }
+    }
+    
+    if (duplicates.length > 0) {
+      console.log(chalk.bold('\n🔍 Duplicate Requirements Found\n'));
+      console.log(chalk.yellow(`Found ${duplicates.length} duplicate(s):\n`));
+      
+      duplicates.forEach((dup, index) => {
+        console.log(chalk.cyan(`${index + 1}. "${dup.requirement}"`));
+        console.log(chalk.gray(`   Original: Line ${dup.originalLine}`));
+        console.log(chalk.gray(`   Duplicate: Line ${dup.duplicateLine}\n`));
+      });
+    } else {
+      console.log(chalk.green('\n✅ No duplicate requirements found\n'));
+    }
+    
+    return duplicates;
+  } catch (error) {
+    console.error(chalk.red('❌ Error checking duplicates:'), error.message);
+    return [];
+  }
+}
+
+/**
+ * Check for orphaned responses (responses without requirements)
+ */
+async function checkOrphanedResponses() {
+  const reqPath = await getRequirementsPath();
+  
+  if (!await fs.pathExists(reqPath)) {
+    console.log(chalk.red('❌ Requirements file not found'));
+    return [];
+  }
+  
+  try {
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    const orphanedResponses = [];
+    let inClarificationSection = false;
+    let lastRequirement = null;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line.includes('Needs clarification')) {
+        inClarificationSection = true;
+        continue;
+      }
+      
+      if (line.startsWith('##') && !line.includes('Needs clarification')) {
+        inClarificationSection = false;
+        lastRequirement = null;
+        continue;
+      }
+      
+      if (line.startsWith('- ')) {
+        lastRequirement = line;
+        continue;
+      }
+      
+      if (line.startsWith('  - ')) {
+        const response = line.substring(4).trim();
+        
+        if (!lastRequirement) {
+          orphanedResponses.push({
+            response,
+            line: i + 1,
+            type: 'no_requirement'
+          });
+        }
+      }
+    }
+    
+    if (orphanedResponses.length > 0) {
+      console.log(chalk.bold('\n🔍 Orphaned Responses Found\n'));
+      console.log(chalk.yellow(`Found ${orphanedResponses.length} orphaned response(s):\n`));
+      
+      orphanedResponses.forEach((orphan, index) => {
+        console.log(chalk.cyan(`${index + 1}. "${orphan.response}"`));
+        console.log(chalk.gray(`   Line: ${orphan.line}`));
+        console.log(chalk.gray(`   Type: ${orphan.type}\n`));
+      });
+    } else {
+      console.log(chalk.green('\n✅ No orphaned responses found\n'));
+    }
+    
+    return orphanedResponses;
+  } catch (error) {
+    console.error(chalk.red('❌ Error checking orphaned responses:'), error.message);
+    return [];
+  }
+}
+
+module.exports = {
+  validateRequirementsFile,
+  getRequirementsStats,
+  checkDuplicateRequirements,
+  checkOrphanedResponses
+};