vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/analysis/boundary-utils.js

@@ -0,0 +1,293 @@
+/**
+ * Boundary Analysis Utilities
+ * 
+ * Utility functions for boundary detection and analysis.
+ */
+
+/**
+ * Boundary types
+ */
+const BOUNDARY_TYPES = {
+  FUNCTION: 'function',
+  CLASS: 'class',
+  MODULE: 'module',
+  BLOCK: 'block',
+  IMPORT: 'import',
+  EXPORT: 'export',
+  COMMENT: 'comment',
+  UTILITY: 'utility',
+  CONSTANT: 'constant'
+};
+
+/**
+ * Create boundary object
+ * @param {string} type - Boundary type
+ * @param {number} start - Start position
+ * @param {number} end - End position
+ * @param {string} name - Boundary name
+ * @param {Object} metadata - Additional metadata
+ * @returns {Object} - Boundary object
+ */
+function createBoundary(type, start, end, name, metadata = {}) {
+  return {
+    type,
+    start,
+    end,
+    name,
+    size: end - start,
+    complexity: metadata.complexity || 1,
+    dependencies: metadata.dependencies || [],
+    exports: metadata.exports || [],
+    imports: metadata.imports || [],
+    metadata
+  };
+}
+
+/**
+ * Analyze boundary complexity
+ * @param {Object} boundary - Boundary object
+ * @returns {number} - Complexity score
+ */
+function analyzeBoundaryComplexity(boundary) {
+  let complexity = 1;
+  
+  // Base complexity by type
+  const typeComplexity = {
+    [BOUNDARY_TYPES.CLASS]: 3,
+    [BOUNDARY_TYPES.FUNCTION]: 2,
+    [BOUNDARY_TYPES.MODULE]: 4,
+    [BOUNDARY_TYPES.BLOCK]: 1,
+    [BOUNDARY_TYPES.UTILITY]: 2,
+    [BOUNDARY_TYPES.CONSTANT]: 1
+  };
+  
+  complexity += typeComplexity[boundary.type] || 1;
+  
+  // Add dependency complexity
+  if (boundary.dependencies) {
+    complexity += boundary.dependencies.length * 0.5;
+  }
+  
+  // Add size complexity
+  if (boundary.size > 100) {
+    complexity += 2;
+  } else if (boundary.size > 50) {
+    complexity += 1;
+  }
+  
+  return Math.round(complexity);
+}
+
+/**
+ * Calculate boundary cohesion
+ * @param {Object} boundary - Boundary object
+ * @returns {string} - Cohesion level
+ */
+function calculateBoundaryCohesion(boundary) {
+  if (!boundary.dependencies || boundary.dependencies.length === 0) {
+    return 'high';
+  }
+  
+  const relatedDependencies = boundary.dependencies.filter(dep => 
+    boundary.name && dep.includes(boundary.name.toLowerCase())
+  );
+  
+  const cohesionRatio = relatedDependencies.length / boundary.dependencies.length;
+  
+  if (cohesionRatio > 0.8) return 'high';
+  if (cohesionRatio > 0.6) return 'medium';
+  if (cohesionRatio > 0.4) return 'low';
+  return 'very_low';
+}
+
+/**
+ * Calculate boundary coupling
+ * @param {Object} boundary - Boundary object
+ * @param {Array} allBoundaries - All boundaries in file
+ * @returns {string} - Coupling level
+ */
+function calculateBoundaryCoupling(boundary, allBoundaries) {
+  const externalDependencies = boundary.dependencies.filter(dep => {
+    return !allBoundaries.some(other => 
+      other.name && other.name !== boundary.name && dep.includes(other.name.toLowerCase())
+    );
+  });
+  
+  const couplingRatio = externalDependencies.length / (boundary.dependencies.length || 1);
+  
+  if (couplingRatio > 0.7) return 'high';
+  if (couplingRatio > 0.5) return 'medium';
+  if (couplingRatio > 0.3) return 'low';
+  return 'very_low';
+}
+
+/**
+ * Group boundaries by type
+ * @param {Array} boundaries - Array of boundaries
+ * @returns {Object} - Boundaries grouped by type
+ */
+function groupBoundariesByType(boundaries) {
+  const grouped = {};
+  
+  boundaries.forEach(boundary => {
+    if (!grouped[boundary.type]) {
+      grouped[boundary.type] = [];
+    }
+    grouped[boundary.type].push(boundary);
+  });
+  
+  return grouped;
+}
+
+/**
+ * Find boundary relationships
+ * @param {Array} boundaries - Array of boundaries
+ * @returns {Array} - Array of relationships
+ */
+function findBoundaryRelationships(boundaries) {
+  const relationships = [];
+  
+  boundaries.forEach(boundary => {
+    if (boundary.dependencies) {
+      boundary.dependencies.forEach(dep => {
+        const target = boundaries.find(b => 
+          b.name && dep.includes(b.name.toLowerCase())
+        );
+        
+        if (target) {
+          relationships.push({
+            source: boundary.name,
+            target: target.name,
+            type: 'dependency',
+            strength: calculateDependencyStrength(boundary, target)
+          });
+        }
+      });
+    }
+  });
+  
+  return relationships;
+}
+
+/**
+ * Calculate dependency strength
+ * @param {Object} source - Source boundary
+ * @param {Object} target - Target boundary
+ * @returns {number} - Dependency strength
+ */
+function calculateDependencyStrength(source, target) {
+  let strength = 1;
+  
+  // Same type increases strength
+  if (source.type === target.type) {
+    strength += 0.5;
+  }
+  
+  // Size difference affects strength
+  const sizeRatio = Math.min(source.size, target.size) / Math.max(source.size, target.size);
+  strength += sizeRatio;
+  
+  return Math.round(strength * 10) / 10;
+}
+
+/**
+ * Generate boundary recommendations
+ * @param {Array} boundaries - Array of boundaries
+ * @returns {Array} - Array of recommendations
+ */
+function generateBoundaryRecommendations(boundaries) {
+  const recommendations = [];
+  
+  // Check for large boundaries
+  const largeBoundaries = boundaries.filter(b => b.size > 100);
+  if (largeBoundaries.length > 0) {
+    recommendations.push({
+      type: 'size',
+      priority: 'high',
+      message: `${largeBoundaries.length} boundaries exceed 100 lines`,
+      action: 'split_large_boundaries'
+    });
+  }
+  
+  // Check for high complexity
+  const highComplexity = boundaries.filter(b => analyzeBoundaryComplexity(b) > 5);
+  if (highComplexity.length > 0) {
+    recommendations.push({
+      type: 'complexity',
+      priority: 'medium',
+      message: `${highComplexity.length} boundaries have high complexity`,
+      action: 'reduce_complexity'
+    });
+  }
+  
+  // Check for low cohesion
+  const lowCohesion = boundaries.filter(b => calculateBoundaryCohesion(b) === 'low' || calculateBoundaryCohesion(b) === 'very_low');
+  if (lowCohesion.length > 0) {
+    recommendations.push({
+      type: 'cohesion',
+      priority: 'medium',
+      message: `${lowCohesion.length} boundaries have low cohesion`,
+      action: 'improve_cohesion'
+    });
+  }
+  
+  return recommendations;
+}
+
+/**
+ * Validate boundary object
+ * @param {Object} boundary - Boundary to validate
+ * @returns {Object} - Validation result
+ */
+function validateBoundary(boundary) {
+  const validation = {
+    isValid: true,
+    errors: [],
+    warnings: []
+  };
+  
+  // Check required fields
+  if (!boundary.type) {
+    validation.isValid = false;
+    validation.errors.push('Missing boundary type');
+  }
+  
+  if (typeof boundary.start !== 'number') {
+    validation.isValid = false;
+    validation.errors.push('Invalid start position');
+  }
+  
+  if (typeof boundary.end !== 'number') {
+    validation.isValid = false;
+    validation.errors.push('Invalid end position');
+  }
+  
+  if (boundary.start >= boundary.end) {
+    validation.isValid = false;
+    validation.errors.push('Start position must be less than end position');
+  }
+  
+  // Warnings
+  if (boundary.size > 200) {
+    validation.warnings.push('Boundary is very large (>200 lines)');
+  }
+  
+  if (analyzeBoundaryComplexity(boundary) > 10) {
+    validation.warnings.push('Boundary has very high complexity (>10)');
+  }
+  
+  return validation;
+}
+
+module.exports = {
+  BOUNDARY_TYPES,
+  createBoundary,
+  analyzeBoundaryComplexity,
+  calculateBoundaryCohesion,
+  calculateBoundaryCoupling,
+  groupBoundariesByType,
+  findBoundaryRelationships,
+  calculateDependencyStrength,
+  generateBoundaryRecommendations,
+  validateBoundary
+};

