vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

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

@@ -0,0 +1,270 @@
+/**
+ * Task Manager Integration
+ * 
+ * Integrates continuous scanning with the task management system
+ * to automatically update and manage refactoring tasks.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const taskListUpdater = require('./task-list-updater');
+const prioritizer = require('./prioritizer');
+const violationTaskGenerator = require('./violation-task-generator');
+
+class TaskManagerIntegration {
+  constructor(options = {}) {
+    this.tasksFilePath = options.tasksFilePath || path.join(process.cwd(), 'specs/010-555-max-file-size/tasks.md');
+    this.backupEnabled = options.backup !== false;
+    this.autoCommit = options.autoCommit || false;
+  }
+
+  /**
+   * Integrate continuous scan results with task management
+   */
+  async integrateScanResults(scanResults, options = {}) {
+    try {
+      // Create backup before making changes
+      if (this.backupEnabled) {
+        await this.createBackup();
+      }
+
+      // Process violations and update tasks
+      const integrationResult = await this.processViolations(scanResults.violations, options);
+
+      // Update task file if there are changes
+      if (integrationResult.tasksModified) {
+        await this.updateTaskFile(integrationResult.taskUpdates);
+        
+        if (this.autoCommit) {
+          await this.commitChanges(integrationResult.commitMessage);
+        }
+      }
+
+      return integrationResult;
+
+    } catch (error) {
+      console.error('Task manager integration failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Process violations and determine task updates
+   */
+  async processViolations(violations, options = {}) {
+    const taskUpdates = {
+      newTasks: [],
+      updatedTasks: [],
+      completedTasks: []
+    };
+
+    // Read current tasks
+    const currentTasks = await this.readCurrentTasks();
+
+    // Generate tasks for new violations
+    const newViolations = this.filterNewViolations(violations, currentTasks);
+    
+    if (newViolations.length > 0) {
+      const generatedTasks = await violationTaskGenerator.generateTasks(newViolations);
+      taskUpdates.newTasks = generatedTasks;
+    }
+
+    // Mark tasks as completed for files that are now compliant
+    const completedTasks = this.findCompletedTasks(violations, currentTasks);
+    taskUpdates.completedTasks = completedTasks;
+
+    // Update task priorities if needed
+    if (options.reprioritize) {
+      const updatedTasks = await this.reprioritizeTasks(currentTasks, violations);
+      taskUpdates.updatedTasks = updatedTasks;
+    }
+
+    return {
+      tasksModified: taskUpdates.newTasks.length > 0 || 
+                    taskUpdates.completedTasks.length > 0 || 
+                    taskUpdates.updatedTasks.length > 0,
+      taskUpdates,
+      summary: {
+        newTasks: taskUpdates.newTasks.length,
+        completedTasks: taskUpdates.completedTasks.length,
+        updatedTasks: taskUpdates.updatedTasks.length,
+        totalViolations: violations.length
+      }
+    };
+  }
+
+  /**
+   * Filter violations that don't have corresponding tasks
+   */
+  filterNewViolations(violations, currentTasks) {
+    const existingTaskFiles = new Set(
+      currentTasks.map(task => this.extractFilePathFromTask(task))
+    );
+
+    return violations.filter(violation => 
+      !existingTaskFiles.has(violation.filePath)
+    );
+  }
+
+  /**
+   * Find tasks for files that are now compliant
+   */
+  findCompletedTasks(violations, currentTasks) {
+    const violationFiles = new Set(violations.map(v => v.filePath));
+    
+    return currentTasks.filter(task => {
+      const taskFilePath = this.extractFilePathFromTask(task);
+      return taskFilePath && !violationFiles.has(taskFilePath);
+    });
+  }
+
+  /**
+   * Reprioritize tasks based on current violations
+   */
+  async reprioritizeTasks(currentTasks, violations) {
+    const updatedTasks = [];
+    
+    for (const task of currentTasks) {
+      const taskFilePath = this.extractFilePathFromTask(task);
+      const violation = violations.find(v => v.filePath === taskFilePath);
+      
+      if (violation) {
+        const newPriority = prioritizer.calculatePriority(violation);
+        const updatedTask = this.updateTaskPriority(task, newPriority);
+        updatedTasks.push(updatedTask);
+      }
+    }
+    
+    return updatedTasks;
+  }
+
+  /**
+   * Update the task file with changes
+   */
+  async updateTaskFile(taskUpdates) {
+    const content = await fs.readFile(this.tasksFilePath, 'utf8');
+    const lines = content.split('\n');
+    
+    let modifiedContent = content;
+    
+    // Add new tasks
+    if (taskUpdates.newTasks.length > 0) {
+      const insertionPoint = this.findInsertionPoint(lines);
+      const newTaskText = taskUpdates.newTasks.map(task => `- [ ] ${task}`).join('\n');
+      modifiedContent = this.insertTasksAtPoint(modifiedContent, insertionPoint, newTaskText);
+    }
+    
+    // Mark completed tasks
+    for (const completedTask of taskUpdates.completedTasks) {
+      modifiedContent = modifiedContent.replace(
+        `- [ ] ${completedTask}`,
+        `- [x] ${completedTask}`
+      );
+    }
+    
+    // Update task priorities
+    for (const updatedTask of taskUpdates.updatedTasks) {
+      modifiedContent = this.updateTaskInContent(modifiedContent, updatedTask);
+    }
+    
+    await fs.writeFile(this.tasksFilePath, modifiedContent, 'utf8');
+  }
+
+  /**
+   * Read current tasks from the task file
+   */
+  async readCurrentTasks() {
+    const content = await fs.readFile(this.tasksFilePath, 'utf8');
+    const taskRegex = /^- \[([ x])\] (.+)$/gm;
+    const tasks = [];
+    let match;
+    
+    while ((match = taskRegex.exec(content)) !== null) {
+      if (match[1] === ' ') { // Only include uncompleted tasks
+        tasks.push(match[2]);
+      }
+    }
+    
+    return tasks;
+  }
+
+  /**
+   * Extract file path from task description
+   */
+  extractFilePathFromTask(taskDescription) {
+    const pathMatch = taskDescription.match(/packages\/[^)]+/);
+    return pathMatch ? pathMatch[0] : null;
+  }
+
+  /**
+   * Find the appropriate insertion point for new tasks
+   */
+  findInsertionPoint(lines) {
+    // Find the end of User Story 4 section
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (lines[i].includes('T082') && lines[i].includes('[US4]')) {
+        return i + 1;
+      }
+    }
+    return lines.length - 1;
+  }
+
+  /**
+   * Insert new tasks at the specified point
+   */
+  insertTasksAtPoint(content, insertionPoint, newTaskText) {
+    const lines = content.split('\n');
+    lines.splice(insertionPoint, 0, newTaskText);
+    return lines.join('\n');
+  }
+
+  /**
+   * Update task priority in content
+   */
+  updateTaskInContent(content, updatedTask) {
+    // Implementation would depend on the specific task format
+    // This is a placeholder for the actual update logic
+    return content;
+  }
+
+  /**
+   * Create backup of task file
+   */
+  async createBackup() {
+    const backupPath = `${this.tasksFilePath}.backup.${Date.now()}`;
+    await fs.copyFile(this.tasksFilePath, backupPath);
+    console.log(`Backup created: ${backupPath}`);
+  }
+
+  /**
+   * Commit changes to git
+   */
+  async commitChanges(commitMessage) {
+    const { execSync } = require('child_process');
+    try {
+      execSync('git add ' + this.tasksFilePath);
+      execSync(`git commit -m "${commitMessage}"`);
+      console.log('Changes committed to git');
+    } catch (error) {
+      console.warn('Failed to commit changes:', error.message);
+    }
+  }
+
+  /**
+   * Get integration status and statistics
+   */
+  async getIntegrationStatus() {
+    const currentTasks = await this.readCurrentTasks();
+    const completedTasks = currentTasks.filter(task => task.startsWith('[x]')).length;
+    const pendingTasks = currentTasks.length - completedTasks;
+    
+    return {
+      totalTasks: currentTasks.length,
+      completedTasks,
+      pendingTasks,
+      completionRate: (completedTasks / currentTasks.length * 100).toFixed(1)
+    };
+  }
+}
+
+module.exports = TaskManagerIntegration;