vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/models/file-analysis.js

@@ -0,0 +1,681 @@
+/**
+ * File Analysis Data Model
+ * 
+ * Comprehensive data model for file analysis results.
+ * Provides structure for storing and accessing file analysis data.
+ */
+
+const path = require('path');
+
+/**
+ * File analysis class
+ */
+class FileAnalysis {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.relativePath = path.relative(process.cwd(), filePath);
+    this.basename = path.basename(filePath);
+    this.extension = path.extname(filePath);
+    this.directory = path.dirname(filePath);
+    this.package = this.extractPackage();
+    
+    // Size metrics
+    this.lineCount = 0;
+    this.codeLines = 0;
+    this.commentLines = 0;
+    this.blankLines = 0;
+    this.fileSize = 0;
+    
+    // Complexity metrics
+    this.complexity = 'unknown';
+    this.cyclomaticComplexity = 0;
+    this.nestingDepth = 0;
+    this.functionCount = 0;
+    this.classCount = 0;
+    
+    // Dependencies
+    this.imports = [];
+    this.exports = [];
+    this.dependencyCount = 0;
+    this.dependents = [];
+    
+    // Structure
+    this.boundaries = null;
+    this.functions = [];
+    this.classes = [];
+    this.utilities = [];
+    
+    // Classification
+    this.category = 'unknown';
+    this.priority = 'unknown';
+    this.riskLevel = 'unknown';
+    this.needsRefactoring = false;
+    this.urgentRefactoring = false;
+    
+    // Metadata
+    this.isTestFile = false;
+    this.isConfigFile = false;
+    this.isGeneratedFile = false;
+    this.lastModified = null;
+    this.createdAt = null;
+    
+    // Analysis metadata
+    this.analyzedAt = new Date().toISOString();
+    this.analysisVersion = '1.0.0';
+    this.errors = [];
+    this.warnings = [];
+  }
+
+  /**
+   * Extract package from file path
+   */
+  extractPackage() {
+    const match = this.filePath.match(/packages\/([^\/]+)/);
+    return match ? match[1] : 'root';
+  }
+
+  /**
+   * Set line count metrics
+   */
+  setLineCountMetrics(total, code, comment, blank) {
+    this.lineCount = total;
+    this.codeLines = code;
+    this.commentLines = comment;
+    this.blankLines = blank;
+  }
+
+  /**
+   * Set complexity metrics
+   */
+  setComplexityMetrics(complexity, cyclomatic, nesting, functions, classes) {
+    this.complexity = complexity;
+    this.cyclomaticComplexity = cyclomatic;
+    this.nestingDepth = nesting;
+    this.functionCount = functions;
+    this.classCount = classes;
+  }
+
+  /**
+   * Add import
+   */
+  addImport(importPath, isRelative = false) {
+    this.imports.push({
+      path: importPath,
+      isRelative,
+      addedAt: new Date().toISOString()
+    });
+    this.dependencyCount = this.imports.length;
+  }
+
+  /**
+   * Add export
+   */
+  addExport(exportName, type = 'default') {
+    this.exports.push({
+      name: exportName,
+      type,
+      addedAt: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Add dependent file
+   */
+  addDependent(dependentPath) {
+    if (!this.dependents.includes(dependentPath)) {
+      this.dependents.push(dependentPath);
+    }
+  }
+
+  /**
+   * Set boundaries analysis
+   */
+  setBoundaries(boundaries) {
+    this.boundaries = boundaries;
+    
+    // Extract functions and classes from boundaries
+    if (boundaries.boundaries) {
+      this.functions = boundaries.boundaries
+        .filter(b => b.type === 'function')
+        .map(b => ({
+          name: b.name,
+          startLine: b.startLine,
+          endLine: b.endLine,
+          lineCount: b.lineCount,
+          complexity: b.complexity || 0
+        }));
+      
+      this.classes = boundaries.boundaries
+        .filter(b => b.type === 'class')
+        .map(b => ({
+          name: b.name,
+          startLine: b.startLine,
+          endLine: b.endLine,
+          lineCount: b.lineCount,
+          complexity: b.complexity || 0
+        }));
+      
+      this.utilities = boundaries.boundaries
+        .filter(b => b.type === 'utility')
+        .map(b => ({
+          name: b.name,
+          startLine: b.startLine,
+          endLine: b.endLine,
+          lineCount: b.lineCount
+        }));
+    }
+  }
+
+  /**
+   * Set classification
+   */
+  setClassification(category, priority, riskLevel, needsRefactoring, urgentRefactoring) {
+    this.category = category;
+    this.priority = priority;
+    this.riskLevel = riskLevel;
+    this.needsRefactoring = needsRefactoring;
+    this.urgentRefactoring = urgentRefactoring;
+  }
+
+  /**
+   * Set file type flags
+   */
+  setFileTypeFlags(isTest, isConfig, isGenerated) {
+    this.isTestFile = isTest;
+    this.isConfigFile = isConfig;
+    this.isGeneratedFile = isGenerated;
+  }
+
+  /**
+   * Set file timestamps
+   */
+  setTimestamps(lastModified, createdAt) {
+    this.lastModified = lastModified;
+    this.createdAt = createdAt;
+  }
+
+  /**
+   * Add error
+   */
+  addError(message, details = null) {
+    this.errors.push({
+      message,
+      details,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Add warning
+   */
+  addWarning(message, details = null) {
+    this.warnings.push({
+      message,
+      details,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Get size category
+   */
+  getSizeCategory() {
+    if (this.lineCount <= 100) return 'tiny';
+    if (this.lineCount <= 300) return 'small';
+    if (this.lineCount <= 555) return 'medium';
+    if (this.lineCount <= 800) return 'large';
+    return 'xlarge';
+  }
+
+  /**
+   * Get complexity score (0-100)
+   */
+  getComplexityScore() {
+    let score = 0;
+    
+    // Line count contribution (0-30 points)
+    if (this.lineCount > 1000) score += 30;
+    else if (this.lineCount > 555) score += 25;
+    else if (this.lineCount > 300) score += 15;
+    else if (this.lineCount > 100) score += 5;
+    
+    // Function count contribution (0-20 points)
+    if (this.functionCount > 20) score += 20;
+    else if (this.functionCount > 10) score += 15;
+    else if (this.functionCount > 5) score += 10;
+    else if (this.functionCount > 2) score += 5;
+    
+    // Class count contribution (0-15 points)
+    if (this.classCount > 5) score += 15;
+    else if (this.classCount > 3) score += 10;
+    else if (this.classCount > 1) score += 5;
+    
+    // Dependency count contribution (0-20 points)
+    if (this.dependencyCount > 20) score += 20;
+    else if (this.dependencyCount > 10) score += 15;
+    else if (this.dependencyCount > 5) score += 10;
+    else if (this.dependencyCount > 2) score += 5;
+    
+    // Nesting depth contribution (0-15 points)
+    if (this.nestingDepth > 8) score += 15;
+    else if (this.nestingDepth > 5) score += 10;
+    else if (this.nestingDepth > 3) score += 5;
+    
+    return Math.min(score, 100);
+  }
+
+  /**
+   * Get refactoring difficulty
+   */
+  getRefactoringDifficulty() {
+    const complexityScore = this.getComplexityScore();
+    
+    if (complexityScore >= 80) return 'very_difficult';
+    if (complexityScore >= 60) return 'difficult';
+    if (complexityScore >= 40) return 'moderate';
+    if (complexityScore >= 20) return 'easy';
+    return 'very_easy';
+  }
+
+  /**
+   * Get largest functions
+   */
+  getLargestFunctions(count = 5) {
+    return this.functions
+      .sort((a, b) => b.lineCount - a.lineCount)
+      .slice(0, count);
+  }
+
+  /**
+   * Get largest classes
+   */
+  getLargestClasses(count = 5) {
+    return this.classes
+      .sort((a, b) => b.lineCount - a.lineCount)
+      .slice(0, count);
+  }
+
+  /**
+   * Get functions that could be extracted
+   */
+  getExtractableFunctions(minSize = 20) {
+    return this.functions.filter(f => 
+      f.lineCount >= minSize && 
+      f.name !== '' && 
+      !f.name.startsWith('_') // Skip private functions
+    );
+  }
+
+  /**
+   * Get classes that could be extracted
+   */
+  getExtractableClasses(minSize = 50) {
+    return this.classes.filter(c => 
+      c.lineCount >= minSize && 
+      c.name !== ''
+    );
+  }
+
+  /**
+   * Check if file exceeds size limit
+   */
+  exceedsSizeLimit(limit = 555) {
+    return this.lineCount > limit;
+  }
+
+  /**
+   * Check if file approaches size limit
+   */
+  approachesSizeLimit(limit = 555, threshold = 0.9) {
+    return this.lineCount > (limit * threshold) && this.lineCount <= limit;
+  }
+
+  /**
+   * Get summary object
+   */
+  getSummary() {
+    return {
+      filePath: this.filePath,
+      relativePath: this.relativePath,
+      package: this.package,
+      lineCount: this.lineCount,
+      category: this.getSizeCategory(),
+      priority: this.priority,
+      needsRefactoring: this.needsRefactoring,
+      urgentRefactoring: this.urgentRefactoring,
+      complexity: this.complexity,
+      complexityScore: this.getComplexityScore(),
+      functionCount: this.functionCount,
+      classCount: this.classCount,
+      dependencyCount: this.dependencyCount,
+      errors: this.errors.length,
+      warnings: this.warnings.length
+    };
+  }
+
+  /**
+   * Convert to JSON
+   */
+  toJSON() {
+    return {
+      // Basic info
+      filePath: this.filePath,
+      relativePath: this.relativePath,
+      basename: this.basename,
+      extension: this.extension,
+      directory: this.directory,
+      package: this.package,
+      
+      // Size metrics
+      lineCount: this.lineCount,
+      codeLines: this.codeLines,
+      commentLines: this.commentLines,
+      blankLines: this.blankLines,
+      fileSize: this.fileSize,
+      
+      // Complexity metrics
+      complexity: this.complexity,
+      cyclomaticComplexity: this.cyclomaticComplexity,
+      nestingDepth: this.nestingDepth,
+      functionCount: this.functionCount,
+      classCount: this.classCount,
+      
+      // Dependencies
+      imports: this.imports,
+      exports: this.exports,
+      dependencyCount: this.dependencyCount,
+      dependents: this.dependents,
+      
+      // Structure
+      functions: this.functions,
+      classes: this.classes,
+      utilities: this.utilities,
+      
+      // Classification
+      category: this.category,
+      priority: this.priority,
+      riskLevel: this.riskLevel,
+      needsRefactoring: this.needsRefactoring,
+      urgentRefactoring: this.urgentRefactoring,
+      
+      // Metadata
+      isTestFile: this.isTestFile,
+      isConfigFile: this.isConfigFile,
+      isGeneratedFile: this.isGeneratedFile,
+      lastModified: this.lastModified,
+      createdAt: this.createdAt,
+      
+      // Analysis metadata
+      analyzedAt: this.analyzedAt,
+      analysisVersion: this.analysisVersion,
+      errors: this.errors,
+      warnings: this.warnings,
+      
+      // Computed metrics
+      complexityScore: this.getComplexityScore(),
+      refactoringDifficulty: this.getRefactoringDifficulty(),
+      sizeCategory: this.getSizeCategory()
+    };
+  }
+
+  /**
+   * Create from JSON
+   */
+  static fromJSON(data) {
+    const analysis = new FileAnalysis(data.filePath);
+    
+    // Restore all properties
+    Object.assign(analysis, data);
+    
+    return analysis;
+  }
+
+  /**
+   * Validate analysis data
+   */
+  validate() {
+    const issues = [];
+    
+    // Check required fields
+    if (!this.filePath) {
+      issues.push('Missing file path');
+    }
+    
+    if (this.lineCount < 0) {
+      issues.push('Invalid line count');
+    }
+    
+    if (this.functionCount < 0) {
+      issues.push('Invalid function count');
+    }
+    
+    if (this.classCount < 0) {
+      issues.push('Invalid class count');
+    }
+    
+    // Check logical consistency
+    if (this.codeLines + this.commentLines + this.blankLines !== this.lineCount) {
+      issues.push('Line count metrics are inconsistent');
+    }
+    
+    if (this.imports.length !== this.dependencyCount) {
+      issues.push('Dependency count is inconsistent with imports');
+    }
+    
+    return {
+      isValid: issues.length === 0,
+      issues
+    };
+  }
+}
+
+/**
+ * File analysis collection class
+ */
+class FileAnalysisCollection {
+  constructor() {
+    this.analyses = new Map();
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      version: '1.0.0',
+      totalFiles: 0,
+      totalLines: 0
+    };
+  }
+
+  /**
+   * Add file analysis
+   */
+  add(analysis) {
+    if (!(analysis instanceof FileAnalysis)) {
+      throw new Error('Analysis must be a FileAnalysis instance');
+    }
+    
+    this.analyses.set(analysis.filePath, analysis);
+    this.updateMetadata();
+  }
+
+  /**
+   * Get file analysis
+   */
+  get(filePath) {
+    return this.analyses.get(filePath);
+  }
+
+  /**
+   * Remove file analysis
+   */
+  remove(filePath) {
+    const removed = this.analyses.delete(filePath);
+    if (removed) {
+      this.updateMetadata();
+    }
+    return removed;
+  }
+
+  /**
+   * Get all analyses
+   */
+  getAll() {
+    return Array.from(this.analyses.values());
+  }
+
+  /**
+   * Get analyses by package
+   */
+  getByPackage(packageName) {
+    return this.getAll().filter(analysis => analysis.package === packageName);
+  }
+
+  /**
+   * Get analyses needing refactoring
+   */
+  getNeedingRefactoring() {
+    return this.getAll().filter(analysis => analysis.needsRefactoring);
+  }
+
+  /**
+   * Get urgent refactoring candidates
+   */
+  getUrgentRefactoring() {
+    return this.getAll().filter(analysis => analysis.urgentRefactoring);
+  }
+
+  /**
+   * Get files exceeding size limit
+   */
+  getExceedingLimit(limit = 555) {
+    return this.getAll().filter(analysis => analysis.exceedsSizeLimit(limit));
+  }
+
+  /**
+   * Get files approaching size limit
+   */
+  getApproachingLimit(limit = 555, threshold = 0.9) {
+    return this.getAll().filter(analysis => analysis.approachesSizeLimit(limit, threshold));
+  }
+
+  /**
+   * Get largest files
+   */
+  getLargestFiles(count = 10) {
+    return this.getAll()
+      .sort((a, b) => b.lineCount - a.lineCount)
+      .slice(0, count);
+  }
+
+  /**
+   * Get most complex files
+   */
+  getMostComplexFiles(count = 10) {
+    return this.getAll()
+      .sort((a, b) => b.getComplexityScore() - a.getComplexityScore())
+      .slice(0, count);
+  }
+
+  /**
+   * Get summary statistics
+   */
+  getSummary() {
+    const analyses = this.getAll();
+    
+    const summary = {
+      totalFiles: analyses.length,
+      totalLines: analyses.reduce((sum, a) => sum + a.lineCount, 0),
+      totalCodeLines: analyses.reduce((sum, a) => sum + a.codeLines, 0),
+      totalCommentLines: analyses.reduce((sum, a) => sum + a.commentLines, 0),
+      totalBlankLines: analyses.reduce((sum, a) => sum + a.blankLines, 0),
+      averageLines: 0,
+      largestFile: null,
+      smallestFile: null,
+      needsRefactoring: analyses.filter(a => a.needsRefactoring).length,
+      urgentRefactoring: analyses.filter(a => a.urgentRefactoring).length,
+      byPackage: {},
+      byCategory: {},
+      byPriority: {},
+      errors: 0,
+      warnings: 0
+    };
+
+    // Calculate averages
+    summary.averageLines = summary.totalFiles > 0 ? 
+      Math.round(summary.totalLines / summary.totalFiles) : 0;
+
+    // Find largest and smallest
+    summary.largestFile = analyses.reduce((largest, a) => 
+      a.lineCount > (largest?.lineCount || 0) ? a : largest, null);
+    summary.smallestFile = analyses.reduce((smallest, a) => 
+      a.lineCount < (smallest?.lineCount || Infinity) ? a : smallest, null);
+
+    // Group by package
+    for (const analysis of analyses) {
+      if (!summary.byPackage[analysis.package]) {
+        summary.byPackage[analysis.package] = 0;
+      }
+      summary.byPackage[analysis.package]++;
+    }
+
+    // Group by category
+    for (const analysis of analyses) {
+      const category = analysis.getSizeCategory();
+      if (!summary.byCategory[category]) {
+        summary.byCategory[category] = 0;
+      }
+      summary.byCategory[category]++;
+    }
+
+    // Group by priority
+    for (const analysis of analyses) {
+      if (!summary.byPriority[analysis.priority]) {
+        summary.byPriority[analysis.priority] = 0;
+      }
+      summary.byPriority[analysis.priority]++;
+    }
+
+    // Count errors and warnings
+    summary.errors = analyses.reduce((sum, a) => sum + a.errors.length, 0);
+    summary.warnings = analyses.reduce((sum, a) => sum + a.warnings.length, 0);
+
+    return summary;
+  }
+
+  /**
+   * Update metadata
+   */
+  updateMetadata() {
+    const analyses = this.getAll();
+    this.metadata.totalFiles = analyses.length;
+    this.metadata.totalLines = analyses.reduce((sum, a) => sum + a.lineCount, 0);
+  }
+
+  /**
+   * Convert to JSON
+   */
+  toJSON() {
+    return {
+      metadata: this.metadata,
+      analyses: this.getAll().map(a => a.toJSON())
+    };
+  }
+
+  /**
+   * Create from JSON
+   */
+  static fromJSON(data) {
+    const collection = new FileAnalysisCollection();
+    
+    for (const analysisData of data.analyses) {
+      const analysis = FileAnalysis.fromJSON(analysisData);
+      collection.add(analysis);
+    }
+    
+    collection.metadata = { ...collection.metadata, ...data.metadata };
+    
+    return collection;
+  }
+}
+
+module.exports = {
+  FileAnalysis,
+  FileAnalysisCollection
+};