vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

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

@@ -0,0 +1,351 @@
+/**
+ * Automated Task Generator
+ * 
+ * Automatically generates refactoring tasks for new file size violations
+ * and integrates them into the task management system.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const TaskManagerIntegration = require('./task-manager-integration');
+const violationTaskGenerator = require('./violation-task-generator');
+const prioritizer = require('./prioritizer');
+
+class AutomatedTaskGenerator {
+  constructor(options = {}) {
+    this.taskManager = new TaskManagerIntegration(options);
+    this.autoGenerate = options.autoGenerate !== false;
+    this.notificationThreshold = options.notificationThreshold || 5;
+    this.taskTemplate = options.taskTemplate || this.getDefaultTaskTemplate();
+  }
+
+  /**
+   * Automatically generate tasks for new violations
+   */
+  async generateTasksForViolations(violations, options = {}) {
+    if (!this.autoGenerate && !options.force) {
+      console.log('Auto-generation disabled. Use --force to override.');
+      return { generated: 0, tasks: [] };
+    }
+
+    try {
+      console.log(`🤖 Auto-generating tasks for ${violations.length} violations...`);
+
+      // Generate tasks for each violation
+      const generatedTasks = [];
+      let taskId = this.getNextTaskId();
+
+      for (const violation of violations) {
+        const task = await this.generateTaskForViolation(violation, taskId);
+        generatedTasks.push(task);
+        taskId++;
+      }
+
+      // Prioritize tasks
+      const prioritizedTasks = this.prioritizeGeneratedTasks(generatedTasks);
+
+      // Integrate with task manager
+      const integrationResult = await this.taskManager.integrateScanResults(
+        { violations }, 
+        { autoGenerate: true, ...options }
+      );
+
+      // Send notifications if threshold exceeded
+      if (violations.length >= this.notificationThreshold) {
+        await this.sendViolationNotification(violations.length, prioritizedTasks);
+      }
+
+      return {
+        generated: generatedTasks.length,
+        tasks: prioritizedTasks,
+        integrationResult,
+        summary: this.generateSummary(violations, prioritizedTasks)
+      };
+
+    } catch (error) {
+      console.error('Automated task generation failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Generate a single task for a violation
+   */
+  async generateTaskForViolation(violation, taskId) {
+    const priority = prioritizer.calculatePriority(violation);
+    const refactoringStrategy = this.determineRefactoringStrategy(violation);
+    const estimatedEffort = this.estimateEffort(violation);
+
+    return {
+      id: `T${String(taskId).padStart(3, '0')}`,
+      priority: priority.level,
+      priorityLabel: priority.label,
+      description: this.generateTaskDescription(violation, refactoringStrategy),
+      filePath: violation.filePath,
+      lineCount: violation.lineCount,
+      violationType: this.categorizeViolation(violation),
+      refactoringStrategy,
+      estimatedEffort,
+      dependencies: this.identifyDependencies(violation),
+      generatedAt: new Date().toISOString(),
+      autoGenerated: true
+    };
+  }
+
+  /**
+   * Generate task description based on violation analysis
+   */
+  generateTaskDescription(violation, strategy) {
+    const action = strategy.suggestedAction;
+    const target = this.extractTargetName(violation.filePath);
+    
+    return `Refactor ${target} - ${action} (${violation.lineCount} lines)`;
+  }
+
+  /**
+   * Determine refactoring strategy for a violation
+   */
+  determineRefactoringStrategy(violation) {
+    const strategies = {
+      'component': {
+        suggestedAction: 'split into component modules',
+        approach: 'component-extraction',
+        difficulty: 'medium'
+      },
+      'utility': {
+        suggestedAction: 'extract utility functions',
+        approach: 'utility-extraction',
+        difficulty: 'low'
+      },
+      'handler': {
+        suggestedAction: 'split into event handlers',
+        approach: 'handler-separation',
+        difficulty: 'medium'
+      },
+      'config': {
+        suggestedAction: 'extract configuration data',
+        approach: 'config-extraction',
+        difficulty: 'low'
+      },
+      'mixed': {
+        suggestedAction: 'refactor into logical modules',
+        approach: 'modular-refactoring',
+        difficulty: 'high'
+      }
+    };
+
+    const category = this.categorizeViolation(violation);
+    return strategies[category] || strategies.mixed;
+  }
+
+  /**
+   * Categorize violation type based on file path and content analysis
+   */
+  categorizeViolation(violation) {
+    const filePath = violation.filePath.toLowerCase();
+    
+    if (filePath.includes('component') || filePath.includes('.jsx') || filePath.includes('.tsx')) {
+      return 'component';
+    }
+    if (filePath.includes('util') || filePath.includes('helper')) {
+      return 'utility';
+    }
+    if (filePath.includes('handler') || filePath.includes('event')) {
+      return 'handler';
+    }
+    if (filePath.includes('config') || filePath.includes('setting')) {
+      return 'config';
+    }
+    
+    return 'mixed';
+  }
+
+  /**
+   * Estimate effort for refactoring
+   */
+  estimateEffort(violation) {
+    const baseEffort = Math.ceil(violation.lineCount / 100); // Base effort per 100 lines
+    const complexityMultiplier = this.getComplexityMultiplier(violation);
+    
+    return {
+      hours: baseEffort * complexityMultiplier,
+      complexity: this.getComplexityLevel(violation),
+      confidence: this.getConfidenceLevel(violation)
+    };
+  }
+
+  /**
+   * Get complexity multiplier based on file characteristics
+   */
+  getComplexityMultiplier(violation) {
+    let multiplier = 1.0;
+    
+    // Increase complexity for very large files
+    if (violation.lineCount > 2000) multiplier += 0.5;
+    if (violation.lineCount > 5000) multiplier += 0.5;
+    
+    // Increase complexity for certain file types
+    if (violation.filePath.includes('integration') || violation.filePath.includes('e2e')) {
+      multiplier += 0.3;
+    }
+    
+    return multiplier;
+  }
+
+  /**
+   * Get complexity level
+   */
+  getComplexityLevel(violation) {
+    if (violation.lineCount > 5000) return 'very-high';
+    if (violation.lineCount > 2000) return 'high';
+    if (violation.lineCount > 1000) return 'medium';
+    return 'low';
+  }
+
+  /**
+   * Get confidence level for automated analysis
+   */
+  getConfidenceLevel(violation) {
+    // Higher confidence for files with clear patterns
+    if (this.hasClearPatterns(violation)) return 'high';
+    if (violation.lineCount < 1000) return 'medium';
+    return 'low';
+  }
+
+  /**
+   * Check if file has clear refactoring patterns
+   */
+  hasClearPatterns(violation) {
+    const patterns = [
+      /export\s+function\s+\w+/g,  // Multiple function exports
+      /class\s+\w+\s*{/g,         // Multiple class definitions
+      /const\s+\w+\s*=\s*\(/g,    // Multiple component definitions
+    ];
+    
+    // This would need actual file content analysis
+    // For now, return true for common patterns
+    return violation.filePath.includes('component') || 
+           violation.filePath.includes('util');
+  }
+
+  /**
+   * Identify dependencies for the task
+   */
+  identifyDependencies(violation) {
+    const dependencies = [];
+    
+    // Core infrastructure dependencies
+    dependencies.push('T001', 'T002', 'T003', 'T004', 'T005'); // Setup tasks
+    
+    // Analysis dependencies
+    dependencies.push('T011', 'T012', 'T013', 'T014'); // Analysis tools
+    
+    // Refactoring tool dependencies
+    dependencies.push('T022', 'T023', 'T024', 'T025'); // Refactoring tools
+    
+    return dependencies;
+  }
+
+  /**
+   * Prioritize generated tasks
+   */
+  prioritizeGeneratedTasks(tasks) {
+    return tasks.sort((a, b) => {
+      // Sort by priority first
+      const priorityOrder = { 'critical': 0, 'high': 1, 'medium': 2, 'low': 3 };
+      const aPriority = priorityOrder[a.priority] || 999;
+      const bPriority = priorityOrder[b.priority] || 999;
+      
+      if (aPriority !== bPriority) {
+        return aPriority - bPriority;
+      }
+      
+      // Then by line count (larger files first)
+      return b.lineCount - a.lineCount;
+    });
+  }
+
+  /**
+   * Get next task ID
+   */
+  getNextTaskId() {
+    // This would scan the current tasks file to find the highest ID
+    // For now, return a default starting point
+    return 99; // Starting after existing tasks
+  }
+
+  /**
+   * Extract target name from file path
+   */
+  extractTargetName(filePath) {
+    const parts = filePath.split('/');
+    const fileName = parts[parts.length - 1];
+    return fileName.replace(/\.(js|jsx|ts|tsx)$/, '');
+  }
+
+  /**
+   * Generate summary of task generation
+   */
+  generateSummary(violations, tasks) {
+    const priorityCounts = tasks.reduce((acc, task) => {
+      acc[task.priority] = (acc[task.priority] || 0) + 1;
+      return acc;
+    }, {});
+
+    return {
+      totalViolations: violations.length,
+      totalTasks: tasks.length,
+      priorityBreakdown: priorityCounts,
+      averageLineCount: violations.reduce((sum, v) => sum + v.lineCount, 0) / violations.length,
+      estimatedTotalHours: tasks.reduce((sum, task) => sum + task.estimatedEffort.hours, 0)
+    };
+  }
+
+  /**
+   * Send notification for high volume of violations
+   */
+  async sendViolationNotification(violationCount, tasks) {
+    const message = `🚨 High volume of violations detected: ${violationCount} files need refactoring\n` +
+                   `Generated ${tasks.length} tasks with priority breakdown:\n` +
+                   `- Critical: ${tasks.filter(t => t.priority === 'critical').length}\n` +
+                   `- High: ${tasks.filter(t => t.priority === 'high').length}\n` +
+                   `- Medium: ${tasks.filter(t => t.priority === 'medium').length}\n` +
+                   `- Low: ${tasks.filter(t => t.priority === 'low').length}`;
+    
+    console.log(message);
+    
+    // Could integrate with email, Slack, or other notification systems
+    if (this.notificationCallback) {
+      await this.notificationCallback(message);
+    }
+  }
+
+  /**
+   * Get default task template
+   */
+  getDefaultTaskTemplate() {
+    return `- [ ] [ID] [P?] [Story?] Description with file path`;
+  }
+
+  /**
+   * Set notification callback
+   */
+  setNotificationCallback(callback) {
+    this.notificationCallback = callback;
+  }
+
+  /**
+   * Get generation statistics
+   */
+  async getGenerationStats() {
+    const status = await this.taskManager.getIntegrationStatus();
+    
+    return {
+      ...status,
+      autoGenerationEnabled: this.autoGenerate,
+      notificationThreshold: this.notificationThreshold
+    };
+  }
+}
+
+module.exports = AutomatedTaskGenerator;

package/src/task-generation/prioritizer.js

@@ -0,0 +1,287 @@
+/**
+ * Violation Prioritizer
+ * 
+ * Prioritizes file violations for refactoring based on multiple factors
+ * including severity, impact, and dependencies.
+ */
+
+const path = require('path');
+
+/**
+ * Violation prioritizer class
+ */
+class ViolationPrioritizer {
+  constructor(options = {}) {
+    this.options = {
+      maxFileSize: options.maxFileSize || 555,
+      priorityWeights: {
+        size: options.priorityWeights?.size || 0.4,        // How much over the limit
+        impact: options.priorityWeights?.impact || 0.3,    // Impact on system
+        complexity: options.priorityWeights?.complexity || 0.2, // Code complexity
+        dependencies: options.priorityWeights?.dependencies || 0.1  // Number of dependents
+      },
+      ...options
+    };
+  }
+
+  /**
+   * Prioritize violations for refactoring
+   */
+  prioritizeViolations(violations) {
+    const prioritized = violations.map(violation => ({
+      ...violation,
+      priority: this.calculatePriority(violation),
+      priorityScore: this.calculatePriorityScore(violation),
+      reasons: this.getPriorityReasons(violation)
+    }));
+
+    // Sort by priority score (highest first)
+    prioritized.sort((a, b) => b.priorityScore - a.priorityScore);
+
+    return {
+      violations: prioritized,
+      summary: this.generatePrioritySummary(prioritized),
+      recommendations: this.generateRecommendations(prioritized)
+    };
+  }
+
+  /**
+   * Calculate priority for a violation
+   */
+  calculatePriority(violation) {
+    const score = this.calculatePriorityScore(violation);
+    
+    if (score >= 80) return 'P1'; // Critical
+    if (score >= 60) return 'P2'; // High
+    if (score >= 40) return 'P3'; // Medium
+    return 'P4'; // Low
+  }
+
+  /**
+   * Calculate priority score (0-100)
+   */
+  calculatePriorityScore(violation) {
+    let score = 0;
+    
+    // Size factor (0-40 points)
+    const sizeFactor = this.calculateSizeFactor(violation);
+    score += sizeFactor * this.options.priorityWeights.size;
+    
+    // Impact factor (0-30 points)
+    const impactFactor = this.calculateImpactFactor(violation);
+    score += impactFactor * this.options.priorityWeights.impact;
+    
+    // Complexity factor (0-20 points)
+    const complexityFactor = this.calculateComplexityFactor(violation);
+    score += complexityFactor * this.options.priorityWeights.complexity;
+    
+    // Dependencies factor (0-10 points)
+    const dependenciesFactor = this.calculateDependenciesFactor(violation);
+    score += dependenciesFactor * this.options.priorityWeights.dependencies;
+    
+    return Math.min(100, Math.round(score));
+  }
+
+  /**
+   * Calculate size factor based on how much the file exceeds the limit
+   */
+  calculateSizeFactor(violation) {
+    if (!violation.lineCount || !violation.limit) return 0;
+    
+    const excess = violation.lineCount - violation.limit;
+    const excessPercentage = (excess / violation.limit) * 100;
+    
+    if (excessPercentage >= 200) return 40;      // 3x+ the limit
+    if (excessPercentage >= 100) return 35;      // 2x the limit
+    if (excessPercentage >= 50) return 30;       // 1.5x the limit
+    if (excessPercentage >= 25) return 25;       // 1.25x the limit
+    if (excessPercentage >= 10) return 20;       // 1.1x the limit
+    if (excessPercentage >= 5) return 15;        // Just over limit
+    return 10;                                   // Slightly over limit
+  }
+
+  /**
+   * Calculate impact factor based on file type and location
+   */
+  calculateImpactFactor(violation) {
+    const filePath = violation.filePath;
+    
+    // Core files have highest impact
+    if (filePath.includes('/packages/core/')) {
+      if (filePath.includes('/src/validation/') || filePath.includes('/src/analysis/')) {
+        return 30; // Core validation/analysis files
+      }
+      if (filePath.includes('/src/rui/') || filePath.includes('/src/commands/')) {
+        return 25; // Core RUI and command files
+      }
+      return 20; // Other core files
+    }
+    
+    // CLI files
+    if (filePath.includes('/packages/cli/')) {
+      if (filePath.includes('/commands/') || filePath.includes('/utils/')) {
+        return 20; // CLI commands and utilities
+      }
+      return 15; // Other CLI files
+    }
+    
+    // Electron app files
+    if (filePath.includes('/packages/electron-app/')) {
+      if (filePath.includes('/src/main/') || filePath.includes('/src/ui/')) {
+        return 18; // Main process and UI files
+      }
+      return 12; // Other Electron files
+    }
+    
+    // Other packages
+    if (filePath.includes('/packages/web/') || filePath.includes('/packages/admin/')) {
+      return 10; // Web and admin packages
+    }
+    
+    return 5; // Other files
+  }
+
+  /**
+   * Calculate complexity factor based on file characteristics
+   */
+  calculateComplexityFactor(violation) {
+    let complexity = 0;
+    
+    // More lines generally means more complexity
+    if (violation.lineCount > 2000) complexity += 20;
+    else if (violation.lineCount > 1500) complexity += 18;
+    else if (violation.lineCount > 1000) complexity += 15;
+    else if (violation.lineCount > 750) complexity += 12;
+    else if (violation.lineCount > 600) complexity += 8;
+    else complexity += 5;
+    
+    // File extension indicates complexity
+    const ext = path.extname(violation.filePath);
+    if (['.js', '.jsx', '.ts', '.tsx'].includes(ext)) {
+      complexity += 5; // JavaScript/TypeScript can be complex
+    }
+    
+    // Directory structure indicates complexity
+    if (violation.filePath.includes('/src/') && violation.filePath.includes('/test/')) {
+      complexity += 3; // Test files
+    }
+    
+    return Math.min(20, complexity);
+  }
+
+  /**
+   * Calculate dependencies factor
+   */
+  calculateDependenciesFactor(violation) {
+    // This is a simplified calculation
+    // In a real implementation, you would analyze import statements
+    
+    let dependencies = 0;
+    
+    // Files in core likely have more dependents
+    if (violation.filePath.includes('/packages/core/')) {
+      dependencies += 8;
+    }
+    
+    // Utility files likely have more dependents
+    if (violation.filePath.includes('/utils/')) {
+      dependencies += 6;
+    }
+    
+    // Main entry points have more dependents
+    if (violation.filePath.includes('index.js') || violation.filePath.includes('app.js')) {
+      dependencies += 10;
+    }
+    
+    return Math.min(10, dependencies);
+  }
+
+  /**
+   * Get reasons for the priority assignment
+   */
+  getPriorityReasons(violation) {
+    const reasons = [];
+    
+    if (violation.lineCount > violation.limit * 2) {
+      reasons.push(`File is ${Math.round((violation.lineCount / violation.limit) * 100)}% over the limit`);
+    }
+    
+    if (violation.filePath.includes('/packages/core/')) {
+      reasons.push('Core package file - high impact');
+    }
+    
+    if (violation.filePath.includes('/validation/') || violation.filePath.includes('/analysis/')) {
+      reasons.push('Critical system component');
+    }
+    
+    if (violation.lineCount > 1000) {
+      reasons.push('Very large file - complex refactoring needed');
+    }
+    
+    return reasons;
+  }
+
+  /**
+   * Generate priority summary
+   */
+  generatePrioritySummary(prioritizedViolations) {
+    const summary = {
+      total: prioritizedViolations.length,
+      byPriority: {
+        P1: 0,
+        P2: 0,
+        P3: 0,
+        P4: 0
+      },
+      averageScore: 0,
+      topViolations: prioritizedViolations.slice(0, 5)
+    };
+    
+    prioritizedViolations.forEach(violation => {
+      summary.byPriority[violation.priority]++;
+    });
+    
+    if (prioritizedViolations.length > 0) {
+      const totalScore = prioritizedViolations.reduce((sum, v) => sum + v.priorityScore, 0);
+      summary.averageScore = Math.round(totalScore / prioritizedViolations.length);
+    }
+    
+    return summary;
+  }
+
+  /**
+   * Generate recommendations based on priorities
+   */
+  generateRecommendations(prioritizedViolations) {
+    const recommendations = [];
+    
+    const p1Count = prioritizedViolations.filter(v => v.priority === 'P1').length;
+    const p2Count = prioritizedViolations.filter(v => v.priority === 'P2').length;
+    
+    if (p1Count > 0) {
+      recommendations.push(`Address ${p1Count} P1 (Critical) violations first - these significantly exceed limits`);
+    }
+    
+    if (p2Count > 0) {
+      recommendations.push(`Focus on ${p2Count} P2 (High) violations next - these impact core functionality`);
+    }
+    
+    // Recommend batch processing
+    if (prioritizedViolations.length > 10) {
+      recommendations.push('Consider processing violations in batches of 5-10 files to manage complexity');
+    }
+    
+    // Recommend parallel processing
+    const independentFiles = prioritizedViolations.filter(v => 
+      !v.filePath.includes('/packages/core/') || v.filePath.includes('/utils/')
+    );
+    
+    if (independentFiles.length > 3) {
+      recommendations.push(`${independentFiles.length} files can be refactored in parallel`);
+    }
+    
+    return recommendations;
+  }
+}
+
+module.exports = ViolationPrioritizer;