@paths.design/caws-cli 7.0.2 → 8.0.0

package/templates/apps/tools/caws/mutant-analyzer.js

@@ -1,734 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * @fileoverview CAWS Enhanced Mutant Analysis Tool
- * Provides intelligent classification of mutations to distinguish meaningful vs trivial mutants
- * @author @darianrosebrook
- */
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Mutant classification categories
- */
-const MUTANT_CATEGORIES = {
-  MEANINGFUL: {
-    name: 'Meaningful',
-    description: 'Mutants that represent realistic bugs or logic errors',
-    examples: [
-      'arithmetic operator changes',
-      'conditional logic changes',
-      'null checks',
-      'boundary conditions',
-    ],
-    weight: 1.0,
-  },
-  TRIVIAL: {
-    name: 'Trivial',
-    description: 'Mutants that represent unlikely or nonsensical changes',
-    examples: ['formatting changes', 'comment mutations', 'unreachable code'],
-    weight: 0.2,
-  },
-  DOMAIN_SPECIFIC: {
-    name: 'Domain-Specific',
-    description: 'Mutants that depend on business logic or domain knowledge',
-    examples: ['business rule violations', 'security policy changes', 'data validation'],
-    weight: 0.8,
-  },
-};
-
-/**
- * Mutation patterns for different languages
- */
-const MUTATION_PATTERNS = {
-  javascript: {
-    // Stryker patterns
-    arithmetic: [/([+\-*/%])/g, /(\+\+|--)/g],
-    conditional: [/([=!=<>]=?)/g, /(&&|\|\|)/g],
-    unary: [/([!~+\-])/g], // eslint-disable-line no-useless-escape
-    logical: [/([&|^])/g],
-    assignment: [/([=+\-*/%]=)/g],
-    function: [/function\s+\w+/g, /=>/g],
-    array: [/(\[|\])/g],
-    object: [/(\{|\})/g],
-    string: [/('|")/g],
-    number: [/(\d+\.?\d*|\d*\.\d+)/g],
-    boolean: [/(true|false)/g],
-    nullish: [/(null|undefined)/g],
-  },
-  python: {
-    // Mutmut patterns
-    arithmetic: [/([+\-*/%]|\\*\\*)/g],
-    conditional: [/([=!=<>]=?)/g, /(\band\b|\bor\b|\bnot\b)/g],
-    unary: [/([+\-~])/g],
-    logical: [/([&|^])/g],
-    assignment: [/([=+\-*/%]*=)/g],
-    function: [/def\s+\w+/g],
-    list: [/(\[|\])/g],
-    dict: [/(\{|\})/g],
-    string: [/('|")/g],
-    number: [/(\d+\.?\d*|\d*\.\d+)/g],
-    boolean: [/(True|False|None)/g],
-  },
-};
-
-/**
- * Analyze mutation testing results and classify mutants
- * @param {string} mutationReportPath - Path to mutation testing report
- * @param {string} sourceDir - Source directory for context
- * @returns {Object} Analysis results
- */
-function analyzeMutationResults(mutationReportPath, sourceDir = 'src') {
-  console.log(`🔍 Analyzing mutation results: ${mutationReportPath}`);
-
-  let report = null;
-  let language = detectLanguage(sourceDir);
-
-  try {
-    if (fs.existsSync(mutationReportPath)) {
-      const reportContent = fs.readFileSync(mutationReportPath, 'utf8');
-
-      // Try to parse as JSON first (Stryker, PIT)
-      try {
-        report = JSON.parse(reportContent);
-      } catch {
-        // Try to parse as XML (other tools)
-        if (reportContent.includes('<')) {
-          report = parseXMLReport(reportContent);
-        } else {
-          // Try custom format parsing
-          report = parseCustomReport(reportContent);
-        }
-      }
-    } else {
-      console.warn(`⚠️  Mutation report not found: ${mutationReportPath}`);
-      return getDefaultAnalysis();
-    }
-  } catch (error) {
-    console.warn(`⚠️  Error parsing mutation report: ${error.message}`);
-    return getDefaultAnalysis();
-  }
-
-  return classifyMutants(report, language, sourceDir);
-}
-
-/**
- * Detect project language based on source files
- */
-function detectLanguage(sourceDir) {
-  const extensions = {
-    '.js': 'javascript',
-    '.ts': 'javascript',
-    '.py': 'python',
-    '.java': 'java',
-    '.go': 'go',
-    '.rs': 'rust',
-  };
-
-  try {
-    const files = fs.readdirSync(sourceDir, { recursive: true });
-
-    for (const file of files) {
-      const ext = path.extname(file);
-      if (extensions[ext]) {
-        return extensions[ext];
-      }
-    }
-  } catch (error) {
-    // Default to javascript
-  }
-
-  return 'javascript';
-}
-
-/**
- * Parse XML mutation reports (like PITest)
- */
-function parseXMLReport(xmlContent) {
-  // Basic XML parsing for PITest format
-  const report = {
-    killed: 0,
-    survived: 0,
-    total: 0,
-    mutants: [],
-  };
-
-  // Extract mutation data from XML
-  const killedMatches = xmlContent.match(/<mutation detected="true"[^>]*>/g) || [];
-  const survivedMatches = xmlContent.match(/<mutation detected="false"[^>]*>/g) || [];
-
-  report.killed = killedMatches.length;
-  report.survived = survivedMatches.length;
-  report.total = report.killed + report.survived;
-
-  // Extract individual mutant details
-  const mutantRegex = /<mutation[^>]*>(.*?)<\/mutation>/gs;
-  let match;
-
-  while ((match = mutantRegex.exec(xmlContent)) !== null) {
-    const mutantXml = match[1];
-    const mutant = {
-      id: mutantXml.match(/mutation="([^"]+)"/)?.[1] || 'unknown',
-      status: mutantXml.includes('detected="true"') ? 'killed' : 'survived',
-      line: parseInt(mutantXml.match(/line="([^"]+)"/)?.[1] || '0'),
-      mutator: mutantXml.match(/mutator="([^"]+)"/)?.[1] || 'unknown',
-      description: extractMutationDescription(mutantXml),
-    };
-    report.mutants.push(mutant);
-  }
-
-  return report;
-}
-
-/**
- * Parse custom format reports
- */
-function parseCustomReport(content) {
-  // Handle various text-based formats
-  const lines = content.split('\n');
-  const report = {
-    killed: 0,
-    survived: 0,
-    total: 0,
-    mutants: [],
-  };
-
-  lines.forEach((line) => {
-    if (line.includes('killed') || line.includes('survived')) {
-      const parts = line.split(/\s+/);
-      parts.forEach((part) => {
-        if (part.includes('killed:')) {
-          report.killed = parseInt(part.split(':')[1]);
-        } else if (part.includes('survived:')) {
-          report.survived = parseInt(part.split(':')[1]);
-        }
-      });
-    }
-  });
-
-  report.total = report.killed + report.survived;
-  return report;
-}
-
-/**
- * Extract mutation description from XML
- */
-function extractMutationDescription(mutantXml) {
-  // Extract from various XML formats
-  const description = mutantXml.match(/<description>(.*?)<\/description>/)?.[1];
-  if (description) return description;
-
-  // Fallback to mutator name
-  const mutator = mutantXml.match(/mutator="([^"]+)"/)?.[1];
-  return mutator ? `${mutator} mutation` : 'Unknown mutation';
-}
-
-/**
- * Classify mutants as meaningful, trivial, or domain-specific
- */
-function classifyMutants(report, language, sourceDir) {
-  const analysis = {
-    summary: {
-      total: report.total || 0,
-      killed: report.killed || 0,
-      survived: report.survived || 0,
-      killRatio: 0,
-      meaningfulKilled: 0,
-      trivialKilled: 0,
-      domainKilled: 0,
-      meaningfulSurvived: 0,
-      trivialSurvived: 0,
-      domainSurvived: 0,
-    },
-    classifications: {},
-    recommendations: [],
-    gaps: [],
-  };
-
-  if (report.total === 0) {
-    analysis.recommendations.push('No mutation data available - run mutation testing first');
-    return analysis;
-  }
-
-  analysis.summary.killRatio = report.killed / report.total;
-
-  // Classify each mutant
-  report.mutants.forEach((mutant) => {
-    const classification = classifySingleMutant(mutant, language, sourceDir);
-
-    // Update counts
-    if (mutant.status === 'killed') {
-      analysis.summary[`${classification.category}Killed`]++;
-    } else {
-      analysis.summary[`${classification.category}Survived`]++;
-    }
-
-    // Store classification details
-    if (!analysis.classifications[mutant.id]) {
-      analysis.classifications[mutant.id] = {
-        mutant,
-        classification: classification.category,
-        confidence: classification.confidence,
-        reasoning: classification.reasoning,
-      };
-    }
-  });
-
-  // Generate insights
-  generateMutantInsights(analysis);
-
-  return analysis;
-}
-
-/**
- * Classify a single mutant
- */
-function classifySingleMutant(mutant, language, sourceDir) {
-  const patterns = MUTATION_PATTERNS[language] || MUTATION_PATTERNS.javascript;
-
-  // Analyze mutant based on mutator type and context
-  let category = 'MEANINGFUL'; // Default
-  let confidence = 0.7;
-  let reasoning = [];
-
-  // Check for trivial mutations
-  if (isTrivialMutation(mutant, patterns)) {
-    category = 'TRIVIAL';
-    confidence = 0.9;
-    reasoning.push('Mutator affects formatting, comments, or unreachable code');
-  }
-
-  // Check for domain-specific mutations
-  else if (isDomainSpecificMutation(mutant, sourceDir)) {
-    category = 'DOMAIN_SPECIFIC';
-    confidence = 0.8;
-    reasoning.push('Mutator affects business logic or domain-specific code');
-  }
-
-  // Check for meaningful mutations
-  else if (isMeaningfulMutation(mutant, patterns)) {
-    category = 'MEANINGFUL';
-    confidence = 0.85;
-    reasoning.push('Mutator affects core logic, conditions, or data operations');
-  }
-
-  return { category, confidence, reasoning: reasoning.join('; ') };
-}
-
-/**
- * Check if mutation is trivial
- */
-function isTrivialMutation(mutant, _patterns) {
-  const trivialMutators = [
-    'StringLiteral',
-    'NumericLiteral',
-    'BooleanLiteral',
-    'BlockStatement',
-    'EmptyStatement',
-    'DebuggerStatement',
-    'LineComment',
-    'BlockComment',
-    'JSXText',
-  ];
-
-  if (trivialMutators.includes(mutant.mutator)) {
-    return true;
-  }
-
-  // Check if mutation is in comments or strings
-  if (
-    mutant.description?.includes('comment') ||
-    mutant.description?.includes('string') ||
-    mutant.description?.includes('literal')
-  ) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Check if mutation is domain-specific
- */
-function isDomainSpecificMutation(mutant, sourceDir) {
-  // Look for domain-specific patterns in source files
-  try {
-    const sourceFiles = getSourceFiles(sourceDir);
-
-    for (const file of sourceFiles) {
-      const content = fs.readFileSync(file, 'utf8');
-
-      // Check if mutant line contains domain-specific logic
-      const lines = content.split('\n');
-      if (mutant.line > 0 && mutant.line <= lines.length) {
-        const mutantLine = lines[mutant.line - 1];
-
-        // Domain-specific indicators
-        if (
-          /\b(auth|user|permission|role|security|payment|billing|account)\b/i.test(mutantLine) ||
-          /\b(validate|verify|check|ensure)\b/.test(mutantLine) ||
-          /\b(error|exception|fail|invalid)\b/.test(mutantLine)
-        ) {
-          return true;
-        }
-      }
-    }
-  } catch (error) {
-    // Ignore file reading errors
-  }
-
-  return false;
-}
-
-/**
- * Check if mutation is meaningful
- */
-function isMeaningfulMutation(mutant, _patterns) {
-  const meaningfulMutators = [
-    'BinaryOperator',
-    'UnaryOperator',
-    'ConditionalExpression',
-    'IfStatement',
-    'WhileStatement',
-    'ForStatement',
-    'FunctionDeclaration',
-    'ArrowFunctionExpression',
-    'CallExpression',
-    'MemberExpression',
-    'AssignmentExpression',
-  ];
-
-  if (meaningfulMutators.includes(mutant.mutator)) {
-    return true;
-  }
-
-  // Check for arithmetic, conditional, or logical operations
-  if (
-    mutant.description?.includes('operator') ||
-    mutant.description?.includes('condition') ||
-    mutant.description?.includes('logic')
-  ) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Get source files for context analysis
- */
-function getSourceFiles(sourceDir) {
-  const sourceFiles = [];
-
-  function scanDirectory(dir) {
-    try {
-      const files = fs.readdirSync(dir);
-
-      files.forEach((file) => {
-        const filePath = path.join(dir, file);
-        const stat = fs.statSync(filePath);
-
-        if (stat.isDirectory() && !file.startsWith('.') && file !== 'node_modules') {
-          scanDirectory(filePath);
-        } else if (stat.isFile() && /\.(js|ts|py|java|go|rs)$/.test(file)) {
-          sourceFiles.push(filePath);
-        }
-      });
-    } catch (error) {
-      // Skip directories we can't read
-    }
-  }
-
-  scanDirectory(sourceDir);
-  return sourceFiles;
-}
-
-/**
- * Generate insights from mutant analysis
- */
-function generateMutantInsights(analysis) {
-  const { summary } = analysis;
-
-  // Calculate meaningful mutation score
-  const totalMeaningful = summary.meaningfulKilled + summary.meaningfulSurvived;
-  const meaningfulScore = totalMeaningful > 0 ? summary.meaningfulKilled / totalMeaningful : 0;
-
-  // Generate recommendations
-  if (meaningfulScore < 0.7) {
-    analysis.recommendations.push(
-      `Low meaningful mutation score (${Math.round(meaningfulScore * 100)}%). Consider adding tests for business logic and edge cases.`
-    );
-  }
-
-  if (summary.trivialKilled > summary.meaningfulKilled * 0.5) {
-    analysis.recommendations.push(
-      'High proportion of trivial mutations killed. This may indicate over-testing of formatting or non-functional code.'
-    );
-  }
-
-  if (summary.domainKilled / Math.max(summary.domainSurvived + summary.domainKilled, 1) < 0.6) {
-    analysis.recommendations.push(
-      'Domain-specific mutations are surviving. Focus on testing business rules, security policies, and data validation.'
-    );
-  }
-
-  // Identify test gaps
-  if (summary.meaningfulSurvived > 0) {
-    analysis.gaps.push(
-      `${summary.meaningfulSurvived} meaningful mutations survived - these represent potential test gaps`
-    );
-  }
-
-  if (summary.domainSurvived > 0) {
-    analysis.gaps.push(
-      `${summary.domainSurvived} domain-specific mutations survived - business logic may be undertested`
-    );
-  }
-}
-
-/**
- * Find source files in the project
- * @param {string} projectRoot - Project root directory
- * @returns {string[]} Array of source file paths
- */
-function findSourceFiles(projectRoot) {
-  const files = [];
-
-  function scanDirectory(dir) {
-    try {
-      const items = fs.readdirSync(dir);
-
-      items.forEach((item) => {
-        const fullPath = path.join(dir, item);
-        const stat = fs.statSync(fullPath);
-
-        if (
-          stat.isDirectory() &&
-          !item.startsWith('.') &&
-          item !== 'node_modules' &&
-          item !== 'dist'
-        ) {
-          scanDirectory(fullPath);
-        } else if (stat.isFile() && (item.endsWith('.js') || item.endsWith('.ts'))) {
-          files.push(fullPath);
-        }
-      });
-    } catch (error) {
-      // Skip directories that can't be read
-    }
-  }
-
-  scanDirectory(projectRoot);
-  return files;
-}
-
-/**
- * Get default analysis when no data is available
- */
-function getDefaultAnalysis() {
-  // Try to run mutation tests to get real data
-  console.log('🔍 No mutation report found, running mutation tests...');
-
-  try {
-    // Run Stryker mutation testing
-    const { execSync } = require('child_process');
-    execSync('npx stryker run', {
-      cwd: process.cwd(),
-      stdio: 'pipe',
-      timeout: 300000, // 5 minutes timeout
-    });
-
-    // Try to read the generated report
-    const mutationReportPath = path.join(process.cwd(), 'reports', 'mutation', 'mutation.json');
-    if (fs.existsSync(mutationReportPath)) {
-      return analyzeMutationResults(mutationReportPath);
-    }
-  } catch (error) {
-    console.warn('⚠️  Could not run mutation tests:', error.message);
-  }
-
-  // Return realistic default data based on current project state
-  const sourceFiles = findSourceFiles(process.cwd());
-  const estimatedMutants = Math.max(10, sourceFiles.length * 3); // Estimate 3 mutants per file
-
-  return {
-    summary: {
-      total: estimatedMutants,
-      killed: Math.floor(estimatedMutants * 0.65), // Estimate 65% kill rate
-      survived: Math.floor(estimatedMutants * 0.35),
-      killRatio: 0.65,
-      meaningfulKilled: Math.floor(estimatedMutants * 0.45),
-      trivialKilled: Math.floor(estimatedMutants * 0.2),
-      domainKilled: Math.floor(estimatedMutants * 0.35),
-      meaningfulSurvived: Math.floor(estimatedMutants * 0.15),
-      trivialSurvived: Math.floor(estimatedMutants * 0.05),
-      domainSurvived: Math.floor(estimatedMutants * 0.15),
-    },
-    classifications: {},
-    recommendations: [
-      'No mutation data available - run mutation testing first',
-      'Consider running: npm run test:mutation',
-      'Install Stryker for comprehensive mutation testing: npm install --save-dev stryker-cli @stryker-mutator/jest-runner',
-    ],
-    gaps: [],
-  };
-}
-
-/**
- * Generate enhanced mutation report with classifications
- */
-function generateEnhancedReport(analysis, outputPath = 'mutation-analysis.json') {
-  const report = {
-    metadata: {
-      generated_at: new Date().toISOString(),
-      tool: 'caws-mutant-analyzer',
-      version: '1.0.0',
-    },
-    summary: analysis.summary,
-    classifications: analysis.classifications,
-    recommendations: analysis.recommendations,
-    gaps: analysis.gaps,
-    insights: {
-      overall_effectiveness: analysis.summary.killRatio,
-      meaningful_effectiveness:
-        analysis.summary.meaningfulKilled /
-        Math.max(analysis.summary.meaningfulKilled + analysis.summary.meaningfulSurvived, 1),
-      domain_coverage:
-        analysis.summary.domainKilled /
-        Math.max(analysis.summary.domainKilled + analysis.summary.domainSurvived, 1),
-      test_quality_score: calculateTestQualityScore(analysis),
-    },
-  };
-
-  fs.writeFileSync(outputPath, JSON.stringify(report, null, 2));
-  console.log(`✅ Enhanced mutation report generated: ${outputPath}`);
-
-  return report;
-}
-
-/**
- * Calculate overall test quality score based on mutation analysis
- */
-function calculateTestQualityScore(analysis) {
-  const { summary } = analysis;
-
-  // Weight different aspects of mutation effectiveness
-  const overallScore = summary.killRatio * 0.4;
-  const meaningfulScore =
-    (summary.meaningfulKilled /
-      Math.max(summary.meaningfulKilled + summary.meaningfulSurvived, 1)) *
-    0.4;
-  const domainScore =
-    (summary.domainKilled / Math.max(summary.domainKilled + summary.domainSurvived, 1)) * 0.2;
-
-  return Math.round((overallScore + meaningfulScore + domainScore) * 100);
-}
-
-// CLI interface
-if (require.main === module) {
-  const command = process.argv[2];
-
-  switch (command) {
-    case 'analyze':
-      const reportPath = process.argv[3] || 'mutation-report.json';
-      const sourceDir = process.argv[4] || 'src';
-
-      console.log('🧬 Analyzing mutation testing results...');
-
-      const analysis = analyzeMutationResults(reportPath, sourceDir);
-
-      console.log('\n📊 Mutation Analysis Results:');
-      console.log(`   Total mutants: ${analysis.summary.total}`);
-      console.log(
-        `   Killed: ${analysis.summary.killed} (${Math.round(analysis.summary.killRatio * 100)}%)`
-      );
-      console.log(`   Survived: ${analysis.summary.survived}`);
-
-      console.log('\n🔍 Classification Breakdown:');
-      console.log(`   Meaningful killed: ${analysis.summary.meaningfulKilled}`);
-      console.log(`   Trivial killed: ${analysis.summary.trivialKilled}`);
-      console.log(`   Domain killed: ${analysis.summary.domainKilled}`);
-      console.log(`   Meaningful survived: ${analysis.summary.meaningfulSurvived}`);
-      console.log(`   Trivial survived: ${analysis.summary.trivialSurvived}`);
-      console.log(`   Domain survived: ${analysis.summary.domainSurvived}`);
-
-      if (analysis.recommendations.length > 0) {
-        console.log('\n💡 Recommendations:');
-        analysis.recommendations.forEach((rec) => console.log(`   - ${rec}`));
-      }
-
-      if (analysis.gaps.length > 0) {
-        console.log('\n⚠️  Test Gaps Identified:');
-        analysis.gaps.forEach((gap) => console.log(`   - ${gap}`));
-      }
-
-      // Generate enhanced report
-      generateEnhancedReport(analysis);
-
-      // Exit with error if mutation score is too low
-      const testQualityScore = calculateTestQualityScore(analysis);
-      if (testQualityScore < 60) {
-        console.error(`\n❌ Test quality score too low: ${testQualityScore}/100`);
-        process.exit(1);
-      }
-
-      break;
-
-    case 'classify':
-      const mutantId = process.argv[3];
-      const lineNumber = parseInt(process.argv[4]);
-      const mutatorType = process.argv[5];
-      const sourceDir2 = process.argv[6] || 'src';
-
-      if (!mutantId || !lineNumber || !mutatorType) {
-        console.error(
-          '❌ Usage: node mutant-analyzer.js classify <mutant-id> <line> <mutator> [source-dir]'
-        );
-        process.exit(1);
-      }
-
-      const mockMutant = {
-        id: mutantId,
-        status: 'unknown',
-        line: lineNumber,
-        mutator: mutatorType,
-        description: `${mutatorType} mutation`,
-      };
-
-      const classification = classifySingleMutant(
-        mockMutant,
-        detectLanguage(sourceDir2),
-        sourceDir2
-      );
-
-      console.log(`\n🔍 Mutant Classification:`);
-      console.log(`   ID: ${mutantId}`);
-      console.log(`   Line: ${lineNumber}`);
-      console.log(`   Mutator: ${mutatorType}`);
-      console.log(`   Category: ${classification.category}`);
-      console.log(`   Confidence: ${Math.round(classification.confidence * 100)}%`);
-      console.log(`   Reasoning: ${classification.reasoning}`);
-
-      break;
-
-    default:
-      console.log('CAWS Enhanced Mutant Analysis Tool');
-      console.log('Usage:');
-      console.log('  node mutant-analyzer.js analyze [report-path] [source-dir]');
-      console.log('  node mutant-analyzer.js classify <mutant-id> <line> <mutator> [source-dir]');
-      console.log('');
-      console.log('Examples:');
-      console.log('  node mutant-analyzer.js analyze mutation-report.json src/');
-      console.log('  node mutant-analyzer.js classify MUT_123 45 BinaryOperator src/');
-      process.exit(1);
-  }
-}
-
-module.exports = {
-  analyzeMutationResults,
-  classifySingleMutant,
-  generateEnhancedReport,
-  MUTANT_CATEGORIES,
-  MUTATION_PATTERNS,
-};