agentsqripts/cli/problem-scope.js

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

#!/usr/bin/env node

/**
 * @file Comprehensive problem scope analyzer orchestrating multi-dimensional code analysis
 * @description Single responsibility: Provide unified CLI for complete codebase problem assessment
 * 
 * This master CLI tool serves as the comprehensive analysis orchestrator for the AgentSqripts
 * platform, combining all analysis types (complexity, security, performance, WET code, etc.)
 * into unified problem scope identification. It provides AI agents and developers with
 * complete visibility into codebase health, technical debt, and optimization opportunities
 * through coordinated multi-analyzer execution and consolidated reporting.
 * 
 * Design rationale:
 * - Unified analysis interface eliminates need to run multiple tools separately
 * - Comprehensive scope assessment enables holistic code quality understanding
 * - Severity-based filtering focuses attention on most critical issues across all domains
 * - Quick mode option provides rapid assessment for time-constrained scenarios
 * - Consolidated reporting enables cross-cutting issue identification and prioritization
 * - Export capabilities support integration with project management and CI/CD workflows
 */

const path = require('path');
const fs = require('fs');
const { parseCommandLineArgs, showUsage } = require('./lib/commandLineParser');
const { outputResults } = require('./lib/outputFormatter');
const { 
  runDependencyAnalysis, 
  runComplexityAnalysis, 
  runSecurityAnalysis, 
  runDebtAnalysis,
  runRefactoringAnalysis,
  runSRPAnalysis,
  runCleanupAnalysis
} = require('./lib/analysisRunner');
const { generateComprehensiveSummary } = require('./lib/scopeAssessmentGenerator');
const { exportReport } = require('./lib/reportExporter');
// Individual analysis functions for direct access if needed
// const { analyzeSRPViolations } = require('../lib/srp-violations/analyzeSRPViolations');
// const { analyzeProjectCleanup } = require('../lib/cleanup/analyzeCleanup');
// Removed qerrors dependency for qtests compatibility
// const qerrors = require('qerrors');

async function main() {
  const { getProcessArgs } = require('../lib/utils/processHelpers');
  const args = getProcessArgs();
  
  if (args.includes('--help') || args.length === 0) {
    showUsage();
    process.exit(0);
  }

  try {
    // Parse command line arguments
    const { options, projectPath: parsedPath } = parseCommandLineArgs(args);
    const projectPath = path.resolve(parsedPath);
    
    // Determine which analyses to run
    const analysisTypes = options.analysis.includes('all') ? 
      ['dependencies', 'complexity', 'security', 'debt', 'srp', 'comments', 'cleanup', 'refactoring'] : 
      options.analysis;

    console.log(`🔍 Problem Scope Analysis for: ${projectPath}`);
    console.log(`📊 Analysis Types: ${analysisTypes.join(', ')}`);
    console.log(`⚠️  Minimum Severity: ${options.severity}`);
    console.log(`⚡ Quick Mode: ${options.quick ? 'Yes' : 'No'}\n`);

    const startTime = Date.now();
    const results = {
      metadata: {
        projectPath,
        analysisTypes,
        severity: options.severity,
        quickMode: options.quick,
        timestamp: new Date().toISOString(),
        executionTime: 0
      },
      summary: {
        overallRiskLevel: 'LOW',
        totalIssues: 0,
        criticalIssues: 0,
        recommendationsCount: 0,
        scopeAssessment: {}
      },
      analyses: {}
    };

    // Run analyses
    await runAnalyses(projectPath, analysisTypes, options, results);
    
    // Calculate execution time
    results.metadata.executionTime = Date.now() - startTime;
    
    // Generate comprehensive summary
    generateComprehensiveSummary(results);

    // Output results
    outputResults(results, options.outputFormat);

    // Export report if requested
    if (options.exportReport) {
      await exportReport(results, options.exportReport);
    }

    // Set exit code based on overall risk
    const hasHighRisk = results.summary.overallRiskLevel === 'HIGH' || 
                       results.summary.overallRiskLevel === 'CRITICAL';
    process.exit(hasHighRisk ? 1 : 0);

  } catch (error) {
    qerrors.default(error, 'CLI problem scope analysis failed', { args });
    console.error(`❌ Error: ${error.message}`);
    process.exit(1);
  }
}

async function runAnalyses(projectPath, analysisTypes, options, results) {
  const promises = [];

  if (analysisTypes.includes('dependencies')) {
    promises.push(runDependencyAnalysis(projectPath, options, results));
  }

  if (analysisTypes.includes('complexity')) {
    promises.push(runComplexityAnalysis(projectPath, options, results));
  }

  if (analysisTypes.includes('security')) {
    promises.push(runSecurityAnalysis(projectPath, options, results));
  }

  if (analysisTypes.includes('debt')) {
    promises.push(runDebtAnalysis(projectPath, options, results));
  }

  if (analysisTypes.includes('srp')) {
    promises.push(runSRPAnalysis(projectPath, options, results));
  }

  if (analysisTypes.includes('cleanup')) {
    promises.push(runCleanupAnalysis(projectPath, options, results));
  }

  if (analysisTypes.includes('refactoring')) {
    promises.push(runRefactoringAnalysis(projectPath, options, results));
  }

  await Promise.all(promises);
}

if (require.main === module) {
  main();
}

// Main orchestration completed, all functions moved to separate modules

if (require.main === module) {
  main().catch(error => { console.error("Fatal error:", error); process.exit(1); });
}

module.exports = { main };