vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/analysis/analysis-engine.js

@@ -0,0 +1,314 @@
+/**
+ * Boundary Detection - Analysis Engine
+ * 
+ * Analysis and recommendation engine for boundary detection.
+ */
+
+const { BOUNDARY_TYPES } = require('./boundary-types');
+
+/**
+ * Assess file complexity
+ * @param {Object} result - Detection result
+ * @returns {string} - Complexity level
+ */
+function assessComplexity(result) {
+  const boundaries = result.boundaries;
+  let totalComplexity = 0;
+  
+  for (const boundary of boundaries) {
+    totalComplexity += boundary.complexity || 0;
+  }
+  
+  const averageComplexity = totalComplexity / boundaries.length;
+  
+  if (averageComplexity > 10) return 'high';
+  if (averageComplexity > 5) return 'medium';
+  return 'low';
+}
+
+/**
+ * Assess file cohesion
+ * @param {Object} result - Detection result
+ * @returns {string} - Cohesion level
+ */
+function assessCohesion(result) {
+  const functions = result.getBoundariesByType(BOUNDARY_TYPES.FUNCTION);
+  const classes = result.getBoundariesByType(BOUNDARY_TYPES.CLASS);
+  
+  // Simple cohesion assessment based on related functionality
+  const totalBoundaries = functions.length + classes.length;
+  const relatedBoundaries = boundaries.filter(b => 
+    b.dependencies.length > 0 || b.exports.length > 0
+  ).length;
+  
+  const cohesionRatio = relatedBoundaries / totalBoundaries;
+  
+  if (cohesionRatio > 0.8) return 'high';
+  if (cohesionRatio > 0.5) return 'medium';
+  return 'low';
+}
+
+/**
+ * Assess file coupling
+ * @param {Object} result - Detection result
+ * @returns {string} - Coupling level
+ */
+function assessCoupling(result) {
+  // Simple coupling assessment based on imports
+  const imports = result.getBoundariesByType(BOUNDARY_TYPES.IMPORT);
+  
+  if (imports.length > 10) return 'high';
+  if (imports.length > 5) return 'medium';
+  return 'low';
+}
+
+/**
+ * Get refactoring recommendations
+ * @param {Object} result - Detection result
+ * @returns {Array} - Recommendations
+ */
+function getRefactoringRecommendations(result) {
+  const recommendations = [];
+  
+  // Large functions
+  const largeFunctions = result.getBoundariesByType(BOUNDARY_TYPES.FUNCTION)
+    .filter(f => f.lineCount > 50);
+  
+  if (largeFunctions.length > 0) {
+    recommendations.push({
+      type: 'extract_functions',
+      priority: 'high',
+      description: `${largeFunctions.length} functions are too large and should be split`,
+      boundaries: largeFunctions.map(f => ({ name: f.name, lineCount: f.lineCount }))
+    });
+  }
+  
+  // Large classes
+  const largeClasses = result.getBoundariesByType(BOUNDARY_TYPES.CLASS)
+    .filter(c => c.lineCount > 200);
+  
+  if (largeClasses.length > 0) {
+    recommendations.push({
+      type: 'split_classes',
+      priority: 'medium',
+      description: `${largeClasses.length} classes are too large and should be split`,
+      boundaries: largeClasses.map(c => ({ name: c.name, lineCount: c.lineCount }))
+    });
+  }
+  
+  // Utility extraction
+  const utilities = result.getBoundariesByType(BOUNDARY_TYPES.UTILITY);
+  if (utilities.length === 0 && result.metadata.totalBoundaries > 5) {
+    recommendations.push({
+      type: 'extract_utilities',
+      priority: 'low',
+      description: 'Consider extracting utility functions to separate modules',
+      boundaries: []
+    });
+  }
+  
+  // High complexity
+  const highComplexity = result.boundaries.filter(b => (b.complexity || 0) > 10);
+  if (highComplexity.length > 0) {
+    recommendations.push({
+      type: 'reduce_complexity',
+      priority: 'high',
+      description: `${highComplexity.length} boundaries have high complexity and should be simplified`,
+      boundaries: highComplexity.map(b => ({ name: b.name, complexity: b.complexity }))
+    });
+  }
+  
+  // Low cohesion
+  if (result.metadata.cohesion === 'low') {
+    recommendations.push({
+      type: 'improve_cohesion',
+      priority: 'medium',
+      description: 'File has low cohesion, consider restructuring related functionality',
+      boundaries: []
+    });
+  }
+  
+  // High coupling
+  if (result.metadata.coupling === 'high') {
+    recommendations.push({
+      type: 'reduce_coupling',
+      priority: 'medium',
+      description: 'File has high coupling, consider dependency injection or interfaces',
+      boundaries: []
+    });
+  }
+  
+  return recommendations;
+}
+
+/**
+ * Generate boundary summary
+ * @param {Object} result - Detection result
+ * @returns {Object} - Summary statistics
+ */
+function generateBoundarySummary(result) {
+  const summary = {
+    totalBoundaries: result.metadata.totalBoundaries,
+    byType: result.metadata.byType,
+    averageSize: 0,
+    largestBoundary: null,
+    smallestBoundary: null,
+    complexityDistribution: {
+      low: 0,
+      medium: 0,
+      high: 0
+    }
+  };
+  
+  if (result.boundaries.length > 0) {
+    // Calculate average size
+    const totalSize = result.boundaries.reduce((sum, b) => sum + b.lineCount, 0);
+    summary.averageSize = Math.round(totalSize / result.boundaries.length);
+    
+    // Find largest and smallest
+    summary.largestBoundary = result.boundaries.reduce((max, b) => 
+      b.lineCount > max.lineCount ? b : max, result.boundaries[0]);
+    summary.smallestBoundary = result.boundaries.reduce((min, b) => 
+      b.lineCount < min.lineCount ? b : min, result.boundaries[0]);
+    
+    // Complexity distribution
+    for (const boundary of result.boundaries) {
+      const complexity = boundary.complexity || 0;
+      if (complexity <= 5) {
+        summary.complexityDistribution.low++;
+      } else if (complexity <= 10) {
+        summary.complexityDistribution.medium++;
+      } else {
+        summary.complexityDistribution.high++;
+      }
+    }
+  }
+  
+  return summary;
+}
+
+/**
+ * Calculate refactoring score
+ * @param {Object} result - Detection result
+ * @returns {number} - Refactoring score (0-100)
+ */
+function calculateRefactoringScore(result) {
+  let score = 100; // Start with perfect score
+  
+  // Penalize large boundaries
+  const largeBoundaries = result.boundaries.filter(b => b.lineCount > 100);
+  score -= largeBoundaries.length * 10;
+  
+  // Penalize high complexity
+  const highComplexity = result.boundaries.filter(b => (b.complexity || 0) > 15);
+  score -= highComplexity.length * 15;
+  
+  // Penalize low cohesion
+  if (result.metadata.cohesion === 'low') {
+    score -= 20;
+  } else if (result.metadata.cohesion === 'medium') {
+    score -= 10;
+  }
+  
+  // Penalize high coupling
+  if (result.metadata.coupling === 'high') {
+    score -= 15;
+  } else if (result.metadata.coupling === 'medium') {
+    score -= 5;
+  }
+  
+  return Math.max(0, Math.min(100, score));
+}
+
+/**
+ * Generate refactoring priority
+ * @param {Object} result - Detection result
+ * @returns {string} - Priority level
+ */
+function generateRefactoringPriority(result) {
+  const score = calculateRefactoringScore(result);
+  
+  if (score >= 80) return 'low';
+  if (score >= 60) return 'medium';
+  return 'high';
+}
+
+/**
+ * Analyze boundary patterns
+ * @param {Object} result - Detection result
+ * @returns {Object} - Pattern analysis
+ */
+function analyzeBoundaryPatterns(result) {
+  const patterns = {
+    functionPatterns: {},
+    classPatterns: {},
+    importPatterns: {},
+    complexityPatterns: {}
+  };
+  
+  // Function patterns
+  const functions = result.getBoundariesByType(BOUNDARY_TYPES.FUNCTION);
+  if (functions.length > 0) {
+    patterns.functionPatterns = {
+      averageSize: Math.round(functions.reduce((sum, f) => sum + f.lineCount, 0) / functions.length),
+      largestFunction: functions.reduce((max, f) => f.lineCount > max.lineCount ? f : max, functions[0]),
+      complexityTrend: functions.map(f => f.complexity || 0)
+    };
+  }
+  
+  // Class patterns
+  const classes = result.getBoundariesByType(BOUNDARY_TYPES.CLASS);
+  if (classes.length > 0) {
+    patterns.classPatterns = {
+      averageSize: Math.round(classes.reduce((sum, c) => sum + c.lineCount, 0) / classes.length),
+      largestClass: classes.reduce((max, c) => c.lineCount > max.lineCount ? c : max, classes[0]),
+      dependencyTrend: classes.map(c => c.dependencies.length)
+    };
+  }
+  
+  // Import patterns
+  const imports = result.getBoundariesByType(BOUNDARY_TYPES.IMPORT);
+  if (imports.length > 0) {
+    const importNames = imports.map(i => i.name);
+    patterns.importPatterns = {
+      totalImports: imports.length,
+      uniqueImports: [...new Set(importNames)].length,
+      duplicateImports: importNames.length - [...new Set(importNames)].length
+    };
+  }
+  
+  // Complexity patterns
+  const complexities = result.boundaries.map(b => b.complexity || 0);
+  if (complexities.length > 0) {
+    patterns.complexityPatterns = {
+      averageComplexity: Math.round(complexities.reduce((sum, c) => sum + c, 0) / complexities.length),
+      maxComplexity: Math.max(...complexities),
+      minComplexity: Math.min(...complexities),
+      complexityVariance: calculateVariance(complexities)
+    };
+  }
+  
+  return patterns;
+}
+
+/**
+ * Calculate variance of numbers
+ * @param {Array} numbers - Array of numbers
+ * @returns {number} - Variance
+ */
+function calculateVariance(numbers) {
+  const mean = numbers.reduce((sum, num) => sum + num, 0) / numbers.length;
+  const squaredDiffs = numbers.map(num => Math.pow(num - mean, 2));
+  return squaredDiffs.reduce((sum, diff) => sum + diff, 0) / numbers.length;
+}
+
+module.exports = {
+  assessComplexity,
+  assessCohesion,
+  assessCoupling,
+  getRefactoringRecommendations,
+  generateBoundarySummary,
+  calculateRefactoringScore,
+  generateRefactoringPriority,
+  analyzeBoundaryPatterns
+};

