vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/refactoring/boundary/boundary-types.js

@@ -0,0 +1,405 @@
+/**
+ * Boundary Types and Data Structures
+ */
+
+/**
+ * Boundary types
+ */
+const BOUNDARY_TYPES = {
+  FUNCTION: 'function',
+  CLASS: 'class',
+  OBJECT: 'object',
+  MODULE: 'module',
+  UTILITY: 'utility',
+  CONFIG: 'config',
+  CONSTANT: 'constant'
+};
+
+/**
+ * Cohesion levels
+ */
+const COHESION_LEVELS = {
+  HIGH: 'high',
+  MEDIUM: 'medium',
+  LOW: 'low',
+  NONE: 'none'
+};
+
+/**
+ * Module boundary class
+ */
+class ModuleBoundary {
+  constructor(type, name, startLine, endLine, filePath) {
+    this.id = this.generateId();
+    this.type = type;
+    this.name = name;
+    this.startLine = startLine;
+    this.endLine = endLine;
+    this.filePath = filePath;
+    this.lineCount = endLine - startLine + 1;
+    this.cohesion = COHESION_LEVELS.NONE;
+    this.complexity = 0;
+    this.dependencies = [];
+    this.exports = [];
+    this.internalReferences = [];
+    this.externalReferences = [];
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      confidence: 0.5,
+      extractable: false
+    };
+  }
+
+  /**
+   * Generate unique boundary ID
+   * @returns {string} Generated ID
+   */
+  generateId() {
+    return `boundary_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Set cohesion level
+   * @param {string} cohesion - Cohesion level
+   */
+  setCohesion(cohesion) {
+    this.cohesion = cohesion;
+  }
+
+  /**
+   * Set complexity score
+   * @param {number} complexity - Complexity score
+   */
+  setComplexity(complexity) {
+    this.complexity = complexity;
+  }
+
+  /**
+   * Add dependency
+   * @param {string} dependency - Dependency name
+   */
+  addDependency(dependency) {
+    if (!this.dependencies.includes(dependency)) {
+      this.dependencies.push(dependency);
+    }
+  }
+
+  /**
+   * Add export
+   * @param {string} exportName - Export name
+   */
+  addExport(exportName) {
+    if (!this.exports.includes(exportName)) {
+      this.exports.push(exportName);
+    }
+  }
+
+  /**
+   * Add internal reference
+   * @param {string} reference - Reference name
+   */
+  addInternalReference(reference) {
+    if (!this.internalReferences.includes(reference)) {
+      this.internalReferences.push(reference);
+    }
+  }
+
+  /**
+   * Add external reference
+   * @param {string} reference - Reference name
+   */
+  addExternalReference(reference) {
+    if (!this.externalReferences.includes(reference)) {
+      this.externalReferences.push(reference);
+    }
+  }
+
+  /**
+   * Set extractable flag
+   * @param {boolean} extractable - Whether boundary is extractable
+   */
+  setExtractable(extractable) {
+    this.metadata.extractable = extractable;
+  }
+
+  /**
+   * Set confidence score
+   * @param {number} confidence - Confidence score (0-1)
+   */
+  setConfidence(confidence) {
+    this.metadata.confidence = Math.min(1.0, Math.max(0.0, confidence));
+  }
+
+  /**
+   * Check if boundary is extractable
+   * @returns {boolean} Whether boundary is extractable
+   */
+  isExtractable() {
+    return this.metadata.extractable;
+  }
+
+  /**
+   * Get boundary summary
+   * @returns {Object} Boundary summary
+   */
+  getSummary() {
+    return {
+      id: this.id,
+      type: this.type,
+      name: this.name,
+      lineCount: this.lineCount,
+      cohesion: this.cohesion,
+      complexity: this.complexity,
+      dependencies: this.dependencies.length,
+      exports: this.exports.length,
+      extractable: this.isExtractable(),
+      confidence: this.metadata.confidence
+    };
+  }
+
+  /**
+   * Validate boundary data
+   * @returns {Object} Validation result
+   */
+  validate() {
+    const errors = [];
+    
+    if (!this.type || !Object.values(BOUNDARY_TYPES).includes(this.type)) {
+      errors.push('Invalid boundary type');
+    }
+    
+    if (!this.name || !this.name.trim()) {
+      errors.push('Boundary name is required');
+    }
+    
+    if (this.startLine < 1) {
+      errors.push('Start line must be positive');
+    }
+    
+    if (this.endLine < this.startLine) {
+      errors.push('End line must be after start line');
+    }
+    
+    if (this.lineCount < 1) {
+      errors.push('Boundary must contain at least one line');
+    }
+    
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Calculate boundary score for prioritization
+   * @returns {number} Boundary score
+   */
+  calculateScore() {
+    let score = 0;
+    
+    // Score from cohesion
+    const cohesionScores = {
+      [COHESION_LEVELS.HIGH]: 100,
+      [COHESION_LEVELS.MEDIUM]: 75,
+      [COHESION_LEVELS.LOW]: 50,
+      [COHESION_LEVELS.NONE]: 25
+    };
+    score += cohesionScores[this.cohesion] || 25;
+    
+    // Score from extractability
+    if (this.isExtractable()) {
+      score += 50;
+    }
+    
+    // Score from size (prefer smaller boundaries)
+    if (this.lineCount <= 50) {
+      score += 30;
+    } else if (this.lineCount <= 100) {
+      score += 20;
+    } else if (this.lineCount <= 200) {
+      score += 10;
+    }
+    
+    // Score from confidence
+    score += this.metadata.confidence * 20;
+    
+    // Deduct for high complexity
+    if (this.complexity > 50) {
+      score -= 20;
+    } else if (this.complexity > 30) {
+      score -= 10;
+    }
+    
+    return Math.max(0, Math.min(100, score));
+  }
+
+  /**
+   * Convert to JSON
+   * @returns {Object} Boundary as JSON object
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      type: this.type,
+      name: this.name,
+      startLine: this.startLine,
+      endLine: this.endLine,
+      filePath: this.filePath,
+      lineCount: this.lineCount,
+      cohesion: this.cohesion,
+      complexity: this.complexity,
+      dependencies: this.dependencies,
+      exports: this.exports,
+      internalReferences: this.internalReferences,
+      externalReferences: this.externalReferences,
+      metadata: this.metadata
+    };
+  }
+}
+
+/**
+ * Boundary collection class
+ */
+class BoundaryCollection {
+  constructor() {
+    this.boundaries = new Map();
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      filePath: null,
+      totalBoundaries: 0,
+      extractableBoundaries: 0
+    };
+  }
+
+  /**
+   * Add boundary to collection
+   * @param {ModuleBoundary} boundary - Boundary to add
+   */
+  addBoundary(boundary) {
+    if (boundary.validate().isValid) {
+      this.boundaries.set(boundary.id, boundary);
+      this.updateMetadata();
+    }
+  }
+
+  /**
+   * Get boundary by ID
+   * @param {string} id - Boundary ID
+   * @returns {ModuleBoundary|null} Boundary or null
+   */
+  getBoundary(id) {
+    return this.boundaries.get(id) || null;
+  }
+
+  /**
+   * Get all boundaries
+   * @returns {Array} Array of boundaries
+   */
+  getAllBoundaries() {
+    return Array.from(this.boundaries.values());
+  }
+
+  /**
+   * Get boundaries by type
+   * @param {string} type - Boundary type
+   * @returns {Array} Array of boundaries
+   */
+  getBoundariesByType(type) {
+    return this.getAllBoundaries().filter(b => b.type === type);
+  }
+
+  /**
+   * Get extractable boundaries
+   * @returns {Array} Array of extractable boundaries
+   */
+  getExtractableBoundaries() {
+    return this.getAllBoundaries().filter(b => b.isExtractable());
+  }
+
+  /**
+   * Get boundaries sorted by score
+   * @returns {Array} Sorted boundaries
+   */
+  getBoundariesByScore() {
+    return this.getAllBoundaries()
+      .sort((a, b) => b.calculateScore() - a.calculateScore());
+  }
+
+  /**
+   * Update collection metadata
+   */
+  updateMetadata() {
+    this.metadata.totalBoundaries = this.boundaries.size;
+    this.metadata.extractableBoundaries = this.getExtractableBoundaries().length;
+  }
+
+  /**
+   * Get collection summary
+   * @returns {Object} Collection summary
+   */
+  getSummary() {
+    const boundaries = this.getAllBoundaries();
+    const extractable = this.getExtractableBoundaries();
+    
+    return {
+      totalBoundaries: boundaries.length,
+      extractableBoundaries: extractable.length,
+      averageComplexity: boundaries.length > 0 
+        ? Math.round(boundaries.reduce((sum, b) => sum + b.complexity, 0) / boundaries.length)
+        : 0,
+      averageCohesion: this.calculateAverageCohesion(),
+      boundaryTypes: this.getBoundaryTypeDistribution(),
+      extractablePercentage: boundaries.length > 0 
+        ? Math.round((extractable.length / boundaries.length) * 100)
+        : 0
+    };
+  }
+
+  /**
+   * Calculate average cohesion
+   * @returns {string} Average cohesion level
+   */
+  calculateAverageCohesion() {
+    const boundaries = this.getAllBoundaries();
+    if (boundaries.length === 0) return COHESION_LEVELS.NONE;
+    
+    const cohesionValues = {
+      [COHESION_LEVELS.HIGH]: 4,
+      [COHESION_LEVELS.MEDIUM]: 3,
+      [COHESION_LEVELS.LOW]: 2,
+      [COHESION_LEVELS.NONE]: 1
+    };
+    
+    const totalScore = boundaries.reduce((sum, b) => {
+      return sum + (cohesionValues[b.cohesion] || 1);
+    }, 0);
+    
+    const average = totalScore / boundaries.length;
+    
+    if (average >= 3.5) return COHESION_LEVELS.HIGH;
+    if (average >= 2.5) return COHESION_LEVELS.MEDIUM;
+    if (average >= 1.5) return COHESION_LEVELS.LOW;
+    return COHESION_LEVELS.NONE;
+  }
+
+  /**
+   * Get boundary type distribution
+   * @returns {Object} Type distribution
+   */
+  getBoundaryTypeDistribution() {
+    const distribution = {};
+    
+    for (const type of Object.values(BOUNDARY_TYPES)) {
+      distribution[type] = this.getBoundariesByType(type).length;
+    }
+    
+    return distribution;
+  }
+}
+
+module.exports = {
+  BOUNDARY_TYPES,
+  COHESION_LEVELS,
+  ModuleBoundary,
+  BoundaryCollection
+};