vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/task-management/continuous-scan-integration.js

@@ -0,0 +1,342 @@
+/**
+ * Continuous Scan Integration with Task Management
+ * 
+ * Integrates the continuous scanner with the task management system
+ * to automatically create and track refactoring tasks.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { EventEmitter } = require('events');
+
+const { ViolationPrioritizer } = require('../task-generation/prioritizer');
+const { TaskListUpdater } = require('../task-generation/task-list-updater');
+
+/**
+ * Continuous Scan Integration
+ */
+class ContinuousScanIntegration extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      tasksFilePath: options.tasksFilePath || './specs/010-555-max-file-size/tasks.md',
+      autoCreateTasks: options.autoCreateTasks !== false,
+      maxTasksPerScan: options.maxTasksPerScan || 10,
+      taskTemplate: options.taskTemplate || this._getDefaultTaskTemplate(),
+      ...options
+    };
+    
+    this.prioritizer = new ViolationPrioritizer();
+    this.taskUpdater = new TaskListUpdater();
+    this.createdTasks = new Map();
+    this.lastScanResults = null;
+  }
+
+  /**
+   * Initialize integration with scanner
+   */
+  initialize(scanner) {
+    this.scanner = scanner;
+    
+    // Setup event handlers
+    scanner.on('scan_completed', (data) => {
+      this._handleScanCompleted(data);
+    });
+    
+    scanner.on('violations_found', (data) => {
+      this._handleViolationsFound(data);
+    });
+    
+    this.emit('initialized');
+  }
+
+  /**
+   * Handle scan completion
+   */
+  async _handleScanCompleted(data) {
+    this.lastScanResults = data;
+    
+    if (this.options.autoCreateTasks && data.violations.length > 0) {
+      await this._createTasksForViolations(data.violations);
+    }
+    
+    this.emit('scan_processed', {
+      timestamp: data.timestamp,
+      violationsCount: data.violations.length,
+      tasksCreated: this.createdTasks.size
+    });
+  }
+
+  /**
+   * Handle violations found
+   */
+  async _handleViolationsFound(data) {
+    const prioritizedViolations = this.prioritizer.prioritizeViolations(data.violations);
+    const topViolations = prioritizedViolations.slice(0, this.options.maxTasksPerScan);
+    
+    if (topViolations.length > 0) {
+      await this._createTasksForViolations(topViolations);
+    }
+  }
+
+  /**
+   * Create tasks for violations
+   */
+  async _createTasksForViolations(violations) {
+    const tasks = [];
+    
+    for (const violation of violations) {
+      const task = this._createTaskForViolation(violation);
+      if (task) {
+        tasks.push(task);
+        this.createdTasks.set(violation.file, task);
+      }
+    }
+    
+    if (tasks.length > 0) {
+      await this._addTasksToTaskList(tasks);
+      this.emit('tasks_created', { count: tasks.length, tasks });
+    }
+  }
+
+  /**
+   * Create task for a single violation
+   */
+  _createTaskForViolation(violation) {
+    const taskId = this._generateTaskId(violation);
+    const story = this._determineUserStory(violation);
+    const priority = this._determinePriority(violation);
+    
+    // Skip if task already exists
+    if (this._taskExists(taskId)) {
+      return null;
+    }
+    
+    const task = {
+      id: taskId,
+      priority: priority ? '[P]' : '',
+      story: story,
+      description: this._generateTaskDescription(violation),
+      filePath: violation.file,
+      lineCount: this._getLineCount(violation),
+      violationCount: violation.violations.length,
+      violations: violation.violations,
+      createdAt: new Date().toISOString()
+    };
+    
+    return task;
+  }
+
+  /**
+   * Generate task ID
+   */
+  _generateTaskId(violation) {
+    const fileName = path.basename(violation.file, path.extname(violation.file));
+    const sanitized = fileName.replace(/[^a-zA-Z0-9]/g, '-').toLowerCase();
+    return `T${Date.now()}-${sanitized}`;
+  }
+
+  /**
+   * Determine user story
+   */
+  _determineUserStory(violation) {
+    // Based on violation type and file location
+    if (violation.file.includes('/core/')) {
+      return '[US2]'; // User Story 2 - Modular Refactoring
+    } else if (violation.file.includes('/cli/') || violation.file.includes('/electron-app/')) {
+      return '[US2]'; // User Story 2 - Modular Refactoring
+    } else {
+      return '[US2]'; // Default to User Story 2
+    }
+  }
+
+  /**
+   * Determine if task can run in parallel
+   */
+  _determinePriority(violation) {
+    // Tasks can run in parallel if they're in different files
+    return true;
+  }
+
+  /**
+   * Generate task description
+   */
+  _generateTaskDescription(violation) {
+    const lineCount = this._getLineCount(violation);
+    const violationTypes = this._getViolationTypes(violation);
+    
+    let description = `Refactor ${path.basename(violation.file)} (${lineCount} lines)`;
+    
+    if (violationTypes.length > 0) {
+      description += ` - fix ${violationTypes.join(', ')}`;
+    }
+    
+    return description;
+  }
+
+  /**
+   * Get line count from violation
+   */
+  _getLineCount(violation) {
+    if (violation.violations) {
+      const sizeViolation = violation.violations.find(v => v.rule === 'maxFileSize');
+      if (sizeViolation && sizeViolation.line) {
+        return sizeViolation.line;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * Get violation types
+   */
+  _getViolationTypes(violation) {
+    const types = new Set();
+    
+    if (violation.violations) {
+      violation.violations.forEach(v => {
+        switch (v.rule) {
+          case 'maxFileSize':
+            types.add('file size limit');
+            break;
+          case 'noTrailingWhitespace':
+            types.add('trailing whitespace');
+            break;
+          case 'fileEndsWithNewline':
+            types.add('missing newline');
+            break;
+          case 'maxLineLength':
+            types.add('long lines');
+            break;
+          default:
+            types.add(v.rule);
+        }
+      });
+    }
+    
+    return Array.from(types);
+  }
+
+  /**
+   * Check if task already exists
+   */
+  _taskExists(taskId) {
+    try {
+      if (!fs.existsSync(this.options.tasksFilePath)) {
+        return false;
+      }
+      
+      const content = fs.readFileSync(this.options.tasksFilePath, 'utf8');
+      return content.includes(taskId);
+      
+    } catch (error) {
+      console.error('Error checking if task exists:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Add tasks to task list
+   */
+  async _addTasksToTaskList(tasks) {
+    try {
+      await this.taskUpdater.addTasks(this.options.tasksFilePath, tasks);
+    } catch (error) {
+      console.error('Failed to add tasks to task list:', error.message);
+      this.emit('error', error);
+    }
+  }
+
+  /**
+   * Get integration status
+   */
+  getStatus() {
+    return {
+      createdTasks: this.createdTasks.size,
+      lastScanResults: this.lastScanResults,
+      options: this.options
+    };
+  }
+
+  /**
+   * Get created tasks
+   */
+  getCreatedTasks() {
+    return Array.from(this.createdTasks.entries()).map(([file, task]) => ({
+      file,
+      task
+    }));
+  }
+
+  /**
+   * Clear created tasks cache
+   */
+  clearCache() {
+    this.createdTasks.clear();
+    this.lastScanResults = null;
+    this.emit('cache_cleared');
+  }
+
+  /**
+   * Get default task template
+   */
+  _getDefaultTaskTemplate() {
+    return `- [ ] {taskId} {priority} {story} {description}`;
+  }
+
+  /**
+   * Generate integration report
+   */
+  generateReport() {
+    const createdTasks = this.getCreatedTasks();
+    const status = this.getStatus();
+    
+    return {
+      timestamp: new Date().toISOString(),
+      summary: {
+        totalTasksCreated: createdTasks.length,
+        lastScanAt: status.lastScanResults?.timestamp || null,
+        autoCreateTasksEnabled: this.options.autoCreateTasks
+      },
+      tasks: createdTasks,
+      recommendations: this._generateIntegrationRecommendations()
+    };
+  }
+
+  /**
+   * Generate integration recommendations
+   */
+  _generateIntegrationRecommendations() {
+    const recommendations = [];
+    
+    if (this.createdTasks.size === 0) {
+      recommendations.push({
+        type: 'info',
+        title: 'No Tasks Created',
+        description: 'No refactoring tasks have been created yet',
+        action: 'Wait for the next scan or check scanner configuration'
+      });
+    } else {
+      recommendations.push({
+        type: 'action',
+        title: 'Review Created Tasks',
+        description: `${this.createdTasks.size} tasks have been created`,
+        action: 'Review the tasks.md file and prioritize implementation'
+      });
+    }
+    
+    if (!this.options.autoCreateTasks) {
+      recommendations.push({
+        type: 'suggestion',
+        title: 'Enable Auto Task Creation',
+        description: 'Automatic task creation is currently disabled',
+        action: 'Enable autoCreateTasks option to streamline workflow'
+      });
+    }
+    
+    return recommendations;
+  }
+}
+
+module.exports = { ContinuousScanIntegration };

package/src/timeout-management/index.js

@@ -1,6 +1,15 @@
-// timeout-management index
-// Placeholder exports for timeout management utilities (TimeoutCalculator, ResponseTimeTracker)
+/**
+ * Timeout Management Module
+ *
+ * Provides adaptive timeout calculation and management for IDE interactions.
+ */
+
+const { TimeoutCalculator } = require('./timeout-calculator');
+const { TimeoutConfigManager } = require('./timeout-config-manager');
+const { ResponseTimeTracker } = require('./response-time-tracker');
 
 module.exports = {
-  // implementations to be added per spec
+  TimeoutCalculator,
+  TimeoutConfigManager,
+  ResponseTimeTracker
 };

package/src/timeout-management/response-time-tracker.js

@@ -0,0 +1,167 @@
+/**
+ * ResponseTimeTracker
+ *
+ * Maintains response time samples for an IDE and provides statistical analysis
+ * including mean, median, standard deviation, and trend detection.
+ */
+
+const EventEmitter = require('events');
+
+class ResponseTimeTracker extends EventEmitter {
+  /**
+   * Create response time tracker
+   * @param {string} ideId - IDE identifier
+   * @param {Object} [options] - Tracker options
+   * @param {number} [options.maxSamples=50] - Maximum samples to keep
+   */
+  constructor(ideId, options = {}) {
+    super();
+
+    this.ideId = ideId;
+    this.maxSamples = options.maxSamples || 50;
+    this.samples = [];
+  }
+
+  /**
+   * Add response time sample
+   * @param {number} responseTime - Response time in milliseconds
+   */
+  addSample(responseTime) {
+    if (responseTime < 0) {
+      throw new Error('Response time must be non-negative');
+    }
+
+    this.samples.push(responseTime);
+
+    // Maintain max samples limit
+    if (this.samples.length > this.maxSamples) {
+      this.samples.shift(); // Remove oldest
+    }
+
+    this.emit('sample-added', responseTime);
+  }
+
+  /**
+   * Get all samples
+   * @returns {number[]} Copy of samples array
+   */
+  getSamples() {
+    return [...this.samples];
+  }
+
+  /**
+   * Get recent N samples
+   * @param {number} n - Number of recent samples to get
+   * @returns {number[]} Recent samples
+   */
+  getRecentSamples(n) {
+    if (n >= this.samples.length) {
+      return [...this.samples];
+    }
+    return this.samples.slice(-n);
+  }
+
+  /**
+   * Get statistical analysis of samples
+   * @returns {Object} Statistics object
+   */
+  getStatistics() {
+    if (this.samples.length === 0) {
+      return {
+        sampleCount: 0,
+        mean: null,
+        median: null,
+        stdDev: null,
+        min: null,
+        max: null
+      };
+    }
+
+    // Calculate mean
+    const sum = this.samples.reduce((acc, val) => acc + val, 0);
+    const mean = sum / this.samples.length;
+
+    // Calculate median
+    const sorted = [...this.samples].sort((a, b) => a - b);
+    let median;
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+      median = (sorted[mid - 1] + sorted[mid]) / 2;
+    } else {
+      median = sorted[mid];
+    }
+
+    // Calculate standard deviation
+    const variance = this.samples.reduce((acc, val) => {
+      const diff = val - mean;
+      return acc + (diff * diff);
+    }, 0) / this.samples.length;
+    const stdDev = Math.sqrt(variance);
+
+    // Min and max
+    const min = Math.min(...this.samples);
+    const max = Math.max(...this.samples);
+
+    return {
+      sampleCount: this.samples.length,
+      mean,
+      median,
+      stdDev,
+      min,
+      max
+    };
+  }
+
+  /**
+   * Detect trend in response times
+   * @returns {string|null} Trend ('increasing', 'decreasing', 'stable') or null
+   */
+  detectTrend() {
+    // Need at least 5 samples for trend detection
+    if (this.samples.length < 5) {
+      return null;
+    }
+
+    // Use simple linear regression to detect trend
+    const n = this.samples.length;
+    let sumX = 0;
+    let sumY = 0;
+    let sumXY = 0;
+    let sumX2 = 0;
+
+    for (let i = 0; i < n; i++) {
+      const x = i;
+      const y = this.samples[i];
+      sumX += x;
+      sumY += y;
+      sumXY += x * y;
+      sumX2 += x * x;
+    }
+
+    // Calculate slope
+    const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+
+    // Calculate mean for threshold
+    const mean = sumY / n;
+    const threshold = mean * 0.05; // 5% of mean
+
+    // Determine trend based on slope
+    if (slope > threshold) {
+      return 'increasing';
+    } else if (slope < -threshold) {
+      return 'decreasing';
+    } else {
+      return 'stable';
+    }
+  }
+
+  /**
+   * Clear all samples
+   */
+  clear() {
+    this.samples = [];
+    this.emit('samples-cleared');
+  }
+}
+
+module.exports = { ResponseTimeTracker };

package/src/timeout-management/timeout-calculator.js

@@ -0,0 +1,159 @@
+/**
+ * TimeoutCalculator
+ *
+ * Provides static methods for calculating adaptive timeouts based on
+ * historical response times using EWMA (Exponentially Weighted Moving Average).
+ */
+
+class TimeoutCalculator {
+  /**
+   * Calculate timeout value based on EWMA and buffer percentage
+   * @param {Object} options - Calculation options
+   * @param {number|null} options.ewma - Current EWMA value (null for fixed mode)
+   * @param {number} options.defaultTimeout - Default timeout to use when no EWMA
+   * @param {number} options.bufferPercentage - Buffer percentage to add (0-200)
+   * @param {number} [options.minTimeout=30000] - Minimum timeout (30 seconds)
+   * @param {number} [options.maxTimeout=600000] - Maximum timeout (10 minutes)
+   * @returns {number} Calculated timeout in milliseconds
+   */
+  static calculateTimeout(options) {
+    const {
+      ewma,
+      defaultTimeout,
+      bufferPercentage,
+      minTimeout = 30000,
+      maxTimeout = 600000
+    } = options;
+
+    // Use default timeout if no EWMA available or EWMA is zero
+    if (!ewma || ewma === 0) {
+      return defaultTimeout;
+    }
+
+    // Calculate timeout with buffer
+    const buffer = ewma * (bufferPercentage / 100);
+    let timeout = Math.round(ewma + buffer);
+
+    // Enforce bounds
+    timeout = Math.max(minTimeout, timeout);
+    timeout = Math.min(maxTimeout, timeout);
+
+    return timeout;
+  }
+
+  /**
+   * Calculate EWMA from array of samples
+   * @param {number[]} samples - Array of response time samples
+   * @param {number} alpha - EWMA alpha weight (0-1)
+   * @returns {number|null} Calculated EWMA or null if no samples
+   */
+  static calculateEWMA(samples, alpha) {
+    if (!samples || samples.length === 0) {
+      return null;
+    }
+
+    if (samples.length === 1) {
+      return samples[0];
+    }
+
+    // Start with first sample
+    let ewma = samples[0];
+
+    // Apply EWMA formula for remaining samples
+    for (let i = 1; i < samples.length; i++) {
+      ewma = this.updateEWMA(ewma, samples[i], alpha);
+    }
+
+    return ewma;
+  }
+
+  /**
+   * Update EWMA with new sample
+   * @param {number|null} currentEWMA - Current EWMA value
+   * @param {number} newSample - New response time sample
+   * @param {number} alpha - EWMA alpha weight (0-1)
+   * @returns {number} Updated EWMA
+   */
+  static updateEWMA(currentEWMA, newSample, alpha) {
+    // If no current EWMA, use new sample
+    if (currentEWMA === null || currentEWMA === undefined) {
+      return newSample;
+    }
+
+    // EWMA formula: alpha * newSample + (1 - alpha) * currentEWMA
+    return Math.round(alpha * newSample + (1 - alpha) * currentEWMA);
+  }
+
+  /**
+   * Detect if a sample is an outlier
+   * @param {number[]} samples - Historical samples
+   * @param {number} newSample - New sample to check
+   * @param {number} [threshold=2.0] - Standard deviation threshold
+   * @returns {boolean} True if outlier detected
+   */
+  static detectOutlier(samples, newSample, threshold = 2.0) {
+    // Need at least 3 samples for meaningful statistics
+    if (!samples || samples.length < 3) {
+      return false;
+    }
+
+    // Calculate mean
+    const mean = samples.reduce((sum, val) => sum + val, 0) / samples.length;
+
+    // Calculate standard deviation
+    const variance = samples.reduce((sum, val) => {
+      const diff = val - mean;
+      return sum + (diff * diff);
+    }, 0) / samples.length;
+    const stdDev = Math.sqrt(variance);
+
+    // Check if new sample is beyond threshold
+    const deviation = Math.abs(newSample - mean);
+    return deviation > (threshold * stdDev);
+  }
+
+  /**
+   * Recommend buffer percentage based on response time variance
+   * @param {number[]} samples - Historical response time samples
+   * @returns {number} Recommended buffer percentage (20-200)
+   */
+  static recommendBufferPercentage(samples) {
+    // Need at least 3 samples for meaningful statistics
+    if (!samples || samples.length < 3) {
+      return 50; // Default
+    }
+
+    // Calculate coefficient of variation (CV = stdDev / mean)
+    const mean = samples.reduce((sum, val) => sum + val, 0) / samples.length;
+
+    const variance = samples.reduce((sum, val) => {
+      const diff = val - mean;
+      return sum + (diff * diff);
+    }, 0) / samples.length;
+    const stdDev = Math.sqrt(variance);
+
+    const cv = stdDev / mean;
+
+    // Map CV to buffer percentage
+    // Low CV (< 0.2) -> 20-40% buffer
+    // Medium CV (0.2-0.5) -> 40-80% buffer
+    // High CV (> 0.5) -> 80-200% buffer
+    let bufferPercentage;
+
+    if (cv < 0.2) {
+      bufferPercentage = 20 + (cv / 0.2) * 20; // 20-40%
+    } else if (cv < 0.5) {
+      bufferPercentage = 40 + ((cv - 0.2) / 0.3) * 40; // 40-80%
+    } else {
+      bufferPercentage = 80 + Math.min((cv - 0.5) * 120, 120); // 80-200%
+    }
+
+    // Enforce bounds
+    bufferPercentage = Math.max(20, bufferPercentage);
+    bufferPercentage = Math.min(200, bufferPercentage);
+
+    return Math.round(bufferPercentage);
+  }
+}
+
+module.exports = { TimeoutCalculator };