vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/timeout-management/timeout-config-manager.js

@@ -0,0 +1,172 @@
+/**
+ * TimeoutConfigManager
+ *
+ * Manages timeout configuration including mode (fixed/adaptive),
+ * default timeout values, buffer percentages, and EWMA alpha values.
+ */
+
+const EventEmitter = require('events');
+
+class TimeoutConfigManager extends EventEmitter {
+  /**
+   * Create timeout config manager
+   * @param {Object} [initialConfig] - Initial configuration
+   */
+  constructor(initialConfig = {}) {
+    super();
+
+    this.config = {
+      mode: initialConfig.mode || 'fixed',
+      defaultTimeout: initialConfig.defaultTimeout || 300000, // 5 minutes
+      bufferPercentage: initialConfig.bufferPercentage || 50,
+      ewmaAlpha: initialConfig.ewmaAlpha || 0.3,
+      minTimeout: initialConfig.minTimeout || 30000, // 30 seconds
+      maxTimeout: initialConfig.maxTimeout || 600000 // 10 minutes
+    };
+  }
+
+  /**
+   * Set timeout mode
+   * @param {string} mode - Mode ('fixed' or 'adaptive')
+   */
+  setMode(mode) {
+    if (mode !== 'fixed' && mode !== 'adaptive') {
+      throw new Error(`Invalid mode: ${mode}. Must be 'fixed' or 'adaptive'`);
+    }
+
+    this.config.mode = mode;
+    this.emit('mode-changed', mode);
+    this.emit('config-changed', this.getConfig());
+  }
+
+  /**
+   * Get current mode
+   * @returns {string} Current mode
+   */
+  getMode() {
+    return this.config.mode;
+  }
+
+  /**
+   * Check if adaptive mode is enabled
+   * @returns {boolean} True if adaptive mode
+   */
+  isAdaptiveMode() {
+    return this.config.mode === 'adaptive';
+  }
+
+  /**
+   * Set default timeout
+   * @param {number} timeout - Default timeout in milliseconds
+   */
+  setDefaultTimeout(timeout) {
+    if (timeout <= 0) {
+      throw new Error('Default timeout must be greater than 0');
+    }
+
+    this.config.defaultTimeout = timeout;
+    this.emit('config-changed', this.getConfig());
+  }
+
+  /**
+   * Get default timeout
+   * @returns {number} Default timeout in milliseconds
+   */
+  getDefaultTimeout() {
+    return this.config.defaultTimeout;
+  }
+
+  /**
+   * Set buffer percentage
+   * @param {number} percentage - Buffer percentage (0-200)
+   */
+  setBufferPercentage(percentage) {
+    if (percentage < 0 || percentage > 200) {
+      throw new Error('Buffer percentage must be between 0 and 200');
+    }
+
+    this.config.bufferPercentage = percentage;
+    this.emit('config-changed', this.getConfig());
+  }
+
+  /**
+   * Get buffer percentage
+   * @returns {number} Buffer percentage
+   */
+  getBufferPercentage() {
+    return this.config.bufferPercentage;
+  }
+
+  /**
+   * Set EWMA alpha value
+   * @param {number} alpha - Alpha value (0-1)
+   */
+  setEWMAAlpha(alpha) {
+    if (alpha < 0 || alpha > 1) {
+      throw new Error('EWMA alpha must be between 0 and 1');
+    }
+
+    this.config.ewmaAlpha = alpha;
+    this.emit('config-changed', this.getConfig());
+  }
+
+  /**
+   * Get EWMA alpha value
+   * @returns {number} Alpha value
+   */
+  getEWMAAlpha() {
+    return this.config.ewmaAlpha;
+  }
+
+  /**
+   * Set minimum timeout
+   * @param {number} timeout - Minimum timeout in milliseconds
+   */
+  setMinTimeout(timeout) {
+    if (timeout < 0) {
+      throw new Error('Minimum timeout must be non-negative');
+    }
+
+    this.config.minTimeout = timeout;
+    this.emit('config-changed', this.getConfig());
+  }
+
+  /**
+   * Set maximum timeout
+   * @param {number} timeout - Maximum timeout in milliseconds
+   */
+  setMaxTimeout(timeout) {
+    if (timeout < this.config.minTimeout) {
+      throw new Error('Maximum timeout must be greater than minimum timeout');
+    }
+
+    this.config.maxTimeout = timeout;
+    this.emit('config-changed', this.getConfig());
+  }
+
+  /**
+   * Get complete configuration
+   * @returns {Object} Configuration object
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+
+  /**
+   * Reset to default configuration
+   */
+  reset() {
+    this.config = {
+      mode: 'fixed',
+      defaultTimeout: 300000,
+      bufferPercentage: 50,
+      ewmaAlpha: 0.3,
+      minTimeout: 30000,
+      maxTimeout: 600000
+    };
+
+    this.emit('config-changed', this.getConfig());
+  }
+}
+
+module.exports = { TimeoutConfigManager };

