jest-test-lineage-reporter 2.0.2 → 2.1.1

package/src/mcp/server.js

@@ -0,0 +1,469 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Server for Jest Test Lineage Reporter
+ * Exposes test analytics functionality via Model Context Protocol
+ */
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+
+const { runJest } = require('../cli/utils/jest-runner');
+const { loadLineageData, processLineageDataForMutation } = require('../cli/utils/data-loader');
+const { loadFullConfig } = require('../cli/utils/config-loader');
+const MutationTester = require('../MutationTester');
+const TestCoverageReporter = require('../TestCoverageReporter');
+
+// Create MCP server
+const server = new Server(
+  {
+    name: 'jest-test-lineage-reporter',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Define available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'run_tests',
+        description: 'Run Jest tests with lineage tracking and generate coverage data',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            args: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Jest command-line arguments (e.g., ["--watch", "--testPathPattern=calculator"])',
+              default: [],
+            },
+            enableLineage: {
+              type: 'boolean',
+              description: 'Enable lineage tracking',
+              default: true,
+            },
+            enablePerformance: {
+              type: 'boolean',
+              description: 'Enable performance tracking',
+              default: true,
+            },
+            enableQuality: {
+              type: 'boolean',
+              description: 'Enable quality analysis',
+              default: true,
+            },
+          },
+        },
+      },
+      {
+        name: 'run_mutation_testing',
+        description: 'Run mutation testing on existing lineage data to assess test effectiveness',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            dataPath: {
+              type: 'string',
+              description: 'Path to lineage data file',
+              default: '.jest-lineage-data.json',
+            },
+            threshold: {
+              type: 'number',
+              description: 'Minimum mutation score threshold (0-100)',
+              default: 80,
+            },
+            timeout: {
+              type: 'number',
+              description: 'Timeout per mutation in milliseconds',
+              default: 5000,
+            },
+            debug: {
+              type: 'boolean',
+              description: 'Create debug mutation files instead of running tests',
+              default: false,
+            },
+          },
+        },
+      },
+      {
+        name: 'generate_report',
+        description: 'Generate HTML report from existing lineage data',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            dataPath: {
+              type: 'string',
+              description: 'Path to lineage data file',
+              default: '.jest-lineage-data.json',
+            },
+            outputPath: {
+              type: 'string',
+              description: 'Output HTML file path',
+              default: 'test-lineage-report.html',
+            },
+          },
+        },
+      },
+      {
+        name: 'query_coverage',
+        description: 'Query which tests cover specific files or lines',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file: {
+              type: 'string',
+              description: 'File path to query (e.g., "src/calculator.ts")',
+            },
+            line: {
+              type: 'number',
+              description: 'Optional line number to query',
+            },
+            dataPath: {
+              type: 'string',
+              description: 'Path to lineage data file',
+              default: '.jest-lineage-data.json',
+            },
+          },
+          required: ['file'],
+        },
+      },
+      {
+        name: 'analyze_full',
+        description: 'Run full workflow: tests, mutation testing, and generate report',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            skipTests: {
+              type: 'boolean',
+              description: 'Skip running tests (use existing data)',
+              default: false,
+            },
+            skipMutation: {
+              type: 'boolean',
+              description: 'Skip mutation testing',
+              default: false,
+            },
+            threshold: {
+              type: 'number',
+              description: 'Mutation score threshold',
+              default: 80,
+            },
+            outputPath: {
+              type: 'string',
+              description: 'Output HTML file path',
+              default: 'test-lineage-report.html',
+            },
+          },
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'run_tests': {
+        const result = await runJest({
+          args: args.args || [],
+          enableLineage: args.enableLineage !== false,
+          enablePerformance: args.enablePerformance !== false,
+          enableQuality: args.enableQuality !== false,
+          quiet: false,
+        });
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                success: result.success,
+                exitCode: result.exitCode,
+                message: result.success
+                  ? 'Tests completed successfully. Lineage data saved to .jest-lineage-data.json'
+                  : `Tests failed with exit code ${result.exitCode}`,
+              }, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'run_mutation_testing': {
+        const config = loadFullConfig({
+          threshold: args.threshold,
+          timeout: args.timeout,
+          debug: args.debug,
+        });
+
+        const rawData = loadLineageData(args.dataPath || '.jest-lineage-data.json');
+        const lineageData = processLineageDataForMutation(rawData);
+
+        const mutationTester = new MutationTester(config);
+        mutationTester.setLineageData(lineageData);
+
+        const results = await mutationTester.runMutationTesting();
+
+        await mutationTester.cleanup();
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                mutationScore: results.mutationScore,
+                totalMutations: results.totalMutations,
+                killedMutations: results.killedMutations,
+                survivedMutations: results.survivedMutations,
+                timeoutMutations: results.timeoutMutations || 0,
+                errorMutations: results.errorMutations || 0,
+                meetsThreshold: results.mutationScore >= (args.threshold || 80),
+                message: `Mutation testing complete. Score: ${results.mutationScore.toFixed(1)}%`,
+              }, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'generate_report': {
+        const rawData = loadLineageData(args.dataPath || '.jest-lineage-data.json');
+        const lineageData = processLineageDataForMutation(rawData);
+
+        const reporter = new TestCoverageReporter(
+          { rootDir: process.cwd() },
+          { outputFile: args.outputPath || 'test-lineage-report.html' }
+        );
+
+        reporter.processLineageResults(lineageData, 'unknown');
+        await reporter.generateHtmlReport();
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                outputPath: args.outputPath || 'test-lineage-report.html',
+                message: 'HTML report generated successfully',
+              }, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'query_coverage': {
+        const rawData = loadLineageData(args.dataPath || '.jest-lineage-data.json');
+        const lineageData = processLineageDataForMutation(rawData);
+
+        const path = require('path');
+        const normalizedFile = path.normalize(args.file);
+
+        const matchingFiles = Object.keys(lineageData).filter(f =>
+          f.includes(normalizedFile) || normalizedFile.includes(path.basename(f))
+        );
+
+        if (matchingFiles.length === 0) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  success: false,
+                  error: `No coverage data found for file: ${args.file}`,
+                }, null, 2),
+              },
+            ],
+          };
+        }
+
+        const targetFile = matchingFiles[0];
+        const fileCoverage = lineageData[targetFile];
+
+        if (args.line) {
+          const lineNumber = args.line.toString();
+          if (!fileCoverage[lineNumber]) {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: JSON.stringify({
+                    success: false,
+                    error: `No coverage data for line ${args.line} in ${args.file}`,
+                  }, null, 2),
+                },
+              ],
+            };
+          }
+
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  success: true,
+                  file: targetFile,
+                  line: lineNumber,
+                  tests: fileCoverage[lineNumber],
+                }, null, 2),
+              },
+            ],
+          };
+        } else {
+          const lines = Object.keys(fileCoverage);
+          const totalTests = new Set(
+            lines.flatMap(lineNum => fileCoverage[lineNum].map(t => t.testName))
+          ).size;
+
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  success: true,
+                  file: targetFile,
+                  linesCovered: lines.length,
+                  totalTests,
+                  coverageByLine: fileCoverage,
+                }, null, 2),
+              },
+            ],
+          };
+        }
+      }
+
+      case 'analyze_full': {
+        const results = {
+          steps: [],
+        };
+
+        // Step 1: Run tests
+        if (!args.skipTests) {
+          const testResult = await runJest({
+            args: [],
+            enableLineage: true,
+            enablePerformance: true,
+            enableQuality: true,
+            quiet: false,
+          });
+
+          results.steps.push({
+            step: 'tests',
+            success: testResult.success,
+            exitCode: testResult.exitCode,
+          });
+
+          if (!testResult.success) {
+            results.success = false;
+            results.message = 'Tests failed';
+            return {
+              content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+            };
+          }
+        }
+
+        // Step 2: Mutation testing
+        if (!args.skipMutation) {
+          try {
+            const config = loadFullConfig({ threshold: args.threshold });
+            const rawData = loadLineageData('.jest-lineage-data.json');
+            const lineageData = processLineageDataForMutation(rawData);
+
+            const mutationTester = new MutationTester(config);
+            mutationTester.setLineageData(lineageData);
+
+            const mutationResults = await mutationTester.runMutationTesting();
+            await mutationTester.cleanup();
+
+            results.steps.push({
+              step: 'mutation',
+              success: mutationResults.mutationScore >= (args.threshold || 80),
+              mutationScore: mutationResults.mutationScore,
+            });
+          } catch (err) {
+            results.steps.push({
+              step: 'mutation',
+              success: false,
+              error: err.message,
+            });
+          }
+        }
+
+        // Step 3: Generate report
+        try {
+          const rawData = loadLineageData('.jest-lineage-data.json');
+          const lineageData = processLineageDataForMutation(rawData);
+
+          const reporter = new TestCoverageReporter(
+            { rootDir: process.cwd() },
+            { outputFile: args.outputPath || 'test-lineage-report.html' }
+          );
+
+          reporter.processLineageResults(lineageData, 'unknown');
+          await reporter.generateHtmlReport();
+
+          results.steps.push({
+            step: 'report',
+            success: true,
+            outputPath: args.outputPath || 'test-lineage-report.html',
+          });
+        } catch (err) {
+          results.steps.push({
+            step: 'report',
+            success: false,
+            error: err.message,
+          });
+        }
+
+        results.success = results.steps.every(s => s.success);
+        results.message = results.success
+          ? 'Full analysis completed successfully'
+          : 'Some steps failed';
+
+        return {
+          content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error.message,
+            stack: error.stack,
+          }, null, 2),
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('Jest Test Lineage Reporter MCP server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Server error:', error);
+  process.exit(1);
+});