package/src/analysis/deadline-priority-calculator.js

@@ -0,0 +1,18 @@
+/**
+ * Deadline Priority Calculator
+ */
+
+function calculateDeadlinePriority(data) {
+  // Calculate deadline priority
+  const deadlinePriority = 0;
+  if (data.deadline === 'soon') {
+    deadlinePriority += 40;
+  } else if (data.deadline === 'medium') {
+    deadlinePriority += 20;
+  } else {
+    deadlinePriority += 4;
+  }
+  return deadlinePriority;
+}
+
+export { calculateDeadlinePriority };

package/src/analysis/detection-methods.js

@@ -0,0 +1,347 @@
+/**
+ * Boundary Detection - Detection Methods
+ * 
+ * Methods for detecting different types of boundaries in code.
+ */
+
+const { BOUNDARY_TYPES, Boundary } = require('./boundary-types');
+const { 
+  findMethodBoundary,
+  findClassBoundary,
+  findModuleBoundary,
+  extractFunctionName,
+  extractClassName,
+  extractModuleName,
+  calculateBoundaryComplexity,
+  findDependencies,
+  findExports
+} = require('./ast-analyzer');
+
+/**
+ * Detect function boundaries
+ * @param {Array} lines - File lines
+ * @param {Object} result - Detection result
+ */
+function detectFunctions(lines, result) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Function patterns
+    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) {
+        const functionName = match[1];
+        const boundary = findMethodBoundary(lines, i, functionName);
+        
+        if (boundary) {
+          boundary.metadata = {
+            pattern: pattern.source,
+            extractedName: functionName
+          };
+          result.addBoundary(boundary);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Detect class boundaries
+ * @param {Array} lines - File lines
+ * @param {Object} result - Detection result
+ */
+function detectClasses(lines, result) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    const classMatch = line.match(/^class\s+(\w+)/);
+    if (classMatch) {
+      const className = classMatch[1];
+      const boundary = findClassBoundary(lines, i, className);
+      
+      if (boundary) {
+        boundary.metadata = {
+          pattern: 'class',
+          extractedName: className
+        };
+        result.addBoundary(boundary);
+      }
+    }
+  }
+}
+
+/**
+ * Detect module boundaries
+ * @param {Array} lines - File lines
+ * @param {Object} result - Detection result
+ */
+function detectModules(lines, result) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Module patterns
+    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) {
+        const moduleName = match[1];
+        const boundary = findModuleBoundary(lines, i, moduleName);
+        
+        if (boundary) {
+          boundary.metadata = {
+            pattern: pattern.source,
+            extractedName: moduleName
+          };
+          result.addBoundary(boundary);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Detect utility sections
+ * @param {Array} lines - File lines
+ * @param {Object} result - Detection result
+ */
+function detectUtilities(lines, result) {
+  // Look for sections with utility functions
+  let utilityStart = null;
+  let utilityName = null;
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Detect utility section comments
+    if (line.includes('// Utilities') || line.includes('/* Utilities')) {
+      utilityStart = i + 1;
+      const commentMatch = line.match(/\/\*\s*(\w+)/);
+      if (commentMatch) {
+        utilityName = commentMatch[1];
+      }
+      continue;
+    }
+    
+    // If we found a utility section, look for its end
+    if (utilityStart !== null) {
+      const boundary = findBlockBoundary(lines, utilityStart, utilityName || 'utilities');
+      
+      if (boundary) {
+        boundary.type = BOUNDARY_TYPES.UTILITY;
+        boundary.metadata = {
+          section: 'utilities',
+          extractedName: utilityName
+        };
+        result.addBoundary(boundary);
+        utilityStart = null;
+        utilityName = null;
+      }
+    }
+  }
+}
+
+/**
+ * Detect import boundaries
+ * @param {Array} lines - File lines
+ * @param {Object} result - Detection result
+ */
+function detectImports(lines, result) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Import patterns
+    const patterns = [
+      /require\s*\(\s*['"]([^'"]+)['"]\s*\)/,
+      /import\s+.*\s+from\s+['"]([^'"]+)['"]/,
+      /import\s*\(\s*['"]([^'"]+)['"]\s*\)/
+    ];
+    
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const importName = match[1];
+        const boundary = new Boundary(
+          BOUNDARY_TYPES.IMPORT,
+          i,
+          i,
+          importName
+        );
+        boundary.metadata = {
+          pattern: pattern.source,
+          extractedName: importName
+        };
+        result.addBoundary(boundary);
+      }
+    }
+  }
+}
+
+/**
+ * Detect export boundaries
+ * @param {Array} lines - File lines
+ * @param {Object} result - Detection result
+ */
+function detectExports(lines, result) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Export patterns
+    const patterns = [
+      /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 pattern of patterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const exportName = match[1] || match[2];
+        const boundary = new Boundary(
+          BOUNDARY_TYPES.EXPORT,
+          i,
+          i,
+          exportName
+        );
+        boundary.metadata = {
+          pattern: pattern.source,
+          extractedName: exportName
+        };
+        result.addBoundary(boundary);
+      }
+    }
+  }
+}
+
+/**
+ * Detect comment boundaries
+ * @param {Array} lines - File lines
+ * @param {Object} result - Detection result
+ */
+function detectComments(lines, result) {
+  let inBlockComment = false;
+  let blockCommentStart = null;
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Block comment start
+    if (line.includes('/*')) {
+      inBlockComment = true;
+      blockCommentStart = i;
+      continue;
+    }
+    
+    // Block comment end
+    if (line.includes('*/') && inBlockComment) {
+      inBlockComment = false;
+      const boundary = new Boundary(
+        BOUNDARY_TYPES.COMMENT,
+        blockCommentStart,
+        i,
+        'block-comment'
+      );
+      boundary.metadata = {
+        type: 'block'
+      };
+      result.addBoundary(boundary);
+      blockCommentStart = null;
+      continue;
+    }
+    
+    // Line comments
+    if (!inBlockComment && (line.includes('//') || line.includes('#'))) {
+      const boundary = new Boundary(
+        BOUNDARY_TYPES.COMMENT,
+        i,
+        i,
+        'line-comment'
+      );
+      boundary.metadata = {
+        type: 'line'
+      };
+      result.addBoundary(boundary);
+    }
+  }
+}
+
+/**
+ * Detect constant boundaries
+ * @param {Array} lines - File lines
+ * @param {Object} result - Detection result
+ */
+function detectConstants(lines, result) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Constant patterns
+    const patterns = [
+      /const\s+(\w+)\s*=\s*[^;]+/,  // const NAME = value
+      /let\s+(\w+)\s*=\s*[^;]+/,   // let NAME = value (immutable)
+      /var\s+(\w+)\s*=\s*[^;]+/,   // var NAME = value (immutable)
+    ];
+    
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const constantName = match[1];
+        const boundary = new Boundary(
+          BOUNDARY_TYPES.CONSTANT,
+          i,
+          i,
+          constantName
+        );
+        boundary.metadata = {
+          pattern: pattern.source,
+          extractedName: constantName
+        };
+        result.addBoundary(boundary);
+      }
+    }
+  }
+}
+
+/**
+ * Calculate complexity for all boundaries
+ * @param {Array} lines - File lines
+ * @param {Object} result - Detection result
+ */
+function calculateComplexity(lines, result) {
+  for (const boundary of result.boundaries) {
+    const boundaryLines = lines.slice(boundary.startLine, boundary.endLine + 1);
+    boundary.setComplexity(calculateBoundaryComplexity(boundaryLines, boundary.type));
+    
+    // Add dependencies and exports
+    const boundaryLinesText = boundaryLines.join('\n');
+    boundary.dependencies = findDependencies(boundaryLinesText.split('\n'));
+    boundary.exports = findExports(boundaryLinesText.split('\n'));
+  }
+}
+
+module.exports = {
+  detectFunctions,
+  detectClasses,
+  detectModules,
+  detectUtilities,
+  detectImports,
+  detectExports,
+  detectComments,
+  detectConstants,
+  calculateComplexity
+};

package/src/analysis/importance-priority-calculator.js

@@ -0,0 +1,18 @@
+/**
+ * Importance Priority Calculator
+ */
+
+function calculateImportancePriority(data) {
+  // Calculate importance priority
+  const importancePriority = 0;
+  if (data.importance === 'high') {
+    importancePriority += 30;
+  } else if (data.importance === 'medium') {
+    importancePriority += 15;
+  } else {
+    importancePriority += 3;
+  }
+  return importancePriority;
+}
+
+export { calculateImportancePriority };