vibecodingmachine-core 2025.12.1-534 → 2025.12.6-1702

package/src/sync/sync-engine.js

@@ -0,0 +1,388 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const EventEmitter = require('events');
+
+/**
+ * SyncEngine - Handles bidirectional sync between local files and AWS DynamoDB
+ * 
+ * Features:
+ * - Real-time change detection using file watchers
+ * - Conflict resolution strategies
+ * - Offline queue for disconnected state
+ * - Change history tracking
+ * - Delta sync for efficiency
+ */
+class SyncEngine extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      syncInterval: options.syncInterval || 30000, // 30 seconds
+      conflictStrategy: options.conflictStrategy || 'last-write-wins',
+      offlineMode: options.offlineMode || false,
+      ...options
+    };
+    
+    this.computerId = this._getComputerId();
+    this.isOnline = !this.offlineMode;
+    this.isSyncing = false;
+    this.offlineQueue = [];
+    this.lastSyncTime = null;
+    this.changeHistory = [];
+    
+    // AWS clients (will be initialized when needed)
+    this.dynamoClient = null;
+    this.apiClient = null;
+    this.wsClient = null;
+  }
+  
+  /**
+   * Get unique computer ID
+   */
+  _getComputerId() {
+    const hostname = os.hostname();
+    return hostname;
+  }
+  
+  /**
+   * Initialize AWS clients
+   */
+  async initialize() {
+    try {
+      // Initialize DynamoDB client
+      const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
+      const { DynamoDBDocumentClient } = require('@aws-sdk/lib-dynamodb');
+      
+      const region = process.env.AWS_REGION || 'us-east-1';
+      const client = new DynamoDBClient({ region });
+      this.dynamoClient = DynamoDBDocumentClient.from(client);
+      
+      // Initialize WebSocket client for real-time updates
+      await this._initializeWebSocket();
+      
+      this.emit('initialized');
+      return true;
+    } catch (error) {
+      this.emit('error', { type: 'initialization', error });
+      throw error;
+    }
+  }
+  
+  /**
+   * Initialize WebSocket connection for real-time updates
+   */
+  async _initializeWebSocket() {
+    // TODO: Implement WebSocket connection to AWS IoT Core or API Gateway WebSocket
+    // For now, we'll use polling
+    this.emit('websocket-status', { connected: false, reason: 'not-implemented' });
+  }
+  
+  /**
+   * Start sync engine
+   */
+  async start() {
+    if (!this.dynamoClient) {
+      await this.initialize();
+    }
+    
+    // Start periodic sync
+    this.syncInterval = setInterval(() => {
+      this.sync().catch(error => {
+        this.emit('error', { type: 'sync', error });
+      });
+    }, this.options.syncInterval);
+    
+    // Do initial sync
+    await this.sync();
+    
+    this.emit('started');
+  }
+  
+  /**
+   * Stop sync engine
+   */
+  stop() {
+    if (this.syncInterval) {
+      clearInterval(this.syncInterval);
+      this.syncInterval = null;
+    }
+    
+    this.emit('stopped');
+  }
+  
+  /**
+   * Perform sync operation
+   */
+  async sync() {
+    if (this.isSyncing) {
+      return; // Already syncing
+    }
+    
+    this.isSyncing = true;
+    this.emit('sync-start');
+    
+    try {
+      // Check if online
+      if (!this.isOnline) {
+        this.emit('sync-complete', { status: 'offline', queued: this.offlineQueue.length });
+        return;
+      }
+      
+      // Process offline queue first
+      if (this.offlineQueue.length > 0) {
+        await this._processOfflineQueue();
+      }
+      
+      // Fetch remote changes
+      const remoteChanges = await this._fetchRemoteChanges();
+      
+      // Detect local changes
+      const localChanges = await this._detectLocalChanges();
+      
+      // Resolve conflicts
+      const conflicts = this._detectConflicts(localChanges, remoteChanges);
+      if (conflicts.length > 0) {
+        await this._resolveConflicts(conflicts);
+      }
+      
+      // Apply remote changes locally
+      if (remoteChanges.length > 0) {
+        await this._applyRemoteChanges(remoteChanges);
+      }
+      
+      // Push local changes to remote
+      if (localChanges.length > 0) {
+        await this._pushLocalChanges(localChanges);
+      }
+      
+      this.lastSyncTime = Date.now();
+      this.emit('sync-complete', {
+        status: 'success',
+        remoteChanges: remoteChanges.length,
+        localChanges: localChanges.length,
+        conflicts: conflicts.length
+      });
+    } catch (error) {
+      this.emit('sync-complete', { status: 'error', error: error.message });
+      // Don't throw - just emit error event
+      this.emit('error', { type: 'sync', error: error.message });
+    } finally {
+      this.isSyncing = false;
+    }
+  }
+  
+  /**
+   * Fetch remote changes from DynamoDB
+   */
+  async _fetchRemoteChanges() {
+    const { ScanCommand } = require('@aws-sdk/lib-dynamodb');
+    
+    const tableName = process.env.DYNAMODB_TABLE_NAME || 'vibecodingmachine-requirements';
+    const lastSync = this.lastSyncTime || 0;
+    
+    try {
+      // Use Scan with filter instead of Query since we need to check all items
+      // In production, consider using DynamoDB Streams for real-time updates
+      const command = new ScanCommand({
+        TableName: tableName,
+        FilterExpression: '#ts > :lastSync',
+        ExpressionAttributeNames: {
+          '#ts': 'timestamp'
+        },
+        ExpressionAttributeValues: {
+          ':lastSync': lastSync
+        }
+      });
+      
+      const response = await this.dynamoClient.send(command);
+      return response.Items || [];
+    } catch (error) {
+      this.emit('error', { type: 'fetch-remote', error });
+      return [];
+    }
+  }
+  
+  /**
+   * Detect local changes
+   */
+  async _detectLocalChanges() {
+    // TODO: Implement file watching and change detection
+    // For now, return empty array
+    return [];
+  }
+  
+  /**
+   * Detect conflicts between local and remote changes
+   */
+  _detectConflicts(localChanges, remoteChanges) {
+    const conflicts = [];
+    
+    for (const local of localChanges) {
+      for (const remote of remoteChanges) {
+        if (local.requirementId === remote.requirementId) {
+          // Same requirement modified both locally and remotely
+          if (local.timestamp !== remote.timestamp) {
+            conflicts.push({ local, remote });
+          }
+        }
+      }
+    }
+    
+    return conflicts;
+  }
+  
+  /**
+   * Resolve conflicts based on strategy
+   */
+  async _resolveConflicts(conflicts) {
+    for (const conflict of conflicts) {
+      this.emit('conflict', conflict);
+      
+      let resolution;
+      switch (this.options.conflictStrategy) {
+        case 'last-write-wins':
+          resolution = conflict.local.timestamp > conflict.remote.timestamp
+            ? conflict.local
+            : conflict.remote;
+          break;
+          
+        case 'manual':
+          // Emit event for manual resolution
+          resolution = await new Promise((resolve) => {
+            this.once('conflict-resolved', resolve);
+          });
+          break;
+          
+        case 'auto-merge':
+          resolution = this._autoMerge(conflict.local, conflict.remote);
+          break;
+          
+        default:
+          resolution = conflict.remote; // Default to remote
+      }
+      
+      // Log conflict resolution
+      this.changeHistory.push({
+        type: 'conflict-resolution',
+        timestamp: Date.now(),
+        conflict,
+        resolution
+      });
+    }
+  }
+  
+  /**
+   * Auto-merge non-overlapping changes
+   */
+  _autoMerge(local, remote) {
+    // Simple merge: combine changes from both
+    return {
+      ...remote,
+      ...local,
+      timestamp: Math.max(local.timestamp, remote.timestamp)
+    };
+  }
+  
+  /**
+   * Apply remote changes locally
+   */
+  async _applyRemoteChanges(changes) {
+    for (const change of changes) {
+      try {
+        // TODO: Apply change to local requirements file
+        this.emit('remote-change-applied', change);
+      } catch (error) {
+        this.emit('error', { type: 'apply-remote', change, error });
+      }
+    }
+  }
+  
+  /**
+   * Push local changes to remote
+   */
+  async _pushLocalChanges(changes) {
+    const { PutCommand } = require('@aws-sdk/lib-dynamodb');
+    
+    const tableName = process.env.DYNAMODB_TABLE_NAME || 'vibecodingmachine-requirements';
+    
+    for (const change of changes) {
+      try {
+        const command = new PutCommand({
+          TableName: tableName,
+          Item: {
+            computerId: this.computerId,
+            timestamp: Date.now(),
+            ...change
+          }
+        });
+        
+        await this.dynamoClient.send(command);
+        this.emit('local-change-pushed', change);
+      } catch (error) {
+        this.emit('error', { type: 'push-local', change, error });
+        
+        // Add to offline queue if push fails
+        if (!this.isOnline) {
+          this.offlineQueue.push(change);
+        }
+      }
+    }
+  }
+  
+  /**
+   * Process offline queue
+   */
+  async _processOfflineQueue() {
+    const queue = [...this.offlineQueue];
+    this.offlineQueue = [];
+    
+    for (const change of queue) {
+      try {
+        await this._pushLocalChanges([change]);
+      } catch (error) {
+        // Re-add to queue if still failing
+        this.offlineQueue.push(change);
+      }
+    }
+  }
+  
+  /**
+   * Get sync status
+   */
+  getStatus() {
+    return {
+      computerId: this.computerId,
+      isOnline: this.isOnline,
+      isSyncing: this.isSyncing,
+      lastSyncTime: this.lastSyncTime,
+      queuedChanges: this.offlineQueue.length,
+      conflictStrategy: this.options.conflictStrategy
+    };
+  }
+  
+  /**
+   * Get change history
+   */
+  getHistory(limit = 100) {
+    return this.changeHistory.slice(-limit);
+  }
+  
+  /**
+   * Set online/offline mode
+   */
+  setOnlineMode(isOnline) {
+    this.isOnline = isOnline;
+    this.emit('online-status-changed', { isOnline });
+    
+    if (isOnline && this.offlineQueue.length > 0) {
+      // Trigger sync to process offline queue
+      this.sync().catch(error => {
+        this.emit('error', { type: 'sync', error });
+      });
+    }
+  }
+}
+
+module.exports = SyncEngine;

