vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/utils/requirement-helpers/requirement-file-ops.js

@@ -0,0 +1,392 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { getRequirementsPath } = require('../repo-helpers.cjs');
+const { logger } = require('../logger.cjs');
+const { DEFAULT_INSTRUCTION_TEXT } = require('./requirement-parser.js');
+
+/**
+ * Requirement File Operations
+ * Handles file-level operations for requirements management
+ */
+
+/**
+ * Get the requirements file path for the current hostname
+ * @param {string} repoPath - Repository path (optional)
+ * @returns {string} Requirements file path
+ */
+function getRequirementsFilePath(repoPath = null) {
+  if (repoPath) {
+    const hostname = os.hostname();
+    return path.join(repoPath, '.vibecodingmachine', `REQUIREMENTS-${hostname}.md`);
+  }
+  
+  return getRequirementsPath();
+}
+
+/**
+ * Check if requirements file exists
+ * @param {string} repoPath - Repository path (optional)
+ * @returns {boolean} Whether the file exists
+ */
+function requirementsFileExists(repoPath = null) {
+  const reqPath = getRequirementsFilePath(repoPath);
+  return fs.pathExistsSync(reqPath);
+}
+
+/**
+ * Create requirements file with default structure
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<boolean>} Success status
+ */
+async function createRequirementsFile(repoPath) {
+  try {
+    const reqPath = getRequirementsFilePath(repoPath);
+    const vibecodingmachineDir = path.dirname(reqPath);
+
+    // Ensure .vibecodingmachine directory exists
+    await fs.ensureDir(vibecodingmachineDir);
+
+    // Check if file already exists
+    if (await fs.pathExists(reqPath)) {
+      logger.log(`Requirements file already exists: ${reqPath}`);
+      return true;
+    }
+
+    // Create default content
+    const defaultContent = `# Vibe Coding Machine Requirements
+
+## 🚦 Current Status
+
+PREPARE
+
+## 🔨 Current In Progress Requirement
+
+*No requirement currently in progress*
+
+## ⏳ Requirements not yet completed
+
+- Add your first requirement here
+
+## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG
+
+*No requirements verified yet*
+
+---
+
+## Instructions
+
+${DEFAULT_INSTRUCTION_TEXT}
+
+## Status Progression
+
+Work through these stages in order:
+1. **PREPARE** - Take screenshots, review code, understand requirements
+2. **CREATE** - Implement the actual code/functionality  
+3. **CLEAN UP** - Clean up code, remove duplicates, apply best practices
+4. **VERIFY** - Run automation, take screenshots to verify functionality
+5. **DONE** - Everything is working perfectly, requirement completed
+
+**CRITICAL**: You MUST update the status at each stage and SAVE the file. The VibeCodingMachine app depends on this for autonomous operation.
+`;
+
+    await fs.writeFile(reqPath, defaultContent, 'utf-8');
+    logger.log(`✅ Created requirements file: ${reqPath}`);
+    return true;
+
+  } catch (error) {
+    logger.error(`Error creating requirements file: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Read requirements file content
+ * @param {string} repoPath - Repository path (optional)
+ * @returns {Promise<string|null>} File content or null if error
+ */
+async function readRequirementsFile(repoPath = null) {
+  try {
+    const reqPath = getRequirementsFilePath(repoPath);
+    
+    if (!(await fs.pathExists(reqPath))) {
+      logger.warn(`Requirements file does not exist: ${reqPath}`);
+      return null;
+    }
+
+    const content = await fs.readFile(reqPath, 'utf-8');
+    return content;
+
+  } catch (error) {
+    logger.error(`Error reading requirements file: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Write requirements file content
+ * @param {string} content - Content to write
+ * @param {string} repoPath - Repository path (optional)
+ * @returns {Promise<boolean>} Success status
+ */
+async function writeRequirementsFile(content, repoPath = null) {
+  try {
+    const reqPath = getRequirementsFilePath(repoPath);
+    const vibecodingmachineDir = path.dirname(reqPath);
+
+    // Ensure directory exists
+    await fs.ensureDir(vibecodingmachineDir);
+
+    await fs.writeFile(reqPath, content, 'utf-8');
+    logger.log(`✅ Wrote requirements file: ${reqPath}`);
+    return true;
+
+  } catch (error) {
+    logger.error(`Error writing requirements file: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Backup requirements file
+ * @param {string} repoPath - Repository path (optional)
+ * @param {string} suffix - Backup suffix (default: .backup)
+ * @returns {Promise<string|null>} Backup file path or null if error
+ */
+async function backupRequirementsFile(repoPath = null, suffix = '.backup') {
+  try {
+    const reqPath = getRequirementsFilePath(repoPath);
+    const backupPath = reqPath + suffix;
+
+    if (!(await fs.pathExists(reqPath))) {
+      logger.warn(`Cannot backup non-existent requirements file: ${reqPath}`);
+      return null;
+    }
+
+    await fs.copy(reqPath, backupPath);
+    logger.log(`✅ Backed up requirements file to: ${backupPath}`);
+    return backupPath;
+
+  } catch (error) {
+    logger.error(`Error backing up requirements file: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Get requirements file statistics
+ * @param {string} repoPath - Repository path (optional)
+ * @returns {Promise<Object>} File statistics
+ */
+async function getRequirementsFileStats(repoPath = null) {
+  try {
+    const reqPath = getRequirementsFilePath(repoPath);
+    
+    if (!(await fs.pathExists(reqPath))) {
+      return {
+        exists: false,
+        path: reqPath,
+        size: 0,
+        lines: 0,
+        lastModified: null,
+        created: null
+      };
+    }
+
+    const stats = await fs.stat(reqPath);
+    const content = await fs.readFile(reqPath, 'utf-8');
+    
+    return {
+      exists: true,
+      path: reqPath,
+      size: stats.size,
+      lines: content.split('\n').length,
+      lastModified: stats.mtime,
+      created: stats.birthtime || stats.ctime
+    };
+
+  } catch (error) {
+    logger.error(`Error getting requirements file stats: ${error.message}`);
+    return {
+      exists: false,
+      path: getRequirementsFilePath(repoPath),
+      size: 0,
+      lines: 0,
+      lastModified: null,
+      created: null,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Validate requirements file format
+ * @param {string} repoPath - Repository path (optional)
+ * @returns {Promise<Object>} Validation result
+ */
+async function validateRequirementsFile(repoPath = null) {
+  try {
+    const content = await readRequirementsFile(repoPath);
+    
+    if (!content) {
+      return {
+        isValid: false,
+        errors: ['Requirements file does not exist or cannot be read'],
+        warnings: []
+      };
+    }
+
+    const result = {
+      isValid: true,
+      errors: [],
+      warnings: []
+    };
+
+    const lines = content.split('\n');
+    
+    // Check for required sections
+    const requiredSections = [
+      '## 🚦 Current Status',
+      '## 🔨 Current In Progress Requirement',
+      '## ⏳ Requirements not yet completed',
+      '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG'
+    ];
+
+    for (const section of requiredSections) {
+      if (!content.includes(section)) {
+        result.isValid = false;
+        result.errors.push(`Missing required section: ${section}`);
+      }
+    }
+
+    // Check for status section content
+    if (content.includes('## 🚦 Current Status')) {
+      const statusMatch = content.match(/## 🚦 Current Status\s*\n\s*\*\*([A-Z_]+)\*\*/);
+      if (!statusMatch) {
+        result.isValid = false;
+        result.errors.push('Current Status section exists but no status value found');
+      }
+    }
+
+    // Check file size
+    if (content.length > 100000) { // 100KB
+      result.warnings.push('Requirements file is very large, consider archiving old requirements');
+    }
+
+    // Check for common formatting issues
+    if (content.includes('  ')) {
+      result.warnings.push('File contains double spaces');
+    }
+
+    if (content.includes('\t')) {
+      result.warnings.push('File contains tabs (should use spaces)');
+    }
+
+    // Check line endings
+    if (content.includes('\r\n')) {
+      result.warnings.push('File uses Windows line endings (CRLF)');
+    }
+
+    return result;
+
+  } catch (error) {
+    return {
+      isValid: false,
+      errors: [`Error validating requirements file: ${error.message}`],
+      warnings: []
+    };
+  }
+}
+
+/**
+ * Get all requirements files in repository
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<Array>} Array of requirements file info
+ */
+async function getAllRequirementsFiles(repoPath) {
+  try {
+    const vibecodingmachineDir = path.join(repoPath, '.vibecodingmachine');
+    
+    if (!(await fs.pathExists(vibecodingmachineDir))) {
+      return [];
+    }
+
+    const files = await fs.readdir(vibecodingmachineDir);
+    const requirementsFiles = [];
+
+    for (const file of files) {
+      if (file.startsWith('REQUIREMENTS-') && file.endsWith('.md')) {
+        const filePath = path.join(vibecodingmachineDir, file);
+        const stats = await fs.stat(filePath);
+        const hostname = file.replace('REQUIREMENTS-', '').replace('.md', '');
+
+        requirementsFiles.push({
+          path: filePath,
+          filename: file,
+          hostname,
+          size: stats.size,
+          lastModified: stats.mtime,
+          isCurrent: hostname === os.hostname()
+        });
+      }
+    }
+
+    return requirementsFiles.sort((a, b) => b.lastModified - a.lastModified);
+
+  } catch (error) {
+    logger.error(`Error getting all requirements files: ${error.message}`);
+    return [];
+  }
+}
+
+/**
+ * Clean up old backup files
+ * @param {string} repoPath - Repository path (optional)
+ * @param {number} keepCount - Number of backups to keep (default: 5)
+ * @returns {Promise<number>} Number of files cleaned up
+ */
+async function cleanupBackupFiles(repoPath = null, keepCount = 5) {
+  try {
+    const reqPath = getRequirementsFilePath(repoPath);
+    const dir = path.dirname(reqPath);
+    const baseName = path.basename(reqPath);
+    
+    const files = await fs.readdir(dir);
+    const backupFiles = files
+      .filter(file => file.startsWith(baseName) && file.includes('.backup'))
+      .map(file => ({
+        name: file,
+        path: path.join(dir, file),
+        mtime: fs.statSync(path.join(dir, file)).mtime
+      }))
+      .sort((a, b) => b.mtime - a.mtime);
+
+    let cleanedCount = 0;
+    
+    // Keep the most recent backups, delete older ones
+    for (let i = keepCount; i < backupFiles.length; i++) {
+      await fs.remove(backupFiles[i].path);
+      cleanedCount++;
+      logger.log(`🗑️ Cleaned up old backup: ${backupFiles[i].name}`);
+    }
+
+    return cleanedCount;
+
+  } catch (error) {
+    logger.error(`Error cleaning up backup files: ${error.message}`);
+    return 0;
+  }
+}
+
+module.exports = {
+  getRequirementsFilePath,
+  requirementsFileExists,
+  createRequirementsFile,
+  readRequirementsFile,
+  writeRequirementsFile,
+  backupRequirementsFile,
+  getRequirementsFileStats,
+  validateRequirementsFile,
+  getAllRequirementsFiles,
+  cleanupBackupFiles
+};