agentsqripts/lib/scalability/scalabilityProjectAnalyzer.js

Comprehensive static code analysis toolkit for identifying technical debt, security vulnerabilities, performance issues, and code quality problems

/**
 * @file Project-wide scalability analyzer for comprehensive performance assessment
 * @description Single responsibility: Coordinate scalability analysis across entire projects with optimized processing
 * 
 * This analyzer orchestrates comprehensive scalability analysis across entire projects,
 * efficiently processing large codebases to identify systematic performance bottlenecks,
 * architectural scalability issues, and optimization opportunities. It provides project-level
 * metrics, issue aggregation, and strategic recommendations for scalability improvements.
 * 
 * Design rationale:
 * - Project-wide analysis identifies systematic scalability patterns missed by file-level analysis
 * - Optimized file processing with intelligent filtering prevents analysis of irrelevant files
 * - Scalable architecture handles large codebases efficiently through batched processing
 * - Comprehensive metrics provide project-wide scalability visibility and improvement tracking
 * - Strategic recommendations prioritize optimization efforts for maximum performance impact
 * 
 * Analysis optimization strategy:
 * - Early file filtering by extension and size reduces unnecessary processing overhead
 * - Configurable exclusion patterns prevent analysis of build artifacts and dependencies
 * - Issue aggregation provides project-wide bottleneck identification and hotspot analysis
 * - Scalability scoring enables project-wide performance quality tracking and measurement
 * - Directory traversal optimization handles complex project structures efficiently
 */

const fs = require('fs');
const path = require('path');
const { analyzeFileScalability } = require('./scalabilityFileAnalyzer');
const { calculateScalabilityScore, getScalabilityGrade } = require('./scalabilityScoreCalculator');
const { generateScalabilityRecommendations } = require('./scalabilityRecommendationGenerator');
const { getAllFiles } = require('../utils/directoryScanner');
const localVars = require('../../config/localVars');

/**
 * Analyzes project scalability across multiple files
 * @param {string} projectPath - Path to the project
 * @param {Object} options - Analysis options
 * @returns {Object} Project scalability analysis results
 */
async function analyzeProjectScalability(projectPath, options = {}) {
  const {
    extensions = localVars.VALID_EXTENSIONS,
    excludePatterns = ['node_modules', '.git', 'dist', 'build', 'coverage'],
    maxFiles = Infinity  // Analyze all files by default
  } = options;
  
  const startTime = Date.now();
  
  // Get all relevant files
  const allFiles = await getAllFiles(projectPath, extensions, excludePatterns);
  const files = allFiles.slice(0, maxFiles);
  
  // Analyze each file
  const fileResults = [];
  const allIssues = [];
  
  for (const filePath of files) {
    try {
      const result = await analyzeFileScalability(filePath);
      fileResults.push(result);
      allIssues.push(...result.issues);
    } catch (error) {
      console.warn(`Warning: Could not analyze ${filePath}: ${error.message}`);
    }
  }
  
  // Calculate project-wide metrics using simple cumulative scoring
  const totalIssues = allIssues.length;
  const projectScore = calculateScalabilityScore(allIssues);
  const projectGrade = getScalabilityGrade(projectScore);
  
  // Calculate breakdowns
  const categoryBreakdown = {};
  const severityBreakdown = { HIGH: 0, MEDIUM: 0, LOW: 0 };
  
  allIssues.forEach(issue => {
    categoryBreakdown[issue.category] = (categoryBreakdown[issue.category] || 0) + 1;
    severityBreakdown[issue.severity] = (severityBreakdown[issue.severity] || 0) + 1;
  });
  
  // Generate recommendations
  const analysisTime = Date.now() - startTime;
  const recommendations = generateScalabilityRecommendations(allIssues, files.length);
  
  return {
    timestamp: new Date().toISOString(),
    summary: {
      totalFiles: files.length,
      filesAnalyzed: files.length,
      totalIssues,
      scalabilityScore: projectScore,
      projectScore,
      projectGrade,
      categoryBreakdown,
      severityBreakdown
    },
    files: fileResults,
    issues: allIssues,
    recommendations,
    analysisTime
  };
}



module.exports = {
  analyzeProjectScalability
};