vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/refactoring/boundaries/cohesion-analyzer.js

@@ -0,0 +1,316 @@
+/**
+ * Cohesion Analyzer
+ * 
+ * Analyzes code cohesion to determine how well-related code segments are.
+ */
+
+const { COHESION_LEVELS } = require('./module-boundary');
+
+/**
+ * Cohesion Analyzer class
+ */
+class CohesionAnalyzer {
+  constructor() {
+    this.metrics = {
+      variableSharing: 0.3,
+      functionCalls: 0.25,
+      typeReferences: 0.2,
+      logicalRelatedness: 0.15,
+      structuralProximity: 0.1
+    };
+  }
+
+  /**
+   * Analyze cohesion of a code segment
+   */
+  analyzeCohesion(code, boundary) {
+    const scores = {
+      variableSharing: this.analyzeVariableSharing(code),
+      functionCalls: this.analyzeFunctionCalls(code),
+      typeReferences: this.analyzeTypeReferences(code),
+      logicalRelatedness: this.analyzeLogicalRelatedness(code, boundary),
+      structuralProximity: this.analyzeStructuralProximity(code, boundary)
+    };
+
+    const totalScore = Object.entries(scores).reduce((sum, [metric, score]) => {
+      return sum + (score * this.metrics[metric]);
+    }, 0);
+
+    return {
+      score: Math.min(1, Math.max(0, totalScore)),
+      level: this.getCohesionLevel(totalScore),
+      details: scores
+    };
+  }
+
+  /**
+   * Analyze variable sharing within the boundary
+   */
+  analyzeVariableSharing(code) {
+    const variables = this.extractVariables(code);
+    const variableUsage = this.analyzeVariableUsage(code, variables);
+    
+    if (variables.length === 0) return 0;
+
+    // High cohesion if variables are used multiple times within the boundary
+    const usageRatio = variableUsage.filter(v => v.count > 1).length / variables.length;
+    return Math.min(1, usageRatio * 1.5);
+  }
+
+  /**
+   * Analyze function calls within the boundary
+   */
+  analyzeFunctionCalls(code) {
+    const functions = this.extractFunctions(code);
+    const functionCalls = this.extractFunctionCalls(code);
+    
+    if (functions.length === 0) return 0;
+
+    // Count internal function calls
+    const internalCalls = functionCalls.filter(call => 
+      functions.some(func => func.name === call.name)
+    );
+
+    const internalCallRatio = internalCalls.length / Math.max(functionCalls.length, 1);
+    return Math.min(1, internalCallRatio * 2);
+  }
+
+  /**
+   * Analyze type references within the boundary
+   */
+  analyzeTypeReferences(code) {
+    const types = this.extractTypes(code);
+    const typeReferences = this.extractTypeReferences(code);
+    
+    if (types.length === 0) return 0;
+
+    // Count internal type references
+    const internalRefs = typeReferences.filter(ref => 
+      types.some(type => type.name === ref.name)
+    );
+
+    const internalRefRatio = internalRefs.length / Math.max(typeReferences.length, 1);
+    return Math.min(1, internalRefRatio * 1.5);
+  }
+
+  /**
+   * Analyze logical relatedness
+   */
+  analyzeLogicalRelatedness(code, boundary) {
+    const semanticGroups = this.identifySemanticGroups(code);
+    const domainTerms = this.extractDomainTerms(code, boundary.name);
+    
+    // High cohesion if code focuses on few semantic groups
+    const groupConcentration = this.calculateGroupConcentration(semanticGroups);
+    const domainConsistency = this.calculateDomainConsistency(domainTerms);
+    
+    return (groupConcentration + domainConsistency) / 2;
+  }
+
+  /**
+   * Analyze structural proximity
+   */
+  analyzeStructuralProximity(code, boundary) {
+    const lines = code.split('\n');
+    const lineSpan = boundary.endLine - boundary.startLine + 1;
+    
+    // Penalize very large spans and very small spans
+    if (lineSpan < 5) return 0.3;
+    if (lineSpan > 100) return 0.5;
+    
+    // Optimal range is 10-50 lines
+    if (lineSpan >= 10 && lineSpan <= 50) return 1.0;
+    
+    // Linear scaling for intermediate ranges
+    return 0.8;
+  }
+
+  /**
+   * Extract variables from code
+   */
+  extractVariables(code) {
+    const patterns = [
+      /(?:const|let|var)\s+(\w+)/g,
+      /(\w+)\s*=/g
+    ];
+
+    const variables = new Set();
+    
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(code)) !== null) {
+        variables.add(match[1]);
+      }
+    }
+
+    return Array.from(variables);
+  }
+
+  /**
+   * Analyze variable usage
+   */
+  analyzeVariableUsage(code, variables) {
+    const usage = variables.map(variable => ({
+      name: variable,
+      count: (code.match(new RegExp(`\\b${variable}\\b`, 'g')) || []).length
+    }));
+
+    return usage;
+  }
+
+  /**
+   * Extract functions from code
+   */
+  extractFunctions(code) {
+    const patterns = [
+      /function\s+(\w+)/g,
+      /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?function/g,
+      /(?:const|let|var)\s+(\w+)\s*=\s*\([^)]*\)\s*=>/g
+    ];
+
+    const functions = [];
+    
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(code)) !== null) {
+        functions.push({ name: match[1] });
+      }
+    }
+
+    return functions;
+  }
+
+  /**
+   * Extract function calls from code
+   */
+  extractFunctionCalls(code) {
+    const pattern = /(\w+)\s*\(/g;
+    const calls = [];
+    let match;
+    
+    while ((match = pattern.exec(code)) !== null) {
+      // Exclude common language constructs
+      if (!['if', 'while', 'for', 'switch', 'catch'].includes(match[1])) {
+        calls.push({ name: match[1] });
+      }
+    }
+
+    return calls;
+  }
+
+  /**
+   * Extract types from code
+   */
+  extractTypes(code) {
+    const patterns = [
+      /class\s+(\w+)/g,
+      /interface\s+(\w+)/g,
+      /type\s+(\w+)\s*=/g
+    ];
+
+    const types = [];
+    
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(code)) !== null) {
+        types.push({ name: match[1] });
+      }
+    }
+
+    return types;
+  }
+
+  /**
+   * Extract type references from code
+   */
+  extractTypeReferences(code) {
+    // Simple heuristic: capitalized words that aren't at start of line
+    const pattern = /\b([A-Z]\w*)\b/g;
+    const references = [];
+    let match;
+    
+    while ((match = pattern.exec(code)) !== null) {
+      references.push({ name: match[1] });
+    }
+
+    return references;
+  }
+
+  /**
+   * Identify semantic groups in code
+   */
+  identifySemanticGroups(code) {
+    const keywords = {
+      data: ['data', 'model', 'entity', 'record', 'item'],
+      validation: ['validate', 'check', 'verify', 'ensure', 'assert'],
+      transformation: ['transform', 'convert', 'parse', 'format', 'normalize'],
+      calculation: ['calculate', 'compute', 'derive', 'determine', 'evaluate'],
+      ui: ['render', 'display', 'show', 'hide', 'update', 'draw'],
+      io: ['read', 'write', 'save', 'load', 'fetch', 'send', 'receive']
+    };
+
+    const groups = {};
+    const words = code.toLowerCase().split(/\W+/);
+
+    for (const [group, terms] of Object.entries(keywords)) {
+      const matches = words.filter(word => terms.includes(word));
+      if (matches.length > 0) {
+        groups[group] = matches.length;
+      }
+    }
+
+    return groups;
+  }
+
+  /**
+   * Extract domain terms
+   */
+  extractDomainTerms(code, boundaryName) {
+    const boundaryWords = boundaryName.toLowerCase().split(/[-_]/);
+    const codeWords = code.toLowerCase().split(/\W+/);
+    
+    // Find words that appear in both boundary name and code
+    const domainTerms = boundaryWords.filter(word => 
+      word.length > 2 && codeWords.includes(word)
+    );
+
+    return domainTerms;
+  }
+
+  /**
+   * Calculate group concentration
+   */
+  calculateGroupConcentration(groups) {
+    const totalGroups = Object.keys(groups).length;
+    const totalOccurrences = Object.values(groups).reduce((sum, count) => sum + count, 0);
+    
+    if (totalGroups === 0) return 0.5; // Neutral
+    
+    // High concentration if few groups dominate
+    const avgOccurrences = totalOccurrences / totalGroups;
+    const dominantGroups = Object.values(groups).filter(count => count > avgOccurrences * 1.5);
+    
+    return Math.min(1, dominantGroups.length / totalGroups);
+  }
+
+  /**
+   * Calculate domain consistency
+   */
+  calculateDomainConsistency(domainTerms) {
+    if (domainTerms.length === 0) return 0.3;
+    if (domainTerms.length >= 3) return 1.0;
+    return 0.5 + (domainTerms.length * 0.25);
+  }
+
+  /**
+   * Get cohesion level from score
+   */
+  getCohesionLevel(score) {
+    if (score >= 0.8) return COHESION_LEVELS.HIGH;
+    if (score >= 0.5) return COHESION_LEVELS.MEDIUM;
+    if (score >= 0.2) return COHESION_LEVELS.LOW;
+    return COHESION_LEVELS.NONE;
+  }
+}
+
+module.exports = CohesionAnalyzer;