package/src/performance-example.ts

@@ -0,0 +1,82 @@
+// Example file to demonstrate CPU cycle and performance tracking
+
+export function lightweightFunction(x: number): number {
+  return x + 1; // Very fast operation - minimal CPU cycles
+}
+
+export function mediumFunction(x: number): number {
+  let result = x;
+  let i = 0;
+  while (i < 100) { // Medium CPU usage
+    result = Math.sqrt(result + i);
+    i++;
+  }
+  return result;
+}
+
+export function heavyFunction(x: number): number {
+  let result = x;
+  let i = 0;
+  while (i < 1000) { // Heavy CPU usage - many cycles (reduced for testing)
+    result = Math.sin(Math.cos(Math.sqrt(result + i)));
+    i++;
+  }
+  return result;
+}
+
+export function memoryIntensiveFunction(size: number): number[] {
+  const array = new Array(size); // Memory allocation
+  let i = 0;
+  while (i < size) {
+    array[i] = Math.random() * i; // Memory writes
+    i++;
+  }
+  return array;
+}
+
+export function recursiveFunction(n: number): number {
+  if (n <= 1) {
+    return lightweightFunction(n); // Light operation at leaf
+  }
+  if (n > 5) return n; // Prevent exponential explosion
+  return recursiveFunction(n - 1) + recursiveFunction(n - 2); // Limited recursion
+}
+
+export function nestedCallsFunction(x: number): number {
+  const light = lightweightFunction(x);     // Depth 2
+  const medium = mediumFunction(light);     // Depth 2  
+  const heavy = heavyFunction(medium);      // Depth 2
+  return heavy;
+}
+
+export function mixedPerformanceFunction(iterations: number): number {
+  let result = 0;
+  let i = 0;
+
+  while (i < iterations) {
+    if (i % 3 === 0) {
+      result += lightweightFunction(i);     // Fast path
+    } else if (i % 3 === 1) {
+      result += mediumFunction(i);          // Medium path
+    } else {
+      result += heavyFunction(i);           // Slow path
+    }
+    i++;
+  }
+
+  return result;
+}
+
+// Function that demonstrates different performance characteristics
+export function performanceVariableFunction(mode: 'fast' | 'medium' | 'slow'): number {
+  switch (mode) {
+    case 'fast':
+      return lightweightFunction(42);
+    case 'medium':
+      return mediumFunction(42);
+    case 'slow':
+      return heavyFunction(42);
+    default:
+      return 0;
+  }
+}

