vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/task-generation/violation-task-generator.js

@@ -0,0 +1,474 @@
+/**
+ * Violation Task Generator
+ * 
+ * Generates specific refactoring tasks for files that violate the 555-line limit
+ * and other constitutional requirements.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Task generator class
+ */
+class ViolationTaskGenerator {
+  constructor(options = {}) {
+    this.options = {
+      maxFileSize: options.maxFileSize || 555,
+      taskTemplate: options.taskTemplate || this.getDefaultTaskTemplate(),
+      outputFormat: options.outputFormat || 'markdown',
+      ...options
+    };
+  }
+
+  /**
+   * Generate tasks for violations
+   */
+  generateTasks(violations, options = {}) {
+    const tasks = [];
+    const taskOptions = { ...this.options, ...options };
+    
+    for (const violation of violations) {
+      const task = this.generateTaskForViolation(violation, taskOptions);
+      if (task) {
+        tasks.push(task);
+      }
+    }
+    
+    return tasks;
+  }
+
+  /**
+   * Generate task for single violation
+   */
+  generateTaskForViolation(violation, options) {
+    const task = {
+      id: this.generateTaskId(violation.filePath),
+      priority: this.calculatePriority(violation),
+      estimatedEffort: this.estimateEffort(violation),
+      description: this.generateDescription(violation),
+      filePath: violation.filePath,
+      violations: this.extractViolations(violation),
+      recommendations: this.generateRecommendations(violation),
+      dependencies: this.identifyDependencies(violation),
+      generatedAt: new Date().toISOString()
+    };
+    
+    return task;
+  }
+
+  /**
+   * Generate task ID
+   */
+  generateTaskId(filePath) {
+    const relativePath = path.relative(process.cwd(), filePath);
+    const sanitized = relativePath.replace(/[^a-zA-Z0-9]/g, '-').toLowerCase();
+    return `refactor-${sanitized}`;
+  }
+
+  /**
+   * Calculate task priority
+   */
+  calculatePriority(violation) {
+    let score = 0;
+    
+    // Base score from line count
+    if (violation.lineCount > 2000) score += 100;
+    else if (violation.lineCount > 1000) score += 80;
+    else if (violation.lineCount > 800) score += 60;
+    else if (violation.lineCount > 600) score += 40;
+    else if (violation.lineCount > 555) score += 20;
+    
+    // Critical violations increase priority
+    if (violation.constitutionalValidation) {
+      const criticalIssues = violation.constitutionalValidation.filter(r => r.severity === 'critical');
+      score += criticalIssues.length * 30;
+      
+      const errorIssues = violation.constitutionalValidation.filter(r => r.severity === 'error');
+      score += errorIssues.length * 20;
+    }
+    
+    // File type considerations
+    const ext = path.extname(violation.filePath);
+    if (['.js', '.jsx', '.ts', '.tsx'].includes(ext)) {
+      score += 10; // Source code files are higher priority
+    }
+    
+    // Convert score to priority level
+    if (score >= 90) return 'critical';
+    if (score >= 70) return 'high';
+    if (score >= 40) return 'medium';
+    return 'low';
+  }
+
+  /**
+   * Estimate effort in hours
+   */
+  estimateEffort(violation) {
+    let hours = 0;
+    
+    // Base effort from line count
+    const linesToRefactor = violation.lineCount - this.options.maxFileSize;
+    if (linesToRefactor > 0) {
+      hours += Math.ceil(linesToRefactor / 100); // ~100 lines per hour
+    }
+    
+    // Additional effort for constitutional violations
+    if (violation.constitutionalValidation) {
+      const nonWarningIssues = violation.constitutionalValidation.filter(r => r.severity !== 'warning');
+      hours += nonWarningIssues.length * 0.5; // 30 minutes per issue
+    }
+    
+    // Complexity multiplier based on file type
+    const ext = path.extname(violation.filePath);
+    if (['.js', '.jsx', '.ts', '.tsx'].includes(ext)) {
+      hours *= 1.2; // Source code is more complex
+    }
+    
+    return Math.max(1, Math.ceil(hours));
+  }
+
+  /**
+   * Generate task description
+   */
+  generateDescription(violation) {
+    const relativePath = path.relative(process.cwd(), violation.filePath);
+    const lineCount = violation.lineCount;
+    const excessLines = lineCount - this.options.maxFileSize;
+    
+    let description = `Refactor ${relativePath} to comply with 555-line limit`;
+    
+    if (excessLines > 0) {
+      description += ` (currently ${lineCount} lines, ${excessLines} over limit)`;
+    }
+    
+    if (violation.constitutionalValidation && violation.constitutionalValidation.length > 0) {
+      const issueCount = violation.constitutionalValidation.filter(r => r.severity !== 'warning').length;
+      description += ` and resolve ${issueCount} constitutional violations`;
+    }
+    
+    return description;
+  }
+
+  /**
+   * Extract violations from scan result
+   */
+  extractViolations(violation) {
+    const violations = [];
+    
+    // Line limit violation
+    if (violation.lineLimitValidation && !violation.lineLimitValidation.isValid) {
+      violations.push({
+        type: 'file_size',
+        severity: violation.lineLimitValidation.violation?.severity || 'error',
+        description: violation.lineLimitValidation.violation?.message || 'File exceeds size limit',
+        details: {
+          lineCount: violation.lineCount,
+          limit: this.options.maxFileSize,
+          excessLines: violation.lineCount - this.options.maxFileSize
+        }
+      });
+    }
+    
+    // Constitutional violations
+    if (violation.constitutionalValidation) {
+      for (const issue of violation.constitutionalValidation) {
+        if (issue.severity !== 'warning') {
+          violations.push({
+            type: issue.category,
+            severity: issue.severity,
+            description: issue.message,
+            details: {
+              rule: issue.rule,
+              lineNumber: issue.lineNumber,
+              suggestion: issue.suggestion
+            }
+          });
+        }
+      }
+    }
+    
+    return violations;
+  }
+
+  /**
+   * Generate recommendations
+   */
+  generateRecommendations(violation) {
+    const recommendations = [];
+    
+    // File size recommendations
+    if (violation.lineCount > this.options.maxFileSize) {
+      const excessLines = violation.lineCount - this.options.maxFileSize;
+      
+      if (excessLines > 1000) {
+        recommendations.push({
+          action: 'split_into_multiple_files',
+          description: `Split into ${Math.ceil(excessLines / 500) + 1} focused modules`,
+          priority: 'high'
+        });
+      } else if (excessLines > 500) {
+        recommendations.push({
+          action: 'extract_large_functions',
+          description: 'Extract large functions and classes into separate modules',
+          priority: 'medium'
+        });
+      } else {
+        recommendations.push({
+          action: 'minor_refactoring',
+          description: 'Minor refactoring to reduce file size',
+          priority: 'low'
+        });
+      }
+      
+      // General refactoring recommendations
+      recommendations.push({
+        action: 'extract_related_functionality',
+        description: 'Group related functionality into logical modules',
+        priority: 'medium'
+      });
+      
+      recommendations.push({
+        action: 'remove_duplicate_code',
+        description: 'Identify and remove duplicate code patterns',
+        priority: 'medium'
+      });
+    }
+    
+    // Constitutional recommendations
+    if (violation.constitutionalValidation) {
+      for (const issue of violation.constitutionalValidation) {
+        if (issue.suggestion && issue.severity !== 'warning') {
+          recommendations.push({
+            action: 'fix_constitutional_issue',
+            description: issue.suggestion,
+            priority: issue.severity === 'critical' ? 'high' : 'medium',
+            category: issue.category
+          });
+        }
+      }
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Identify dependencies
+   */
+  identifyDependencies(violation) {
+    const dependencies = [];
+    
+    try {
+      const content = fs.readFileSync(violation.filePath, 'utf8');
+      
+      // Find import statements
+      const importRegex = /(?:import|require)\s+['"]([^'"]+)['"]/g;
+      const imports = [];
+      let match;
+      
+      while ((match = importRegex.exec(content)) !== null) {
+        const importPath = match[1];
+        
+        // Only include local imports
+        if (importPath.startsWith('./') || importPath.startsWith('../')) {
+          const absolutePath = path.resolve(path.dirname(violation.filePath), importPath);
+          
+          // Try different extensions
+          const possiblePaths = [
+            absolutePath,
+            absolutePath + '.js',
+            absolutePath + '.jsx',
+            absolutePath + '.ts',
+            absolutePath + '.tsx',
+            path.join(absolutePath, 'index.js'),
+            path.join(absolutePath, 'index.jsx'),
+            path.join(absolutePath, 'index.ts'),
+            path.join(absolutePath, 'index.tsx')
+          ];
+          
+          for (const possiblePath of possiblePaths) {
+            if (fs.existsSync(possiblePath)) {
+              imports.push(possiblePath);
+              break;
+            }
+          }
+        }
+      }
+      
+      dependencies.push(...imports);
+    } catch (error) {
+      // Skip dependency analysis if file can't be read
+    }
+    
+    return dependencies;
+  }
+
+  /**
+   * Generate tasks in markdown format
+   */
+  generateMarkdownTasks(tasks) {
+    let markdown = '# Generated Refactoring Tasks\n\n';
+    markdown += `Generated on: ${new Date().toISOString()}\n`;
+    markdown += `Total tasks: ${tasks.length}\n\n`;
+    
+    // Group by priority
+    const grouped = this.groupTasksByPriority(tasks);
+    
+    for (const [priority, priorityTasks] of Object.entries(grouped)) {
+      markdown += `## ${priority.toUpperCase()} Priority Tasks\n\n`;
+      
+      for (const task of priorityTasks) {
+        markdown += `### ${task.id}\n\n`;
+        markdown += `- [ ] **${task.description}**\n`;
+        markdown += `  - **File:** \`${task.filePath}\`\n`;
+        markdown += `  - **Lines:** ${task.lineCount || 'unknown'}\n`;
+        markdown += `  - **Priority:** ${task.priority}\n`;
+        markdown += `  - **Estimated Effort:** ${task.estimatedEffort} hours\n`;
+        
+        if (task.violations && task.violations.length > 0) {
+          markdown += `  - **Violations:**\n`;
+          for (const violation of task.violations) {
+            markdown += `    - ${violation.type}: ${violation.description}\n`;
+          }
+        }
+        
+        if (task.recommendations && task.recommendations.length > 0) {
+          markdown += `  - **Recommendations:**\n`;
+          for (const rec of task.recommendations) {
+            markdown += `    - ${rec.action}: ${rec.description}\n`;
+          }
+        }
+        
+        if (task.dependencies && task.dependencies.length > 0) {
+          markdown += `  - **Dependencies:** ${task.dependencies.length} files\n`;
+        }
+        
+        markdown += '\n';
+      }
+    }
+    
+    return markdown;
+  }
+
+  /**
+   * Group tasks by priority
+   */
+  groupTasksByPriority(tasks) {
+    const grouped = {
+      critical: [],
+      high: [],
+      medium: [],
+      low: []
+    };
+    
+    for (const task of tasks) {
+      grouped[task.priority].push(task);
+    }
+    
+    // Sort within each priority by effort (highest first)
+    for (const priority in grouped) {
+      grouped[priority].sort((a, b) => b.estimatedEffort - a.estimatedEffort);
+    }
+    
+    return grouped;
+  }
+
+  /**
+   * Get default task template
+   */
+  getDefaultTaskTemplate() {
+    return {
+      id: '',
+      priority: 'medium',
+      estimatedEffort: 4,
+      description: '',
+      filePath: '',
+      violations: [],
+      recommendations: [],
+      dependencies: [],
+      generatedAt: ''
+    };
+  }
+
+  /**
+   * Export tasks to file
+   */
+  async exportTasks(tasks, filePath, format = 'markdown') {
+    let content;
+    
+    switch (format.toLowerCase()) {
+      case 'markdown':
+        content = this.generateMarkdownTasks(tasks);
+        break;
+      case 'json':
+        content = JSON.stringify({
+          metadata: {
+            exportedAt: new Date().toISOString(),
+            totalTasks: tasks.length,
+            generatorVersion: '1.0.0'
+          },
+          tasks
+        }, null, 2);
+        break;
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+    
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    fs.writeFileSync(filePath, content, 'utf8');
+    return filePath;
+  }
+
+  /**
+   * Generate summary statistics
+   */
+  generateSummary(tasks) {
+    const summary = {
+      totalTasks: tasks.length,
+      totalEstimatedHours: tasks.reduce((sum, task) => sum + task.estimatedEffort, 0),
+      priorityBreakdown: {},
+      violationTypes: {},
+      averageEffort: 0,
+      largestFile: null,
+      mostComplexTask: null
+    };
+    
+    // Priority breakdown
+    for (const task of tasks) {
+      summary.priorityBreakdown[task.priority] = (summary.priorityBreakdown[task.priority] || 0) + 1;
+    }
+    
+    // Violation types
+    for (const task of tasks) {
+      for (const violation of task.violations) {
+        summary.violationTypes[violation.type] = (summary.violationTypes[violation.type] || 0) + 1;
+      }
+    }
+    
+    // Average effort
+    if (tasks.length > 0) {
+      summary.averageEffort = summary.totalEstimatedHours / tasks.length;
+    }
+    
+    // Find largest file
+    const taskWithLargestFile = tasks.reduce((max, task) => {
+      return (!max || (task.lineCount || 0) > (max.lineCount || 0)) ? task : max;
+    }, null);
+    summary.largestFile = taskWithLargestFile;
+    
+    // Find most complex task (most violations)
+    const mostComplexTask = tasks.reduce((max, task) => {
+      return (!max || task.violations.length > max.violations.length) ? task : max;
+    }, null);
+    summary.mostComplexTask = mostComplexTask;
+    
+    return summary;
+  }
+}
+
+module.exports = ViolationTaskGenerator;