package/src/utils/requirement-helpers.js

@@ -61,67 +61,87 @@ async function promoteToVerified(reqPath, requirementTitle) {
   try {
     const content = await fs.readFile(reqPath, 'utf-8');
     const lines = content.split('\n');
-    const updatedLines = [];
     let inVerifySection = false;
-    let verifyCount = 0;
-    let requirementToMove = null;
+    let requirementStartIndex = -1;
+    let requirementEndIndex = -1;
+    const normalizedTitle = requirementTitle.trim();
 
-    for (const line of lines) {
-      if (line.includes('## ✅ Verified by AI screenshot')) {
+    // Find the requirement in TO VERIFY section (new ### format)
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check if we're entering TO VERIFY section (multiple variants)
+      if (trimmed.startsWith('##') && !trimmed.startsWith('###') && 
+          (trimmed.includes('TO VERIFY') || trimmed.includes('Verified by AI screenshot'))) {
         inVerifySection = true;
-        updatedLines.push(line);
         continue;
       }
 
-      if (inVerifySection && line.startsWith('## ')) {
+      // Check if we're leaving TO VERIFY section
+      if (inVerifySection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
         inVerifySection = false;
-        updatedLines.push(line);
-        continue;
       }
 
-      if (inVerifySection && line.startsWith('- ')) {
-        const reqText = parseRequirementLine(line);
-        if (reqText === requirementTitle || reqText.includes(requirementTitle)) {
-          requirementToMove = reqText;
-          verifyCount++;
-          continue;
+      // Look for requirement in TO VERIFY section (### header format)
+      if (inVerifySection && trimmed.startsWith('###')) {
+        const title = trimmed.replace(/^###\s*/, '').trim();
+        if (title === normalizedTitle || title.includes(normalizedTitle) || normalizedTitle.includes(title)) {
+          requirementStartIndex = i;
+          
+          // Find the end of this requirement block
+          for (let j = i + 1; j < lines.length; j++) {
+            const nextLine = lines[j].trim();
+            if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+              requirementEndIndex = j;
+              break;
+            }
+          }
+          if (requirementEndIndex === -1) {
+            requirementEndIndex = lines.length;
+          }
+          break;
         }
-        verifyCount++;
       }
+    }
 
-      updatedLines.push(line);
+    if (requirementStartIndex === -1) {
+      return false;
     }
 
-    if (requirementToMove) {
-      // CHANGELOG.md should be at repository root, not in .vibecodingmachine directory
-      const allnightDir = path.dirname(reqPath); // .vibecodingmachine directory
-      const repoRoot = path.dirname(allnightDir); // repository root (one level up)
-      const changelogPath = path.join(repoRoot, 'CHANGELOG.md');
-      const timestamp = new Date().toISOString().split('T')[0];
-      const changelogEntry = `- ${requirementToMove} (${timestamp})`;
+    // Extract requirement block
+    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+    const extractedTitle = lines[requirementStartIndex].replace(/^###\s*/, '').trim();
 
-      let changelogContent = '';
-      if (await fs.pathExists(changelogPath)) {
-        changelogContent = await fs.readFile(changelogPath, 'utf-8');
-      } else {
-        changelogContent = '# Changelog\n\n## Verified Requirements\n\n';
-      }
+    // Remove requirement from TO VERIFY section
+    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
 
-      if (changelogContent.includes('## Verified Requirements')) {
-        changelogContent = changelogContent.replace(
-          '## Verified Requirements\n',
-          `## Verified Requirements\n${changelogEntry}\n`
-        );
-      } else {
-        changelogContent += `\n## Verified Requirements\n${changelogEntry}\n`;
-      }
+    // Add to CHANGELOG.md
+    const allnightDir = path.dirname(reqPath);
+    const repoRoot = path.dirname(allnightDir);
+    const changelogPath = path.join(repoRoot, 'CHANGELOG.md');
+    const timestamp = new Date().toISOString().split('T')[0];
+    const changelogEntry = `- ${extractedTitle} (${timestamp})`;
+
+    let changelogContent = '';
+    if (await fs.pathExists(changelogPath)) {
+      changelogContent = await fs.readFile(changelogPath, 'utf-8');
+    } else {
+      changelogContent = '# Changelog\n\n## Verified Requirements\n\n';
+    }
 
-      await fs.writeFile(changelogPath, changelogContent);
-      await fs.writeFile(reqPath, updatedLines.join('\n'));
-      return true;
+    if (changelogContent.includes('## Verified Requirements')) {
+      changelogContent = changelogContent.replace(
+        '## Verified Requirements\n',
+        `## Verified Requirements\n${changelogEntry}\n`
+      );
+    } else {
+      changelogContent += `\n## Verified Requirements\n${changelogEntry}\n`;
     }
 
-    return false;
+    await fs.writeFile(changelogPath, changelogContent);
+    await fs.writeFile(reqPath, lines.join('\n'));
+    return true;
   } catch (error) {
     throw new Error(`Failed to promote requirement to verified: ${error.message}`);
   }
@@ -315,16 +335,17 @@ async function promoteTodoToVerify(reqPath, requirementTitle) {
  * Move requirement from TO VERIFY back to TODO section
  * @param {string} reqPath - Path to REQUIREMENTS file
  * @param {string} requirementTitle - Title of requirement to move
+ * @param {string} explanation - Optional explanation of what went wrong
  * @returns {Promise<boolean>} Success status
  */
-async function demoteVerifyToTodo(reqPath, requirementTitle) {
+async function demoteVerifyToTodo(reqPath, requirementTitle, explanation = '') {
   try {
     const content = await fs.readFile(reqPath, 'utf-8');
     const lines = content.split('\n');
     
-    // Find the requirement block in TO VERIFY section (### header format)
-    let requirementStartIndex = -1;
-    let requirementEndIndex = -1;
+    // Find ALL matching requirements in TO VERIFY section and remove them
+    // We'll collect all requirement blocks to remove, then process them
+    const requirementsToRemove = [];
     let inVerifySection = false;
     
     const verifySectionVariants = [
@@ -332,26 +353,56 @@ async function demoteVerifyToTodo(reqPath, requirementTitle) {
       '## 🔍 TO VERIFY',
       '## TO VERIFY',
       '## ✅ TO VERIFY',
+      '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG',
       '## ✅ Verified by AI screenshot'
     ];
     
+    // First pass: find all matching requirements in TO VERIFY section
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      if (verifySectionVariants.some(variant => line.includes(variant))) {
-        inVerifySection = true;
-        continue;
-      }
+      const line = lines[i];
+      const trimmed = line.trim();
       
-      if (inVerifySection && line.startsWith('##') && !line.startsWith('###')) {
-        break;
+      // Check if this is a TO VERIFY section header
+      if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+        const isToVerifyHeader = verifySectionVariants.some(variant => {
+          return trimmed === variant || trimmed.startsWith(variant) || 
+                 (trimmed.includes('Verified by AI screenshot') && trimmed.includes('Needs Human to Verify'));
+        });
+        
+        if (isToVerifyHeader) {
+          // Make sure it's not a VERIFIED section (without TO VERIFY)
+          if (!trimmed.includes('## 📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) && !trimmed.includes('📝 VERIFIED')) {
+            inVerifySection = true;
+            continue;
+          }
+        } else if (inVerifySection) {
+          // Check if we're leaving TO VERIFY section (hit a different section)
+          if (trimmed.includes('⏳ Requirements not yet completed') ||
+              trimmed.includes('## 📝 VERIFIED') ||
+              trimmed.includes('## ♻️ RECYCLED') ||
+              trimmed.includes('## 📦 RECYCLED') ||
+              trimmed.includes('## ❓ Requirements needing')) {
+            // We've left the TO VERIFY section
+            inVerifySection = false;
+          }
+        }
       }
       
-      if (inVerifySection && line.startsWith('###')) {
-        const title = line.replace(/^###\s*/, '').trim();
-        if (title && (title === requirementTitle || title.includes(requirementTitle) || requirementTitle.includes(title))) {
-          requirementStartIndex = i;
+      // Look for requirement in TO VERIFY section
+      if (inVerifySection && trimmed.startsWith('###')) {
+        const title = trimmed.replace(/^###\s*/, '').trim();
+        // Normalize titles for matching (handle TRY AGAIN prefixes)
+        const normalizedTitle = title.replace(/^TRY AGAIN \(\d+(st|nd|rd|th) time\):\s*/i, '').trim();
+        const normalizedRequirementTitle = requirementTitle.replace(/^TRY AGAIN \(\d+(st|nd|rd|th) time\):\s*/i, '').trim();
+        
+        if (title && (title === requirementTitle || 
+                      normalizedTitle === normalizedRequirementTitle ||
+                      title.includes(requirementTitle) || 
+                      requirementTitle.includes(title) ||
+                      normalizedTitle.includes(normalizedRequirementTitle) ||
+                      normalizedRequirementTitle.includes(normalizedTitle))) {
           // Find the end of this requirement (next ### or ## header)
+          let requirementEndIndex = lines.length;
           for (let j = i + 1; j < lines.length; j++) {
             const nextLine = lines[j].trim();
             if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
@@ -359,31 +410,49 @@ async function demoteVerifyToTodo(reqPath, requirementTitle) {
               break;
             }
           }
-          if (requirementEndIndex === -1) {
-            requirementEndIndex = lines.length;
-          }
-          break;
+          
+          // Store this requirement to remove (we'll use the first one for moving to TODO)
+          requirementsToRemove.push({
+            start: i,
+            end: requirementEndIndex,
+            block: lines.slice(i, requirementEndIndex)
+          });
         }
       }
     }
     
-    if (requirementStartIndex === -1) {
+    if (requirementsToRemove.length === 0) {
       return false;
     }
     
-    // Extract the requirement block
-    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+    // Use the first matching requirement for moving to TODO (with TRY AGAIN prefix)
+    const firstRequirement = requirementsToRemove[0];
+    const requirementBlock = [...firstRequirement.block];
     
     // Update title with TRY AGAIN prefix
     const originalTitle = requirementBlock[0].replace(/^###\s*/, '').trim();
     const titleWithPrefix = addTryAgainPrefix(originalTitle);
     requirementBlock[0] = `### ${titleWithPrefix}`;
     
-    // Remove the requirement from its current location
-    const updatedLines = [
-      ...lines.slice(0, requirementStartIndex),
-      ...lines.slice(requirementEndIndex)
-    ];
+    // Add explanation to the requirement description if provided
+    if (explanation && explanation.trim()) {
+      // Find where to insert the explanation (after the title, before any existing content)
+      // Insert after first line (title) with a blank line and "What went wrong:" section
+      const explanationLines = [
+        '',
+        '**What went wrong (from previous attempt):**',
+        explanation.trim(),
+        ''
+      ];
+      requirementBlock.splice(1, 0, ...explanationLines);
+    }
+    
+    // Remove ALL matching requirements from TO VERIFY section (work backwards to preserve indices)
+    const updatedLines = [...lines];
+    for (let i = requirementsToRemove.length - 1; i >= 0; i--) {
+      const req = requirementsToRemove[i];
+      updatedLines.splice(req.start, req.end - req.start);
+    }
     
     // Find or create TODO section
     let todoIndex = -1;