package/src/utils/ast-analyzer.js

@@ -0,0 +1,417 @@
+/**
+ * AST-Based Code Structure Analyzer
+ * Analyzes code structure to identify logical module boundaries
+ * Part of specs/010-555-max-file-size implementation (Task 102)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Analyze file structure to identify logical boundaries
+ * Uses simple heuristics without heavy AST parsing dependencies
+ * @param {string} filePath - Path to file to analyze
+ * @returns {Object} Analysis results with suggested module boundaries
+ */
+function analyzeFileStructure(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    const analysis = {
+      filePath,
+      totalLines: lines.length,
+      functions: [],
+      classes: [],
+      exports: [],
+      imports: [],
+      comments: [],
+      sections: [],
+      suggestedModules: []
+    };
+
+    // Track current section
+    let currentSection = null;
+    let sectionStart = 0;
+
+    // Analyze line by line
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Detect section headers (comments with separators)
+      if (isSectionHeader(trimmed)) {
+        if (currentSection) {
+          currentSection.endLine = i - 1;
+          currentSection.lineCount = currentSection.endLine - currentSection.startLine + 1;
+          analysis.sections.push(currentSection);
+        }
+
+        currentSection = {
+          title: extractSectionTitle(trimmed),
+          startLine: i,
+          endLine: null,
+          lineCount: 0
+        };
+        sectionStart = i;
+      }
+
+      // Detect function declarations
+      if (isFunctionDeclaration(trimmed)) {
+        const funcInfo = extractFunctionInfo(trimmed, i);
+        if (funcInfo) {
+          analysis.functions.push(funcInfo);
+        }
+      }
+
+      // Detect class declarations
+      if (isClassDeclaration(trimmed)) {
+        const classInfo = extractClassInfo(trimmed, i);
+        if (classInfo) {
+          analysis.classes.push(classInfo);
+        }
+      }
+
+      // Detect exports
+      if (isExport(trimmed)) {
+        analysis.exports.push({
+          line: i + 1,
+          text: trimmed
+        });
+      }
+
+      // Detect imports
+      if (isImport(trimmed)) {
+        analysis.imports.push({
+          line: i + 1,
+          text: trimmed
+        });
+      }
+
+      // Detect comments
+      if (isComment(trimmed)) {
+        analysis.comments.push({
+          line: i + 1,
+          text: trimmed
+        });
+      }
+    }
+
+    // Close last section
+    if (currentSection) {
+      currentSection.endLine = lines.length - 1;
+      currentSection.lineCount = currentSection.endLine - currentSection.startLine + 1;
+      analysis.sections.push(currentSection);
+    }
+
+    // Generate module suggestions based on analysis
+    analysis.suggestedModules = generateModuleSuggestions(analysis);
+
+    return analysis;
+  } catch (error) {
+    return {
+      filePath,
+      error: error.message,
+      suggestedModules: []
+    };
+  }
+}
+
+/**
+ * Check if line is a section header comment
+ * @param {string} line - Trimmed line
+ * @returns {boolean}
+ */
+function isSectionHeader(line) {
+  // Look for comment lines with separators like:
+  // // ========= Section Name =========
+  // /* -------- Section Name -------- */
+  // // ─────────────────────────────────
+  return (
+    (line.startsWith('//') || line.startsWith('/*')) &&
+    (line.includes('===') || line.includes('---') || line.includes('━━') || line.includes('──'))
+  );
+}
+
+/**
+ * Extract section title from header comment
+ * @param {string} line - Section header line
+ * @returns {string}
+ */
+function extractSectionTitle(line) {
+  // Remove comment markers and separators
+  let title = line
+    .replace(/^\/\/\s*/, '')
+    .replace(/^\/\*\s*/, '')
+    .replace(/\*\/\s*$/, '')
+    .replace(/[=\-━─]+/g, '')
+    .trim();
+
+  return title || 'Unnamed Section';
+}
+
+/**
+ * Check if line is a function declaration
+ * @param {string} line - Trimmed line
+ * @returns {boolean}
+ */
+function isFunctionDeclaration(line) {
+  return (
+    line.startsWith('function ') ||
+    line.startsWith('async function ') ||
+    line.includes(' function ') ||
+    /^(const|let|var)\s+\w+\s*=\s*(async\s+)?(\([^)]*\)|[a-zA-Z_$][\w$]*)\s*=>/.test(line) ||
+    /^(async\s+)?[\w$]+\s*\([^)]*\)\s*{/.test(line)
+  );
+}
+
+/**
+ * Extract function information
+ * @param {string} line - Function declaration line
+ * @param {number} lineNum - Line number
+ * @returns {Object|null}
+ */
+function extractFunctionInfo(line, lineNum) {
+  let name = 'anonymous';
+  let isAsync = line.includes('async');
+  let isExported = line.includes('export');
+
+  // Try to extract function name
+  const funcMatch = line.match(/function\s+([a-zA-Z_$][\w$]*)/);
+  const arrowMatch = line.match(/(const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=/);
+  const methodMatch = line.match(/^(async\s+)?([\w$]+)\s*\(/);
+
+  if (funcMatch) {
+    name = funcMatch[1];
+  } else if (arrowMatch) {
+    name = arrowMatch[2];
+  } else if (methodMatch) {
+    name = methodMatch[2];
+  }
+
+  return {
+    name,
+    line: lineNum + 1,
+    isAsync,
+    isExported
+  };
+}
+
+/**
+ * Check if line is a class declaration
+ * @param {string} line - Trimmed line
+ * @returns {boolean}
+ */
+function isClassDeclaration(line) {
+  return line.startsWith('class ') || line.includes(' class ');
+}
+
+/**
+ * Extract class information
+ * @param {string} line - Class declaration line
+ * @param {number} lineNum - Line number
+ * @returns {Object|null}
+ */
+function extractClassInfo(line, lineNum) {
+  const match = line.match(/class\s+([a-zA-Z_$][\w$]*)/);
+  if (match) {
+    return {
+      name: match[1],
+      line: lineNum + 1,
+      isExported: line.includes('export')
+    };
+  }
+  return null;
+}
+
+/**
+ * Check if line is an export statement
+ * @param {string} line - Trimmed line
+ * @returns {boolean}
+ */
+function isExport(line) {
+  return line.startsWith('export ') || line.startsWith('module.exports');
+}
+
+/**
+ * Check if line is an import statement
+ * @param {string} line - Trimmed line
+ * @returns {boolean}
+ */
+function isImport(line) {
+  return line.startsWith('import ') || line.startsWith('const ') && line.includes('require(') ||
+         line.startsWith('require(');
+}
+
+/**
+ * Check if line is a comment
+ * @param {string} line - Trimmed line
+ * @returns {boolean}
+ */
+function isComment(line) {
+  return line.startsWith('//') || line.startsWith('/*') || line.startsWith('*');
+}
+
+/**
+ * Generate module suggestions based on file analysis
+ * @param {Object} analysis - File analysis results
+ * @returns {Array} Array of module suggestions
+ */
+function generateModuleSuggestions(analysis) {
+  const suggestions = [];
+
+  // If file has clear sections, suggest splitting by section
+  if (analysis.sections.length > 1) {
+    analysis.sections.forEach((section, idx) => {
+      if (section.lineCount > 100) { // Only suggest if section is substantial
+        suggestions.push({
+          type: 'section-based',
+          moduleName: sanitizeModuleName(section.title),
+          startLine: section.startLine,
+          endLine: section.endLine,
+          estimatedLines: section.lineCount,
+          description: `Extract "${section.title}" section into separate module`
+        });
+      }
+    });
+  }
+
+  // If file has many functions, suggest grouping related functions
+  if (analysis.functions.length > 10) {
+    const functionGroups = groupFunctionsByPrefix(analysis.functions);
+    Object.entries(functionGroups).forEach(([prefix, funcs]) => {
+      if (funcs.length >= 3) {
+        suggestions.push({
+          type: 'function-group',
+          moduleName: `${prefix}-functions`,
+          functions: funcs.map(f => f.name),
+          description: `Group ${funcs.length} related functions with prefix "${prefix}"`
+        });
+      }
+    });
+  }
+
+  // If file has classes, suggest one class per module
+  if (analysis.classes.length > 1) {
+    analysis.classes.forEach(cls => {
+      suggestions.push({
+        type: 'class-based',
+        moduleName: cls.name,
+        className: cls.name,
+        description: `Extract ${cls.name} class into separate module`
+      });
+    });
+  }
+
+  return suggestions;
+}
+
+/**
+ * Group functions by common prefix
+ * @param {Array} functions - Array of function objects
+ * @returns {Object} Grouped functions by prefix
+ */
+function groupFunctionsByPrefix(functions) {
+  const groups = {};
+
+  functions.forEach(func => {
+    const name = func.name;
+    // Extract prefix (e.g., "handle" from "handleClick", "get" from "getUserData")
+    const prefixMatch = name.match(/^(get|set|handle|is|has|create|update|delete|fetch|send|load|save|parse|format|validate|check)/i);
+
+    if (prefixMatch) {
+      const prefix = prefixMatch[1].toLowerCase();
+      if (!groups[prefix]) {
+        groups[prefix] = [];
+      }
+      groups[prefix].push(func);
+    }
+  });
+
+  return groups;
+}
+
+/**
+ * Sanitize section title to valid module name
+ * @param {string} title - Section title
+ * @returns {string} Sanitized module name
+ */
+function sanitizeModuleName(title) {
+  return title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Generate refactoring plan for a file
+ * @param {string} filePath - Path to file
+ * @param {number} targetLinesPerModule - Target lines per module (default 400)
+ * @returns {Object} Refactoring plan
+ */
+function generateRefactoringPlan(filePath, targetLinesPerModule = 400) {
+  const analysis = analyzeFileStructure(filePath);
+
+  if (analysis.error) {
+    return { success: false, error: analysis.error };
+  }
+
+  const plan = {
+    sourceFile: filePath,
+    totalLines: analysis.totalLines,
+    targetLinesPerModule,
+    estimatedModuleCount: Math.ceil(analysis.totalLines / targetLinesPerModule),
+    suggestedModules: analysis.suggestedModules,
+    strategy: determineRefactoringStrategy(analysis),
+    complexity: assessRefactoringComplexity(analysis)
+  };
+
+  return plan;
+}
+
+/**
+ * Determine best refactoring strategy
+ * @param {Object} analysis - File analysis
+ * @returns {string} Strategy description
+ */
+function determineRefactoringStrategy(analysis) {
+  if (analysis.sections.length > 1) {
+    return 'section-based: File has clear sections that can be extracted';
+  } else if (analysis.classes.length > 0) {
+    return 'class-based: Extract classes into separate modules';
+  } else if (analysis.functions.length > 10) {
+    return 'function-based: Group related functions into modules';
+  } else {
+    return 'manual: Requires manual analysis and refactoring';
+  }
+}
+
+/**
+ * Assess refactoring complexity
+ * @param {Object} analysis - File analysis
+ * @returns {string} Complexity level
+ */
+function assessRefactoringComplexity(analysis) {
+  const exportCount = analysis.exports.length;
+  const importCount = analysis.imports.length;
+  const functionCount = analysis.functions.length;
+
+  if (exportCount > 20 || functionCount > 50) {
+    return 'HIGH';
+  } else if (exportCount > 10 || functionCount > 20) {
+    return 'MEDIUM';
+  } else {
+    return 'LOW';
+  }
+}
+
+module.exports = {
+  analyzeFileStructure,
+  generateRefactoringPlan,
+  isSectionHeader,
+  isFunctionDeclaration,
+  isClassDeclaration,
+  isExport,
+  isImport,
+  isComment
+};