vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/requirement-management/default-requirement-manager.js

@@ -0,0 +1,321 @@
+/**
+ * Manages default requirement lifecycle (create, edit, delete, pause, resume, status tracking)
+ */
+class DefaultRequirementManager {
+  constructor(storage) {
+    this.storage = storage;
+    this.consecutiveFailuresThreshold = 5;
+  }
+
+  /**
+   * Create a new default requirement
+   * @param {Object} requirement - Requirement data
+   * @param {string} requirement.title - Requirement title
+   * @param {string} requirement.description - Requirement description
+   * @param {number} requirement.maxIterations - Maximum iterations
+   * @returns {Object} Created requirement
+   */
+  async create(requirement) {
+    const { title, description, maxIterations } = requirement;
+    
+    if (!title || !description || !maxIterations) {
+      throw new Error('Title, description, and maxIterations are required');
+    }
+
+    if (maxIterations < 1 || maxIterations > 1000) {
+      throw new Error('maxIterations must be between 1 and 1000');
+    }
+
+    const data = await this.storage.read();
+    
+    if (data.defaultRequirement) {
+      throw new Error('Default requirement already exists');
+    }
+
+    const newRequirement = {
+      title,
+      description,
+      maxIterations,
+      status: 'ACTIVE',
+      createdAt: Date.now(),
+      iterationCount: 0,
+      consecutiveFailures: 0,
+      lastIterationAt: null
+    };
+
+    data.defaultRequirement = newRequirement;
+    await this.storage.write(data);
+
+    return newRequirement;
+  }
+
+  /**
+   * Edit existing default requirement
+   * @param {Object} updates - Updates to apply
+   * @returns {Object} Updated requirement
+   */
+  async edit(updates) {
+    const data = await this.storage.read();
+    
+    if (!data.defaultRequirement) {
+      throw new Error('No default requirement exists');
+    }
+
+    const { title, description, maxIterations } = updates;
+    
+    if (title !== undefined) {
+      if (!title.trim()) {
+        throw new Error('Title cannot be empty');
+      }
+      data.defaultRequirement.title = title.trim();
+    }
+    
+    if (description !== undefined) {
+      if (!description.trim()) {
+        throw new Error('Description cannot be empty');
+      }
+      data.defaultRequirement.description = description.trim();
+    }
+    
+    if (maxIterations !== undefined) {
+      if (maxIterations < 1 || maxIterations > 1000) {
+        throw new Error('maxIterations must be between 1 and 1000');
+      }
+      data.defaultRequirement.maxIterations = maxIterations;
+    }
+
+    data.defaultRequirement.updatedAt = Date.now();
+    await this.storage.write(data);
+
+    return data.defaultRequirement;
+  }
+
+  /**
+   * Delete default requirement
+   */
+  async delete() {
+    const data = await this.storage.read();
+    
+    if (!data.defaultRequirement) {
+      throw new Error('No default requirement exists');
+    }
+
+    data.defaultRequirement = null;
+    await this.storage.write(data);
+  }
+
+  /**
+   * Get current status of default requirement
+   * @returns {Object|null} Current status or null if no requirement
+   */
+  async getStatus() {
+    const data = await this.storage.read();
+    return data.defaultRequirement || null;
+  }
+
+  /**
+   * Check if default requirement should stop
+   * @returns {boolean} True if should stop
+   */
+  async shouldStop() {
+    const requirement = await this.getStatus();
+    
+    if (!requirement) {
+      return true;
+    }
+
+    // Stop if status is DONE
+    if (requirement.status === 'DONE') {
+      return true;
+    }
+
+    // Stop if max iterations reached
+    if (requirement.iterationCount >= requirement.maxIterations) {
+      return true;
+    }
+
+    // Stop if consecutive failures threshold reached
+    if (requirement.consecutiveFailures >= this.consecutiveFailuresThreshold) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Pause default requirement
+   */
+  async pause() {
+    const data = await this.storage.read();
+    
+    if (!data.defaultRequirement) {
+      throw new Error('No default requirement exists');
+    }
+
+    if (data.defaultRequirement.status === 'PAUSED') {
+      return; // Already paused
+    }
+
+    data.defaultRequirement.status = 'PAUSED';
+    data.defaultRequirement.pausedAt = Date.now();
+    await this.storage.write(data);
+  }
+
+  /**
+   * Resume default requirement
+   */
+  async resume() {
+    const data = await this.storage.read();
+    
+    if (!data.defaultRequirement) {
+      throw new Error('No default requirement exists');
+    }
+
+    if (data.defaultRequirement.status === 'ACTIVE') {
+      return; // Already active
+    }
+
+    data.defaultRequirement.status = 'ACTIVE';
+    data.defaultRequirement.resumedAt = Date.now();
+    await this.storage.write(data);
+  }
+
+  /**
+   * Increment iteration count
+   */
+  async incrementIteration() {
+    const data = await this.storage.read();
+    
+    if (!data.defaultRequirement) {
+      throw new Error('No default requirement exists');
+    }
+
+    data.defaultRequirement.iterationCount += 1;
+    data.defaultRequirement.lastIterationAt = Date.now();
+    
+    // Reset consecutive failures on successful iteration
+    data.defaultRequirement.consecutiveFailures = 0;
+    
+    await this.storage.write(data);
+  }
+
+  /**
+   * Record a failure and increment consecutive failures
+   */
+  async recordFailure() {
+    const data = await this.storage.read();
+    
+    if (!data.defaultRequirement) {
+      throw new Error('No default requirement exists');
+    }
+
+    data.defaultRequirement.consecutiveFailures += 1;
+    await this.storage.write(data);
+  }
+
+  /**
+   * Reset consecutive failures to 0
+   */
+  async resetFailures() {
+    const data = await this.storage.read();
+    
+    if (!data.defaultRequirement) {
+      throw new Error('No default requirement exists');
+    }
+
+    data.defaultRequirement.consecutiveFailures = 0;
+    await this.storage.write(data);
+  }
+
+  /**
+   * Mark default requirement as done
+   * @param {string} reason - Reason for completion
+   */
+  async markDone(reason = 'Completed successfully') {
+    const data = await this.storage.read();
+    
+    if (!data.defaultRequirement) {
+      throw new Error('No default requirement exists');
+    }
+
+    data.defaultRequirement.status = 'DONE';
+    data.defaultRequirement.completedAt = Date.now();
+    data.defaultRequirement.completionReason = reason;
+    await this.storage.write(data);
+  }
+
+  /**
+   * Get statistics for default requirement
+   * @returns {Object} Statistics
+   */
+  async getStatistics() {
+    const requirement = await this.getStatus();
+    
+    if (!requirement) {
+      return null;
+    }
+
+    const now = Date.now();
+    const createdAt = requirement.createdAt;
+    const ageMs = now - createdAt;
+    const ageHours = Math.floor(ageMs / (1000 * 60 * 60));
+    
+    const iterationsPerHour = requirement.iterationCount > 0 && ageHours > 0 
+      ? (requirement.iterationCount / ageHours).toFixed(2)
+      : 0;
+
+    return {
+      title: requirement.title,
+      status: requirement.status,
+      iterations: requirement.iterationCount,
+      maxIterations: requirement.maxIterations,
+      consecutiveFailures: requirement.consecutiveFailures,
+      completionPercentage: Math.round((requirement.iterationCount / requirement.maxIterations) * 100),
+      ageHours,
+      iterationsPerHour,
+      createdAt: requirement.createdAt,
+      lastIterationAt: requirement.lastIterationAt,
+      ...(requirement.completedAt && { completedAt: requirement.completedAt }),
+      ...(requirement.completionReason && { completionReason: requirement.completionReason })
+    };
+  }
+
+  /**
+   * Validate default requirement data
+   * @param {Object} requirement - Requirement data to validate
+   * @returns {Object} Validation result
+   */
+  validate(requirement) {
+    const errors = [];
+    
+    if (!requirement) {
+      errors.push('Requirement data is required');
+      return { valid: false, errors };
+    }
+
+    if (!requirement.title || typeof requirement.title !== 'string') {
+      errors.push('Title is required and must be a string');
+    }
+
+    if (!requirement.description || typeof requirement.description !== 'string') {
+      errors.push('Description is required and must be a string');
+    }
+
+    if (!requirement.maxIterations || typeof requirement.maxIterations !== 'number') {
+      errors.push('maxIterations is required and must be a number');
+    } else if (requirement.maxIterations < 1 || requirement.maxIterations > 1000) {
+      errors.push('maxIterations must be between 1 and 1000');
+    }
+
+    if (requirement.status && !['ACTIVE', 'PAUSED', 'DONE'].includes(requirement.status)) {
+      errors.push('Status must be one of: ACTIVE, PAUSED, DONE');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+}
+
+module.exports = { DefaultRequirementManager };

package/src/requirement-management/requirement-file-parser.js

@@ -0,0 +1,159 @@
+const fs = require('fs');
+
+/**
+ * Parses REQUIREMENTS.md files to extract TODO, TO VERIFY, and VERIFIED sections
+ */
+class RequirementFileParser {
+  constructor() {
+    this.sectionHeaders = {
+      TODO: /^##\s*TODO\s*$/mi,
+      'TO VERIFY': /^##\s*TO\s+VERIFY\s*$/mi,
+      VERIFIED: /^##\s*VERIFIED\s*$/mi
+    };
+  }
+
+  /**
+   * Parse a REQUIREMENTS.md file and extract items from each section
+   * @param {string} filePath - Path to the REQUIREMENTS.md file
+   * @returns {Object} Object with todo, toVerify, and verified arrays
+   */
+  parse(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      return this.parseContent(content);
+    } catch (error) {
+      throw new Error(`Failed to read requirements file: ${error.message}`);
+    }
+  }
+
+  /**
+   * Parse markdown content and extract requirement items
+   * @param {string} content - Markdown content
+   * @returns {Object} Object with todo, toVerify, and verified arrays
+   */
+  parseContent(content) {
+    const sections = {
+      todo: [],
+      toVerify: [],
+      verified: []
+    };
+
+    // Split content by section headers
+    const lines = content.split('\n');
+    let currentSection = null;
+    let currentIndentation = 0;
+
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      
+      // Check for section headers
+      if (this.sectionHeaders.TODO.test(trimmedLine)) {
+        currentSection = 'todo';
+        currentIndentation = 0;
+        continue;
+      } else if (this.sectionHeaders['TO VERIFY'].test(trimmedLine)) {
+        currentSection = 'toVerify';
+        currentIndentation = 0;
+        continue;
+      } else if (this.sectionHeaders.VERIFIED.test(trimmedLine)) {
+        currentSection = 'verified';
+        currentIndentation = 0;
+        continue;
+      }
+
+      // Skip if not in a section
+      if (!currentSection) {
+        continue;
+      }
+
+      // Parse list items
+      const listItemMatch = line.match(/^(\s*)- \[([ x])\]\s*(.+)$/);
+      if (listItemMatch) {
+        const [, indentation, checkbox, itemText] = listItemMatch;
+        
+        // Only include items at the current indentation level (skip sub-bullets)
+        if (indentation.length <= currentIndentation || currentIndentation === 0) {
+          currentIndentation = indentation.length;
+          // Preserve original text formatting (don't clean markdown)
+          sections[currentSection].push(itemText);
+        }
+      }
+    }
+
+    return sections;
+  }
+
+  /**
+   * Clean item text by removing markdown formatting
+   * @param {string} text - Raw item text
+   * @returns {string} Cleaned text
+   */
+  cleanItemText(text) {
+    return text
+      // Remove bold formatting
+      .replace(/\*\*(.*?)\*\*/g, '$1')
+      // Remove italic formatting
+      .replace(/\*(.*?)\*/g, '$1')
+      // Remove inline code formatting
+      .replace(/`(.*?)`/g, '$1')
+      // Remove links but keep text
+      .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+      // Remove block quotes
+      .replace(/^>\s+/gm, '')
+      // Trim whitespace
+      .trim();
+  }
+
+  /**
+   * Check if there are regular requirements (TODO or TO VERIFY items)
+   * @param {Object} parsedData - Parsed requirement data
+   * @returns {boolean} True if regular requirements exist
+   */
+  hasRegularRequirements(parsedData) {
+    return parsedData.todo.length > 0 || parsedData.toVerify.length > 0;
+  }
+
+  /**
+   * Get completion status for requirements
+   * @param {Object} parsedData - Parsed requirement data
+   * @returns {Object} Completion statistics
+   */
+  getCompletionStatus(parsedData) {
+    const total = parsedData.todo.length + parsedData.toVerify.length + parsedData.verified.length;
+    const completed = parsedData.verified.length;
+    const remaining = parsedData.todo.length + parsedData.toVerify.length;
+    const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
+
+    return {
+      total,
+      completed,
+      remaining,
+      percentage
+    };
+  }
+
+  /**
+   * Validate parsed data structure
+   * @param {Object} data - Parsed data to validate
+   * @returns {boolean} True if data is valid
+   */
+  validateParsedData(data) {
+    return data && 
+           typeof data === 'object' &&
+           Array.isArray(data.todo) &&
+           Array.isArray(data.toVerify) &&
+           Array.isArray(data.verified);
+  }
+
+  /**
+   * Get summary of parsed requirements
+   * @param {Object} parsedData - Parsed requirement data
+   * @returns {string} Human-readable summary
+   */
+  getSummary(parsedData) {
+    const status = this.getCompletionStatus(parsedData);
+    return `Requirements: ${status.completed}/${status.total} complete (${status.percentage}%)`;
+  }
+}
+
+module.exports = { RequirementFileParser };

package/src/requirement-management/requirement-sequencer.js

@@ -0,0 +1,221 @@
+const RequirementFileParser = require('./requirement-file-parser');
+
+/**
+ * Manages the sequencing and lifecycle of default requirements vs regular requirements
+ */
+class RequirementSequencer {
+  constructor(parser, defaultManager) {
+    this.parser = parser;
+    this.defaultManager = defaultManager;
+  }
+
+  /**
+   * Determine if default requirement should be processed
+   * @param {string} requirementsPath - Path to REQUIREMENTS.md
+   * @returns {boolean} True if default requirement should be processed
+   */
+  async shouldProcessDefault(requirementsPath) {
+    try {
+      // Check if regular requirements exist
+      const parsedData = this.parser.parse(requirementsPath);
+      const hasRegular = this.parser.hasRegularRequirements(parsedData);
+      
+      if (hasRegular) {
+        return false;
+      }
+
+      // Check if default requirement exists and is active
+      const defaultStatus = await this.defaultManager.getStatus();
+      return defaultStatus && defaultStatus.status !== 'DONE';
+    } catch (error) {
+      console.error('Error checking if should process default:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Handle the case when regular requirements are added
+   * @param {string} requirementsPath - Path to REQUIREMENTS.md
+   */
+  async handleRegularRequirementsAdded(requirementsPath) {
+    try {
+      const defaultStatus = await this.defaultManager.getStatus();
+      
+      if (defaultStatus && defaultStatus.status === 'ACTIVE') {
+        await this.defaultManager.pause();
+        console.log('Default requirement paused due to new regular requirements');
+      }
+    } catch (error) {
+      console.error('Error handling regular requirements added:', error);
+    }
+  }
+
+  /**
+   * Handle the case when regular requirements are completed
+   * @param {string} requirementsPath - Path to REQUIREMENTS.md
+   */
+  async handleRegularRequirementsComplete(requirementsPath) {
+    try {
+      const defaultStatus = await this.defaultManager.getStatus();
+      
+      if (defaultStatus && defaultStatus.status === 'PAUSED') {
+        await this.defaultManager.resume();
+        console.log('Default requirement resumed after regular requirements completed');
+      }
+    } catch (error) {
+      console.error('Error handling regular requirements completed:', error);
+    }
+  }
+
+  /**
+   * Check for changes in requirements between two states
+   * @param {string} requirementsPath - Path to REQUIREMENTS.md
+   * @param {Object} previousData - Previous parsed data
+   * @returns {Object} Change information
+   */
+  async checkRequirementsChange(requirementsPath, previousData) {
+    try {
+      const currentData = this.parser.parse(requirementsPath);
+      
+      const previousHasRegular = this.parser.hasRegularRequirements(previousData);
+      const currentHasRegular = this.parser.hasRegularRequirements(currentData);
+      
+      const regularRequirementsAdded = !previousHasRegular && currentHasRegular;
+      const regularRequirementsCompleted = previousHasRegular && !currentHasRegular;
+      
+      return {
+        regularRequirementsAdded,
+        regularRequirementsCompleted,
+        previousData,
+        currentData
+      };
+    } catch (error) {
+      console.error('Error checking requirements change:', error);
+      return {
+        regularRequirementsAdded: false,
+        regularRequirementsCompleted: false,
+        previousData,
+        currentData: null
+      };
+    }
+  }
+
+  /**
+   * Get processing priority (regular vs default)
+   * @param {string} requirementsPath - Path to REQUIREMENTS.md
+   * @returns {string} 'regular', 'default', or 'none'
+   */
+  async getProcessingPriority(requirementsPath) {
+    try {
+      const parsedData = this.parser.parse(requirementsPath);
+      const hasRegular = this.parser.hasRegularRequirements(parsedData);
+      
+      if (hasRegular) {
+        return 'regular';
+      }
+      
+      const defaultStatus = await this.defaultManager.getStatus();
+      if (defaultStatus && defaultStatus.status !== 'DONE') {
+        return 'default';
+      }
+      
+      return 'none';
+    } catch (error) {
+      console.error('Error getting processing priority:', error);
+      return 'none';
+    }
+  }
+
+  /**
+   * Monitor requirements file for changes and handle sequencing
+   * @param {string} requirementsPath - Path to REQUIREMENTS.md
+   * @param {Function} onChange - Callback for changes
+   * @returns {Function} Stop monitoring function
+   */
+  monitorRequirements(requirementsPath, onChange) {
+    let previousData = null;
+    
+    try {
+      previousData = this.parser.parse(requirementsPath);
+    } catch (error) {
+      console.error('Error initial parsing of requirements:', error);
+    }
+
+    const checkInterval = setInterval(async () => {
+      try {
+        const change = await this.checkRequirementsChange(requirementsPath, previousData);
+        
+        if (change.regularRequirementsAdded) {
+          await this.handleRegularRequirementsAdded(requirementsPath);
+          if (onChange) onChange('regular-requirements-added', change);
+        } else if (change.regularRequirementsCompleted) {
+          await this.handleRegularRequirementsComplete(requirementsPath);
+          if (onChange) onChange('regular-requirements-completed', change);
+        }
+        
+        previousData = change.currentData || previousData;
+      } catch (error) {
+        console.error('Error in requirements monitoring:', error);
+      }
+    }, 5000); // Check every 5 seconds
+
+    return () => clearInterval(checkInterval);
+  }
+
+  /**
+   * Get the current state of requirements
+   * @param {string} requirementsPath - Path to REQUIREMENTS.md
+   * @returns {Object} Current state
+   */
+  async getCurrentState(requirementsPath) {
+    try {
+      const parsedData = this.parser.parse(requirementsPath);
+      const defaultStatus = await this.defaultManager.getStatus();
+      const completionStatus = this.parser.getCompletionStatus(parsedData);
+      
+      return {
+        hasRegularRequirements: this.parser.hasRegularRequirements(parsedData),
+        regularRequirements: parsedData.todo.length + parsedData.toVerify.length,
+        completedRequirements: parsedData.verified.length,
+        completionPercentage: completionStatus.percentage,
+        defaultRequirement: defaultStatus,
+        processingPriority: await this.getProcessingPriority(requirementsPath)
+      };
+    } catch (error) {
+      console.error('Error getting current state:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Determine if auto mode should continue running
+   * @param {string} requirementsPath - Path to REQUIREMENTS.md
+   * @returns {boolean} True if auto mode should continue
+   */
+  async shouldContinueAutoMode(requirementsPath) {
+    try {
+      const state = await this.getCurrentState(requirementsPath);
+      
+      if (!state) {
+        return false;
+      }
+      
+      // Continue if there are regular requirements
+      if (state.hasRegularRequirements) {
+        return true;
+      }
+      
+      // Continue if default requirement is active
+      if (state.defaultRequirement && state.defaultRequirement.status === 'ACTIVE') {
+        return true;
+      }
+      
+      return false;
+    } catch (error) {
+      console.error('Error determining if should continue auto mode:', error);
+      return false;
+    }
+  }
+}
+
+module.exports = RequirementSequencer;