package/src/analysis/ast-analyzer.js

@@ -0,0 +1,342 @@
+/**
+ * Boundary Detection - AST Analyzer
+ * 
+ * AST-based boundary detection utilities.
+ */
+
+const { BOUNDARY_TYPES, Boundary } = require('./boundary-types');
+
+/**
+ * Find function boundary
+ * @param {Array} lines - File lines
+ * @param {number} startLine - Starting line index
+ * @param {string} name - Function name
+ * @returns {Boundary|null} - Function boundary or null
+ */
+function findMethodBoundary(lines, startLine, name) {
+  let braceCount = 0;
+  let foundBrace = false;
+  
+  for (let i = startLine; i < lines.length; i++) {
+    const line = lines[i];
+    
+    for (let j = 0; j < line.length; j++) {
+      if (line[j] === '{') {
+        braceCount++;
+        foundBrace = true;
+      } else if (line[j] === '}') {
+        braceCount--;
+        if (foundBrace && braceCount === 0) {
+          const boundary = new Boundary(
+            BOUNDARY_TYPES.FUNCTION,
+            startLine,
+            i,
+            name
+          );
+          boundary.metadata.type = 'method';
+          return boundary;
+        }
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Find class boundary
+ * @param {Array} lines - File lines
+ * @param {number} startLine - Starting line index
+ * @param {string} name - Class name
+ * @returns {Boundary|null} - Class boundary or null
+ */
+function findClassBoundary(lines, startLine, name) {
+  let braceCount = 0;
+  let foundBrace = false;
+  
+  for (let i = startLine; i < lines.length; i++) {
+    const line = lines[i];
+    
+    for (let j = 0; j < line.length; j++) {
+      if (line[j] === '{') {
+        braceCount++;
+        foundBrace = true;
+      } else if (line[j] === '}') {
+        braceCount--;
+        if (foundBrace && braceCount === 0) {
+          return new Boundary(
+            BOUNDARY_TYPES.CLASS,
+            startLine,
+            i,
+            name
+          );
+        }
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Find module boundary
+ * @param {Array} lines - File lines
+ * @param {number} startLine - Starting line index
+ * @param {string} name - Module name
+ * @returns {Boundary|null} - Module boundary or null
+ */
+function findModuleBoundary(lines, startLine, name) {
+  let braceCount = 0;
+  let foundBrace = false;
+  
+  for (let i = startLine; i < lines.length; i++) {
+    const line = lines[i];
+    
+    // Look for module.exports or similar patterns
+    if (line.includes('module.exports') || line.includes('export default')) {
+      if (foundBrace && braceCount === 0) {
+        const boundary = new Boundary(
+          BOUNDARY_TYPES.MODULE,
+          startLine,
+          i,
+          name
+        );
+        boundary.metadata.type = 'module';
+        return boundary;
+      }
+    }
+    
+    for (let j = 0; j < line.length; j++) {
+      if (line[j] === '{') {
+        braceCount++;
+        foundBrace = true;
+      } else if (line[j] === '}') {
+        braceCount--;
+        if (foundBrace && braceCount === 0) {
+          const boundary = new Boundary(
+            BOUNDARY_TYPES.MODULE,
+            startLine,
+            i,
+            name
+          );
+          boundary.metadata.type = 'module';
+          return boundary;
+        }
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Find block boundary
+ * @param {Array} lines - File lines
+ * @param {number} startLine - Starting line index
+ * @param {string} name - Block name
+ * @returns {Boundary|null} - Block boundary or null
+ */
+function findBlockBoundary(lines, startLine, name) {
+  let braceCount = 0;
+  let foundBrace = false;
+  
+  for (let i = startLine; i < lines.length; i++) {
+    const line = lines[i];
+    
+    for (let j = 0; j < line.length; j++) {
+      if (line[j] === '{') {
+        braceCount++;
+        foundBrace = true;
+      } else if (line[j] === '}') {
+        braceCount--;
+        if (foundBrace && braceCount === 0) {
+          const boundary = new Boundary(
+            BOUNDARY_TYPES.BLOCK,
+            startLine,
+            i,
+            name
+          );
+          boundary.metadata.type = 'block';
+          return boundary;
+        }
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Extract function name from line
+ * @param {string} line - Source line
+ * @returns {string|null} - Function name or null
+ */
+function extractFunctionName(line) {
+  const patterns = [
+    /function\s+(\w+)\s*\(/,  // function name()
+    /const\s+(\w+)\s*=\s*(async\s+)?/,  // const name = async
+    /let\s+(\w+)\s*=\s*(async\s+)?/,   // let name = async
+    /var\s+(\w+)\s*=\s*(async\s+)?/,   // var name = async
+    /(\w+)\s*:\s*function\s*\(/,   // name: function()
+    /(\w+)\s*=>\s*\(/           // arrow function
+  ];
+  
+  for (const pattern of patterns) {
+    const match = line.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Extract class name from line
+ * @param {string} line - Source line
+ * @returns {string|null} - Class name or null
+ */
+function extractClassName(line) {
+  const patterns = [
+    /class\s+(\w+)/,                    // class Name
+    /const\s+(\w+)\s*=\s*class\s+/, // const Name = class
+    /let\s+(\w+)\s*=\s*class\s+/,   // let Name = class
+    /var\s+(\w+)\s*=\s*class\s+/,   // var Name = class
+  ];
+  
+  for (const pattern of patterns) {
+    const match = line.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Extract module name from line
+ * @param {string} line - Source line
+ * @returns {string|null} - Module name or null
+ */
+function extractModuleName(line) {
+  const patterns = [
+    /module\.exports\s*=\s*(\w+)/,     // module.exports = Name
+    /exports\.(\w+)\s*=/,              // exports.Name =
+    /export\s+default\s+(\w+)/,          // export default Name
+    /export\s+{\s*(\w+)\s*:/,         // export { Name }:
+  ];
+  
+  for (const pattern of patterns) {
+    const match = line.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Calculate boundary complexity
+ * @param {Array} lines - Lines within boundary
+ * @param {string} boundaryType - Type of boundary
+ * @returns {number} - Complexity score
+ */
+function calculateBoundaryComplexity(lines, boundaryType) {
+  let complexity = 1; // Base complexity
+  
+  for (const line of lines) {
+    // Add complexity for control structures
+    if (/\b(if|else|for|while|switch|case|try|catch|finally)\b/.test(line)) {
+      complexity += 0.5;
+    }
+    
+    // Add complexity for nested structures
+    const nestingLevel = (line.match(/\{/g) || []).length - (line.match(/\}/g) || []).length;
+    if (nestingLevel > 2) {
+      complexity += nestingLevel * 0.2;
+    }
+    
+    // Add complexity for logical operators
+    const logicalOperators = (line.match(/(&&|\|\||&&|\|\|)/g) || []).length;
+    if (logicalOperators > 2) {
+      complexity += logicalOperators * 0.1;
+    }
+  }
+  
+  return Math.round(complexity);
+}
+
+/**
+ * Find dependencies in boundary
+ * @param {Array} lines - Lines within boundary
+ * @returns {Array} - Dependencies
+ */
+function findDependencies(lines) {
+  const dependencies = [];
+  const importPatterns = [
+    /require\s*\(\s*['"]([^'"]+)['"]\s*\)/,
+    /import\s+.*\s+from\s+['"]([^'"]+)['"]/,
+    /import\s*\(\s*['"]([^'"]+)['"]\s*\)/
+  ];
+  
+  for (const line of lines) {
+    for (const pattern of importPatterns) {
+      const match = line.match(pattern);
+      if (match) {
+        dependencies.push({
+          type: 'import',
+          name: match[1],
+          line: line
+        });
+      }
+    }
+  }
+  
+  return dependencies;
+}
+
+/**
+ * Find exports in boundary
+ * @param {Array} lines - Lines within boundary
+ * @returns {Array} - Exports
+ */
+function findExports(lines) {
+  const exports = [];
+  const exportPatterns = [
+    /module\.exports\.(\w+)\s*=/,
+    /exports\.(\w+)\s*=/,
+    /export\s+default\s+(\w+)/,
+    /export\s+{\s*(\w+)\s*[,}]/,
+    /export\s+{\s*(\w+)\s+as\s+(\w+)\s*[,}]/
+  ];
+  
+  for (const line of lines) {
+    for (const pattern of exportPatterns) {
+      const match = line.match(pattern);
+      if (match) {
+        exports.push({
+          type: 'export',
+          name: match[1] || match[2],
+          line: line
+        });
+      }
+    }
+  }
+  
+  return exports;
+}
+
+module.exports = {
+  findMethodBoundary,
+  findClassBoundary,
+  findModuleBoundary,
+  findBlockBoundary,
+  extractFunctionName,
+  extractClassName,
+  extractModuleName,
+  calculateBoundaryComplexity,
+  findDependencies,
+  findExports
+};