package/src/quality-example.ts

@@ -0,0 +1,79 @@
+// Example file to demonstrate test quality metrics
+
+export function simpleFunction(x: number): number {
+  return x * 2;
+}
+
+export function complexFunction(data: any): any {
+  if (data === null || data === undefined) {
+    throw new Error('Data is required');
+  }
+  
+  if (typeof data === 'string') {
+    return data.toUpperCase();
+  } else if (typeof data === 'number') {
+    if (data < 0) {
+      return Math.abs(data);
+    } else if (data === 0) {
+      return 1;
+    } else {
+      return data * data;
+    }
+  } else if (Array.isArray(data)) {
+    return data.map(item => item * 2);
+  } else {
+    return JSON.stringify(data);
+  }
+}
+
+export async function asyncFunction(delay: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    if (delay < 0) {
+      reject(new Error('Delay cannot be negative'));
+    } else {
+      setTimeout(() => {
+        resolve(`Completed after ${delay}ms`);
+      }, delay);
+    }
+  });
+}
+
+export function errorProneFunction(input: any): string {
+  // This function has potential issues
+  return input.toString().toUpperCase();
+}
+
+export function wellTestedFunction(a: number, b: number): number {
+  if (a === null || a === undefined) {
+    throw new Error('Parameter a is required');
+  }
+  if (b === null || b === undefined) {
+    throw new Error('Parameter b is required');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new Error('Both parameters must be numbers');
+  }
+  if (a < 0 || b < 0) {
+    throw new Error('Parameters must be non-negative');
+  }
+  
+  return a + b;
+}
+
+export class Calculator {
+  private history: number[] = [];
+  
+  add(a: number, b: number): number {
+    const result = a + b;
+    this.history.push(result);
+    return result;
+  }
+  
+  getHistory(): number[] {
+    return [...this.history];
+  }
+  
+  clearHistory(): void {
+    this.history = [];
+  }
+}

