agentsqripts/lib/frontend-backend/projectIntegrationAnalyzer.js

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

/**
 * @file Project-wide frontend-backend integration analyzer for comprehensive API mismatch detection
 * @description Single responsibility: Orchestrate comprehensive integration analysis across entire projects
 * 
 * This analyzer performs systematic frontend-backend integration analysis across entire projects,
 * identifying API endpoint mismatches, unused routes, missing endpoints, and communication
 * problems that could cause runtime failures. It provides comprehensive integration assessment
 * with quantitative scoring and strategic recommendations for improving API consistency.
 * 
 * Design rationale:
 * - Project-wide analysis identifies systematic integration patterns missed by file-level analysis
 * - Multi-framework support covers diverse technology stacks (Express, React, Vue, Angular)
 * - Comprehensive detection covers unused endpoints, missing routes, and method mismatches
 * - Issue prioritization helps teams focus on highest-impact integration improvements
 * - Quantitative scoring enables tracking of integration quality improvements over time
 * 
 * Integration analysis scope:
 * - Backend endpoint extraction from Express, NestJS, FastAPI, Django frameworks
 * - Frontend API call detection from Fetch, Axios, jQuery, XMLHttpRequest patterns
 * - Cross-layer route matching with intelligent normalization for different naming conventions
 * - CORS configuration analysis for browser security compliance
 * - Method mismatch detection (GET/POST/PUT/DELETE inconsistencies)
 */

const path = require('path');

// Import from atomic modules
const { extractBackendEndpoints } = require('./backendEndpointExtractor');
const { extractFrontendCalls } = require('./frontendCallExtractor');
const { detectUnusedEndpoints } = require('./unusedEndpointDetector');
const { detectMissingEndpoints } = require('./missingEndpointDetector');
const { detectMethodMismatches } = require('./methodMismatchDetector');
const { detectCorsIssues } = require('./corsIssueDetector');
const { getIntegrationGrade } = require('./integrationGrader');
const { generateIntegrationRecommendations } = require('./integrationRecommendationGenerator');
const { getAllFiles } = require('./fileScanner');
const { FRONTEND_EXTENSIONS, BACKEND_EXTENSIONS } = require('../../config/localVars');

/**
 * Analyzes frontend-backend integration for a project
 * @param {string} projectPath - Path to the project
 * @param {Object} options - Analysis options
 * @returns {Object} Integration analysis results
 */
function analyzeProjectIntegration(projectPath, options = {}) {
  const {
    frontendDir = path.join(projectPath, 'frontend'),
    backendDir = path.join(projectPath, 'backend'),
    frontendExtensions = FRONTEND_EXTENSIONS,
    backendExtensions = BACKEND_EXTENSIONS,
    excludePatterns = ['node_modules', '.git', 'dist', 'build', 'coverage']
  } = options;
  
  const startTime = Date.now();
  
  // Get all frontend and backend files
  const frontendFiles = getAllFiles(frontendDir, frontendExtensions, excludePatterns);
  const backendFiles = getAllFiles(backendDir, backendExtensions, excludePatterns);
  
  // Extract endpoints and calls
  const backendEndpoints = extractBackendEndpoints(backendFiles);
  const frontendCalls = extractFrontendCalls(frontendFiles);
  
  // Run all integration checks
  const issues = [];
  issues.push(...detectUnusedEndpoints(backendEndpoints, frontendCalls));
  issues.push(...detectMissingEndpoints(backendEndpoints, frontendCalls));
  issues.push(...detectMethodMismatches(backendEndpoints, frontendCalls));
  issues.push(...detectCorsIssues(frontendCalls));
  
  // Calculate integration quality score (0-100, higher is better)
  let integrationScore = 100;
  let totalEffort = 0;
  
  issues.forEach(issue => {
    switch (issue.severity) {
      case 'HIGH': 
        integrationScore -= 25; 
        totalEffort += issue.effort || 3;
        break;
      case 'MEDIUM': 
        integrationScore -= 15; 
        totalEffort += issue.effort || 2;
        break;
      case 'LOW': 
        integrationScore -= 5; 
        totalEffort += issue.effort || 1;
        break;
    }
  });
  integrationScore = Math.max(0, integrationScore);
  
  // Calculate category and severity breakdown
  const categoryBreakdown = {};
  const severityBreakdown = { HIGH: 0, MEDIUM: 0, LOW: 0 };
  
  issues.forEach(issue => {
    categoryBreakdown[issue.category] = (categoryBreakdown[issue.category] || 0) + 1;
    severityBreakdown[issue.severity] = (severityBreakdown[issue.severity] || 0) + 1;
  });
  
  const analysisTime = Date.now() - startTime;
  
  return {
    timestamp: new Date().toISOString(),
    summary: {
      frontendFiles: frontendFiles.length,
      backendFiles: backendFiles.length,
      frontendCalls: frontendCalls.length,
      backendEndpoints: backendEndpoints.length,
      totalIssues: issues.length,
      totalEffort: totalEffort,
      integrationScore: integrationScore,
      integrationGrade: getIntegrationGrade(integrationScore),
      severityBreakdown,
      categoryBreakdown
    },
    endpoints: backendEndpoints,
    calls: frontendCalls,
    issues,
    recommendations: generateIntegrationRecommendations(issues, totalEffort, backendEndpoints.length, frontendCalls.length),
    analysisTime
  };
}

module.exports = {
  analyzeProjectIntegration
};