package/src/refactoring/boundaries/extraction-result.js

@@ -0,0 +1,285 @@
+/**
+ * Boundary Extraction Result
+ * 
+ * Contains results of boundary extraction analysis.
+ */
+
+const { ModuleBoundary } = require('./module-boundary');
+
+/**
+ * Boundary extraction result class
+ */
+class BoundaryExtractionResult {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.boundaries = [];
+    this.errors = [];
+    this.warnings = [];
+    this.metadata = {
+      extractedAt: new Date().toISOString(),
+      totalLines: 0,
+      processedLines: 0,
+      extractionTime: 0
+    };
+  }
+
+  /**
+   * Add boundary to result
+   */
+  addBoundary(boundaryData) {
+    const boundary = new ModuleBoundary(
+      boundaryData.type,
+      boundaryData.name,
+      boundaryData.startLine,
+      boundaryData.endLine,
+      this.filePath
+    );
+
+    // Set additional properties
+    if (boundaryData.confidence) {
+      boundary.confidence = boundaryData.confidence;
+    }
+
+    this.boundaries.push(boundary);
+    return boundary;
+  }
+
+  /**
+   * Add error
+   */
+  addError(error) {
+    this.errors.push({
+      message: error.message || error,
+      line: error.line || null,
+      severity: error.severity || 'error',
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Add warning
+   */
+  addWarning(warning) {
+    this.warnings.push({
+      message: warning.message || warning,
+      line: warning.line || null,
+      code: warning.code || null,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Get extractable boundaries
+   */
+  getExtractableBoundaries() {
+    return this.boundaries.filter(boundary => boundary.isExtractable());
+  }
+
+  /**
+   * Get high cohesion boundaries
+   */
+  getHighCohesionBoundaries() {
+    return this.boundaries.filter(boundary => boundary.hasHighCohesion());
+  }
+
+  /**
+   * Get boundaries by type
+   */
+  getBoundariesByType(type) {
+    return this.boundaries.filter(boundary => boundary.type === type);
+  }
+
+  /**
+   * Get boundaries by priority range
+   */
+  getBoundariesByPriority(minPriority = 1, maxPriority = Infinity) {
+    return this.boundaries.filter(boundary => {
+      const priority = boundary.getExtractionPriority();
+      return priority >= minPriority && priority <= maxPriority;
+    });
+  }
+
+  /**
+   * Calculate coverage percentage
+   */
+  calculateCoverage() {
+    if (this.metadata.totalLines === 0) return 0;
+
+    const coveredLines = this.boundaries.reduce((total, boundary) => {
+      return total + boundary.lineCount;
+    }, 0);
+
+    return (coveredLines / this.metadata.totalLines) * 100;
+  }
+
+  /**
+   * Get extraction statistics
+   */
+  getStatistics() {
+    const extractable = this.getExtractableBoundaries();
+    const highCohesion = this.getHighCohesionBoundaries();
+
+    return {
+      totalBoundaries: this.boundaries.length,
+      extractableBoundaries: extractable.length,
+      highCohesionBoundaries: highCohesion.length,
+      coverage: this.calculateCoverage(),
+      averageBoundarySize: this.calculateAverageBoundarySize(),
+      priorityDistribution: this.getPriorityDistribution(),
+      typeDistribution: this.getTypeDistribution(),
+      errors: this.errors.length,
+      warnings: this.warnings.length
+    };
+  }
+
+  /**
+   * Calculate average boundary size
+   */
+  calculateAverageBoundarySize() {
+    if (this.boundaries.length === 0) return 0;
+
+    const totalLines = this.boundaries.reduce((sum, boundary) => {
+      return sum + boundary.lineCount;
+    }, 0);
+
+    return totalLines / this.boundaries.length;
+  }
+
+  /**
+   * Get priority distribution
+   */
+  getPriorityDistribution() {
+    const distribution = { high: 0, medium: 0, low: 0, none: 0 };
+
+    for (const boundary of this.boundaries) {
+      const priority = boundary.getExtractionPriority();
+      if (priority >= 5) distribution.high++;
+      else if (priority >= 3) distribution.medium++;
+      else if (priority >= 1) distribution.low++;
+      else distribution.none++;
+    }
+
+    return distribution;
+  }
+
+  /**
+   * Get type distribution
+   */
+  getTypeDistribution() {
+    const distribution = {};
+
+    for (const boundary of this.boundaries) {
+      distribution[boundary.type] = (distribution[boundary.type] || 0) + 1;
+    }
+
+    return distribution;
+  }
+
+  /**
+   * Get top extraction candidates
+   */
+  getTopExtractionCandidates(limit = 10) {
+    return this.getExtractableBoundaries()
+      .sort((a, b) => b.getExtractionPriority() - a.getExtractionPriority())
+      .slice(0, limit);
+  }
+
+  /**
+   * Validate extraction result
+   */
+  validate() {
+    const issues = [];
+
+    // Check for overlapping boundaries
+    const overlaps = this.findOverlappingBoundaries();
+    if (overlaps.length > 0) {
+      issues.push({
+        type: 'overlap',
+        message: `${overlaps.length} overlapping boundaries found`,
+        details: overlaps
+      });
+    }
+
+    // Check for very small boundaries
+    const tinyBoundaries = this.boundaries.filter(b => b.lineCount < 3);
+    if (tinyBoundaries.length > 0) {
+      issues.push({
+        type: 'size',
+        message: `${tinyBoundaries.length} boundaries are too small (< 3 lines)`,
+        details: tinyBoundaries.map(b => b.name)
+      });
+    }
+
+    // Check for unnamed boundaries
+    const unnamedBoundaries = this.boundaries.filter(b => !b.name || b.name.trim() === '');
+    if (unnamedBoundaries.length > 0) {
+      issues.push({
+        type: 'naming',
+        message: `${unnamedBoundaries.length} boundaries have no name`,
+        details: unnamedBoundaries.map(b => `Line ${b.startLine}-${b.endLine}`)
+      });
+    }
+
+    return issues;
+  }
+
+  /**
+   * Find overlapping boundaries
+   */
+  findOverlappingBoundaries() {
+    const overlaps = [];
+    const sorted = [...this.boundaries].sort((a, b) => a.startLine - b.startLine);
+
+    for (let i = 0; i < sorted.length - 1; i++) {
+      const current = sorted[i];
+      const next = sorted[i + 1];
+
+      if (current.endLine >= next.startLine) {
+        overlaps.push({
+          boundary1: current.name,
+          boundary2: next.name,
+          overlapLines: current.endLine - next.startLine + 1
+        });
+      }
+    }
+
+    return overlaps;
+  }
+
+  /**
+   * Set metadata
+   */
+  setMetadata(key, value) {
+    this.metadata[key] = value;
+  }
+
+  /**
+   * Get summary
+   */
+  getSummary() {
+    return {
+      filePath: this.filePath,
+      statistics: this.getStatistics(),
+      topCandidates: this.getTopExtractionCandidates(5).map(b => b.getSummary()),
+      issues: this.validate(),
+      errors: this.errors.slice(0, 5), // Limit for summary
+      warnings: this.warnings.slice(0, 5) // Limit for summary
+    };
+  }
+
+  /**
+   * Export to JSON
+   */
+  toJSON() {
+    return {
+      filePath: this.filePath,
+      boundaries: this.boundaries.map(b => b.toJSON()),
+      errors: this.errors,
+      warnings: this.warnings,
+      metadata: this.metadata,
+      statistics: this.getStatistics()
+    };
+  }
+}
+
+module.exports = BoundaryExtractionResult;