package/src/survived-mutations-example.ts

@@ -0,0 +1,19 @@
+// This file contains functions with absolutely terrible tests that guarantee survived mutations
+
+export function demonstrateSurvivedMutations(input: number): number {
+  if (input === 42) {
+    return 100;
+  } else if (input > 50) {
+    return input * 2;
+  } else {
+    return input + 10;
+  }
+}
+
+export function anotherWeakFunction(x: number, y: number): boolean {
+  if (x > y) {
+    return true;
+  } else {
+    return false;
+  }
+}

package/src/truly-weak-example.ts

@@ -0,0 +1,37 @@
+// This file contains functions with absolutely terrible tests that guarantee survived mutations
+
+export function definitelyWillSurvive(x: number): number {
+  if (!(!(x === 5))) {
+    return 42;
+  } else if (x > 10) {
+    return x + 100;
+  } else {
+    return x * 2;
+  }
+}
+export function anotherSurvivor(a: number, b: number): number {
+  const sum = a + b;
+  if (sum > 50) {
+    return sum - 10;
+  } else {
+    return sum / 2;
+  }
+}
+export function booleanSurvivor(x: number): boolean {
+  if (x > 0) {
+    return true;
+  } else {
+    return false;
+  }
+}
+export function guaranteedSurvivor(input: number): number {
+  if (input === 10) {
+    const result = 100;
+    return result;
+  } else if (input === 20) {
+    const result = 200;
+    return result;
+  } else {
+    return input + 5;
+  }
+}