vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/task-generation/task-list-updater.js

@@ -0,0 +1,215 @@
+/**
+ * Task List Updater
+ * 
+ * Dynamically updates the tasks.md file with new refactoring tasks
+ * for files that violate the 555-line limit and other requirements.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const ViolationTaskGenerator = require('./violation-task-generator');
+
+/**
+ * Task list updater class
+ */
+class TaskListUpdater {
+  constructor(options = {}) {
+    this.options = {
+      tasksFilePath: options.tasksFilePath || path.resolve(__dirname, '../../../specs/010-555-max-file-size/tasks.md'),
+      maxFileSize: options.maxFileSize || 555,
+      backupOriginal: options.backupOriginal !== false,
+      ...options
+    };
+    
+    this.taskGenerator = new ViolationTaskGenerator(this.options);
+  }
+
+  /**
+   * Update the tasks file with new violation tasks
+   */
+  async updateTasks(violations) {
+    try {
+      // Read the current tasks file
+      const currentContent = fs.readFileSync(this.options.tasksFilePath, 'utf8');
+      
+      // Create backup if requested
+      if (this.options.backupOriginal) {
+        const backupPath = this.options.tasksFilePath + '.backup';
+        fs.writeFileSync(backupPath, currentContent);
+      }
+      
+      // Generate new tasks for violations
+      const newTasks = this.taskGenerator.generateTasks(violations);
+      
+      // Find where to insert the new tasks
+      const insertionPoint = this.findInsertionPoint(currentContent);
+      
+      // Insert the new tasks
+      const updatedContent = this.insertTasks(currentContent, newTasks, insertionPoint);
+      
+      // Write the updated content
+      fs.writeFileSync(this.options.tasksFilePath, updatedContent);
+      
+      return {
+        success: true,
+        tasksAdded: newTasks.length,
+        violationsProcessed: violations.length,
+        backupCreated: this.options.backupOriginal
+      };
+      
+    } catch (error) {
+      throw new Error(`Failed to update tasks file: ${error.message}`);
+    }
+  }
+
+  /**
+   * Find the appropriate insertion point in the tasks file
+   */
+  findInsertionPoint(content) {
+    // Look for the end of User Story 4 implementation section
+    const userStory4Section = content.match(/## Phase 6: User Story 4.*?### Implementation for User Story 4\s*\n([\s\S]*?)(?=\n##|\n---|$)/);
+    
+    if (userStory4Section) {
+      const implementationContent = userStory4Section[1];
+      
+      // Find the last task in User Story 4
+      const taskMatches = implementationContent.match(/- \[ \] T\d+.*$/gm);
+      
+      if (taskMatches && taskMatches.length > 0) {
+        const lastTask = taskMatches[taskMatches.length - 1];
+        const lastTaskIndex = implementationContent.lastIndexOf(lastTask);
+        
+        return {
+          section: userStory4Section.index,
+          implementationStart: userStory4Section.index + userStory4Section[0].indexOf(implementationContent),
+          insertAfter: userStory4Section.index + userStory4Section[0].indexOf(implementationContent) + lastTaskIndex + lastTask.length
+        };
+      }
+    }
+    
+    // Fallback: insert before the next section or end of file
+    const nextSection = content.indexOf('\n---', content.indexOf('## Phase 6'));
+    return {
+      insertAfter: nextSection !== -1 ? nextSection : content.length
+    };
+  }
+
+  /**
+   * Insert new tasks into the content
+   */
+  insertTasks(content, newTasks, insertionPoint) {
+    if (newTasks.length === 0) {
+      return content;
+    }
+    
+    const before = content.substring(0, insertionPoint.insertAfter);
+    const after = content.substring(insertionPoint.insertAfter);
+    
+    const tasksText = newTasks.map(task => `- [ ] ${task.id} ${task.priority ? '[P] ' : ''}[${task.story}] ${task.description}`).join('\n');
+    
+    return before + '\n' + tasksText + '\n' + after;
+  }
+
+  /**
+   * Check if a task already exists for a file
+   */
+  taskExists(filePath) {
+    try {
+      const content = fs.readFileSync(this.options.tasksFilePath, 'utf8');
+      return content.includes(filePath);
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get current task statistics
+   */
+  getTaskStats() {
+    try {
+      const content = fs.readFileSync(this.options.tasksFilePath, 'utf8');
+      
+      const totalTasks = (content.match(/- \[.\] T\d+/g) || []).length;
+      const completedTasks = (content.match(/- \[x\] T\d+/g) || []).length;
+      const pendingTasks = totalTasks - completedTasks;
+      
+      return {
+        total: totalTasks,
+        completed: completedTasks,
+        pending: pendingTasks,
+        completionPercentage: totalTasks > 0 ? Math.round((completedTasks / totalTasks) * 100) : 0
+      };
+      
+    } catch (error) {
+      return {
+        total: 0,
+        completed: 0,
+        pending: 0,
+        completionPercentage: 0,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Update task completion status
+   */
+  updateTaskStatus(taskId, completed) {
+    try {
+      const content = fs.readFileSync(this.options.tasksFilePath, 'utf8');
+      
+      // Find and replace the task checkbox
+      const taskPattern = new RegExp(`(- \\[)(${completed ? ' ' : 'x'})(\\] ${taskId})`, 'g');
+      const updatedContent = content.replace(taskPattern, `$1${completed ? 'x' : ' '}$3`);
+      
+      if (updatedContent !== content) {
+        fs.writeFileSync(this.options.tasksFilePath, updatedContent);
+        return { success: true, updated: true };
+      } else {
+        return { success: true, updated: false, message: 'Task not found' };
+      }
+      
+    } catch (error) {
+      throw new Error(`Failed to update task status: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate the tasks file structure
+   */
+  validateTasksFile() {
+    try {
+      const content = fs.readFileSync(this.options.tasksFilePath, 'utf8');
+      
+      const issues = [];
+      
+      // Check for required sections
+      if (!content.includes('## Phase 6: User Story 4')) {
+        issues.push('Missing Phase 6: User Story 4 section');
+      }
+      
+      if (!content.includes('### Implementation for User Story 4')) {
+        issues.push('Missing Implementation for User Story 4 section');
+      }
+      
+      // Check task format
+      const invalidTasks = content.match(/- \[.\] [^T\d]/g) || [];
+      if (invalidTasks.length > 0) {
+        issues.push(`Found ${invalidTasks.length} tasks with invalid format`);
+      }
+      
+      return {
+        valid: issues.length === 0,
+        issues
+      };
+      
+    } catch (error) {
+      return {
+        valid: false,
+        issues: [`Failed to read tasks file: ${error.message}`]
+      };
+    }
+  }
+}
+
+module.exports = TaskListUpdater;

package/src/task-generation/task-management-integration.js

@@ -0,0 +1,480 @@
+/**
+ * Task Management Integration
+ * 
+ * Integrates continuous scanning with the task management system
+ * to provide automated task generation and tracking.
+ */
+
+const EventEmitter = require('events');
+const { ContinuousScanner } = require('../monitoring/continuous-scanner');
+const { TaskListUpdater } = require('./task-list-updater');
+const { ViolationTaskGenerator } = require('./violation-task-generator');
+
+/**
+ * Task Management Integration class
+ */
+class TaskManagementIntegration extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      // Scanner configuration
+      scanIntervalMs: options.scanIntervalMs || 60000,
+      maxFileSize: options.maxFileSize || 555,
+      watchPaths: options.watchPaths || [process.cwd()],
+      
+      // Task generation configuration
+      autoGenerateTasks: options.autoGenerateTasks !== false,
+      autoMarkCompleted: options.autoMarkCompleted !== false,
+      taskUpdateDelay: options.taskUpdateDelay || 5000, // 5 seconds
+      
+      // Integration settings
+      enableRealTimeUpdates: options.enableRealTimeUpdates !== false,
+      batchTaskUpdates: options.batchTaskUpdates !== false,
+      maxBatchSize: options.maxBatchSize || 10,
+      
+      ...options
+    };
+    
+    // Components
+    this.scanner = null;
+    this.taskUpdater = new TaskListUpdater();
+    this.taskGenerator = new ViolationTaskGenerator();
+    
+    // State
+    this.isRunning = false;
+    this.pendingTaskUpdates = new Map(); // filePath -> violation
+    this.taskUpdateTimer = null;
+    
+    // Statistics
+    this.stats = {
+      totalViolationsDetected: 0,
+      totalTasksGenerated: 0,
+      totalTasksCompleted: 0,
+      totalViolationsResolved: 0,
+      startTime: new Date(),
+      lastTaskGeneration: null,
+      lastTaskCompletion: null
+    };
+  }
+  
+  /**
+   * Start the integrated system
+   */
+  async start() {
+    if (this.isRunning) {
+      throw new Error('Task management integration is already running');
+    }
+    
+    console.log('🚀 Starting task management integration...');
+    
+    // Initialize scanner
+    this.scanner = new ContinuousScanner({
+      scanIntervalMs: this.options.scanIntervalMs,
+      maxFileSize: this.options.maxFileSize,
+      watchPaths: this.options.watchPaths,
+      enableFileWatching: true
+    });
+    
+    // Setup event listeners
+    this.setupScannerListeners();
+    
+    // Start scanner
+    await this.scanner.start();
+    
+    // Start batch processing if enabled
+    if (this.options.batchTaskUpdates) {
+      this.startBatchProcessing();
+    }
+    
+    this.isRunning = true;
+    this.emit('started');
+    
+    console.log('✅ Task management integration started');
+    console.log(`   Auto-generate tasks: ${this.options.autoGenerateTasks}`);
+    console.log(`   Real-time updates: ${this.options.enableRealTimeUpdates}`);
+    console.log(`   Batch processing: ${this.options.batchTaskUpdates}`);
+    
+    return { success: true, started: true };
+  }
+  
+  /**
+   * Stop the integrated system
+   */
+  async stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    
+    console.log('🛑 Stopping task management integration...');
+    
+    this.isRunning = false;
+    
+    // Stop scanner
+    if (this.scanner) {
+      this.scanner.stop();
+      this.scanner = null;
+    }
+    
+    // Stop batch processing
+    if (this.taskUpdateTimer) {
+      clearInterval(this.taskUpdateTimer);
+      this.taskUpdateTimer = null;
+    }
+    
+    // Process any remaining pending updates
+    if (this.options.enableRealTimeUpdates && this.pendingTaskUpdates.size > 0) {
+      await this.processPendingUpdates();
+    }
+    
+    this.emit('stopped');
+    
+    console.log('✅ Task management integration stopped');
+  }
+  
+  /**
+   * Setup scanner event listeners
+   */
+  setupScannerListeners() {
+    if (!this.scanner) return;
+    
+    // Handle new violations
+    this.scanner.on('violationDetected', async (event) => {
+      await this.handleViolationDetected(event);
+    });
+    
+    // Handle resolved violations
+    this.scanner.on('violationResolved', async (event) => {
+      await this.handleViolationResolved(event);
+    });
+    
+    // Handle scan completion
+    this.scanner.on('scanCompleted', async (event) => {
+      await this.handleScanCompleted(event);
+    });
+    
+    // Handle scanner errors
+    this.scanner.on('scanError', (error) => {
+      this.emit('error', error);
+    });
+  }
+  
+  /**
+   * Handle violation detected event
+   */
+  async handleViolationDetected(event) {
+    const { filePath, result, eventType } = event;
+    
+    this.stats.totalViolationsDetected++;
+    
+    console.log(`🚨 Violation detected: ${filePath} (${result.lineCount} lines)`);
+    
+    if (this.options.autoGenerateTasks) {
+      if (this.options.enableRealTimeUpdates) {
+        // Real-time task generation
+        await this.generateTaskForViolation(result);
+      } else {
+        // Batch task generation
+        this.pendingTaskUpdates.set(filePath, result);
+      }
+    }
+    
+    this.emit('violationDetected', event);
+  }
+  
+  /**
+   * Handle violation resolved event
+   */
+  async handleViolationResolved(event) {
+    const { filePath, result, previousResult } = event;
+    
+    this.stats.totalViolationsResolved++;
+    
+    console.log(`✅ Violation resolved: ${filePath}`);
+    
+    if (this.options.autoMarkCompleted) {
+      await this.markTaskCompleted(filePath);
+    }
+    
+    this.emit('violationResolved', event);
+  }
+  
+  /**
+   * Handle scan completed event
+   */
+  async handleScanCompleted(event) {
+    const { results, scanTime, stats } = event;
+    const violations = results.filter(r => r.hasViolations);
+    
+    console.log(`🔍 Scan completed: ${violations.length} violations found`);
+    
+    // Process any pending updates if not using real-time
+    if (!this.options.enableRealTimeUpdates && this.pendingTaskUpdates.size > 0) {
+      await this.processPendingUpdates();
+    }
+    
+    this.emit('scanCompleted', event);
+  }
+  
+  /**
+   * Generate task for a single violation
+   */
+  async generateTaskForViolation(violation) {
+    try {
+      const result = await this.taskUpdater.updateTasksWithViolations([violation]);
+      
+      if (result.success && result.tasksAdded > 0) {
+        this.stats.totalTasksGenerated += result.tasksAdded;
+        this.stats.lastTaskGeneration = new Date();
+        
+        console.log(`📝 Generated ${result.tasksAdded} task(s) for ${violation.filePath}`);
+        
+        this.emit('taskGenerated', {
+          filePath: violation.filePath,
+          tasksAdded: result.tasksAdded,
+          totalTasks: result.totalTasks
+        });
+        
+        return result;
+      }
+    } catch (error) {
+      console.error(`❌ Failed to generate task for ${violation.filePath}:`, error.message);
+      this.emit('error', error);
+    }
+    
+    return { success: false, tasksAdded: 0 };
+  }
+  
+  /**
+   * Mark task as completed for a file
+   */
+  async markTaskCompleted(filePath) {
+    try {
+      // Load current tasks to find task for this file
+      const currentTasks = await this.taskUpdater.loadCurrentTasks();
+      const taskForFile = currentTasks.find(task => task.description.includes(filePath));
+      
+      if (taskForFile && !taskForFile.completed) {
+        const result = await this.taskUpdater.markTaskCompleted(taskForFile.id);
+        
+        if (result.success) {
+          this.stats.totalTasksCompleted++;
+          this.stats.lastTaskCompletion = new Date();
+          
+          console.log(`✅ Marked task ${taskForFile.id} as completed for ${filePath}`);
+          
+          this.emit('taskCompleted', {
+            filePath,
+            taskId: taskForFile.id,
+            totalCompleted: this.stats.totalTasksCompleted
+          });
+          
+          return result;
+        }
+      }
+    } catch (error) {
+      console.error(`❌ Failed to mark task completed for ${filePath}:`, error.message);
+      this.emit('error', error);
+    }
+    
+    return { success: false };
+  }
+  
+  /**
+   * Start batch processing
+   */
+  startBatchProcessing() {
+    this.taskUpdateTimer = setInterval(async () => {
+      if (this.pendingTaskUpdates.size > 0) {
+        await this.processPendingUpdates();
+      }
+    }, this.options.taskUpdateDelay);
+  }
+  
+  /**
+   * Process pending task updates
+   */
+  async processPendingUpdates() {
+    if (this.pendingTaskUpdates.size === 0) {
+      return;
+    }
+    
+    console.log(`📋 Processing ${this.pendingTaskUpdates.size} pending task updates...`);
+    
+    const violations = Array.from(this.pendingTaskUpdates.values());
+    this.pendingTaskUpdates.clear();
+    
+    try {
+      // Batch process violations
+      const batchSize = Math.min(violations.length, this.options.maxBatchSize);
+      const batches = [];
+      
+      for (let i = 0; i < violations.length; i += batchSize) {
+        batches.push(violations.slice(i, i + batchSize));
+      }
+      
+      let totalTasksGenerated = 0;
+      
+      for (const batch of batches) {
+        const result = await this.taskUpdater.updateTasksWithViolations(batch);
+        
+        if (result.success) {
+          totalTasksGenerated += result.tasksAdded;
+          
+          if (result.tasksAdded > 0) {
+            console.log(`📝 Generated ${result.tasksAdded} tasks in batch`);
+          }
+        }
+      }
+      
+      if (totalTasksGenerated > 0) {
+        this.stats.totalTasksGenerated += totalTasksGenerated;
+        this.stats.lastTaskGeneration = new Date();
+        
+        this.emit('batchTaskGenerated', {
+          violationsProcessed: violations.length,
+          tasksGenerated: totalTasksGenerated
+        });
+      }
+      
+    } catch (error) {
+      console.error('❌ Failed to process pending updates:', error.message);
+      this.emit('error', error);
+    }
+  }
+  
+  /**
+   * Get integration statistics
+   */
+  getStats() {
+    const uptime = Date.now() - this.stats.startTime.getTime();
+    
+    return {
+      ...this.stats,
+      uptime,
+      isRunning: this.isRunning,
+      pendingUpdates: this.pendingTaskUpdates.size,
+      violationsPerHour: this.stats.totalViolationsDetected / (uptime / 1000 / 60 / 60) || 0,
+      tasksPerHour: this.stats.totalTasksGenerated / (uptime / 1000 / 60 / 60) || 0,
+      completionRate: this.stats.totalViolationsDetected > 0 
+        ? (this.stats.totalViolationsResolved / this.stats.totalViolationsDetected * 100).toFixed(1)
+        : 0
+    };
+  }
+  
+  /**
+   * Get current status
+   */
+  async getStatus() {
+    const stats = this.getStats();
+    const scannerStats = this.scanner ? this.scanner.getStats() : null;
+    const taskStats = await this.taskUpdater.getTaskStatistics();
+    
+    return {
+      integration: {
+        isRunning: this.isRunning,
+        uptime: stats.uptime,
+        autoGenerateTasks: this.options.autoGenerateTasks,
+        realTimeUpdates: this.options.enableRealTimeUpdates,
+        batchProcessing: this.options.batchTaskUpdates
+      },
+      statistics: stats,
+      scanner: scannerStats,
+      tasks: taskStats
+    };
+  }
+  
+  /**
+   * Force task generation for all current violations
+   */
+  async generateTasksForAllViolations() {
+    if (!this.scanner) {
+      throw new Error('Scanner not initialized');
+    }
+    
+    console.log('🔨 Generating tasks for all current violations...');
+    
+    const violations = this.scanner.getViolations();
+    
+    if (violations.length === 0) {
+      console.log('✅ No violations found');
+      return { success: true, tasksGenerated: 0 };
+    }
+    
+    const result = await this.taskUpdater.updateTasksWithViolations(violations);
+    
+    if (result.success) {
+      this.stats.totalTasksGenerated += result.tasksAdded;
+      console.log(`✅ Generated ${result.tasksAdded} tasks for ${violations.length} violations`);
+    }
+    
+    return result;
+  }
+  
+  /**
+   * Mark all resolved violations as completed
+   */
+  async markResolvedViolationsCompleted() {
+    if (!this.scanner) {
+      throw new Error('Scanner not initialized');
+    }
+    
+    console.log('✅ Marking resolved violations as completed...');
+    
+    // Get current violations and tasks
+    const currentViolations = new Set(
+      this.scanner.getViolations().map(v => v.filePath)
+    );
+    
+    const currentTasks = await this.taskUpdater.loadCurrentTasks();
+    const completedTasks = [];
+    
+    for (const task of currentTasks) {
+      if (task.completed) continue;
+      
+      // Extract file path from task description
+      const filePathMatch = task.description.match(/([^\\]+)\(\d+ lines\)/);
+      if (filePathMatch) {
+        const filePath = filePathMatch[1].trim();
+        
+        // If file is not in current violations, mark as completed
+        if (!currentViolations.has(filePath)) {
+          const result = await this.taskUpdater.markTaskCompleted(task.id);
+          if (result.success) {
+            completedTasks.push(task.id);
+            this.stats.totalTasksCompleted++;
+          }
+        }
+      }
+    }
+    
+    console.log(`✅ Marked ${completedTasks.length} tasks as completed`);
+    
+    return {
+      success: true,
+      tasksCompleted: completedTasks.length,
+      taskIds: completedTasks
+    };
+  }
+  
+  /**
+   * Export integration data
+   */
+  exportData() {
+    return {
+      metadata: {
+        exportedAt: new Date().toISOString(),
+        integrationVersion: '1.0.0',
+        options: this.options
+      },
+      statistics: this.getStats(),
+      pendingUpdates: Array.from(this.pendingTaskUpdates.entries()).map(([filePath, violation]) => ({
+        filePath,
+        lineCount: violation.lineCount,
+        detectedAt: violation.scannedAt
+      }))
+    };
+  }
+}
+
+module.exports = TaskManagementIntegration;