jest-test-lineage-reporter 2.0.2 → 2.1.0

package/src/gc-pressure-example.ts

@@ -0,0 +1,158 @@
+// Examples demonstrating GC pressure and how to fix it
+
+// BAD: Creates many small objects (causes GC pressure)
+export function badGCPressureFunction(count: number): number {
+  let total = 0;
+  
+  for (let i = 0; i < count; i++) {
+    // Creating new objects in a loop - BAD for GC
+    const tempObj = {
+      id: i,
+      value: Math.random(),
+      timestamp: Date.now(),
+      processed: false
+    };
+    
+    // More object creation
+    const result = {
+      input: tempObj,
+      output: tempObj.value * 2,
+      metadata: {
+        created: new Date(),
+        index: i
+      }
+    };
+    
+    total += result.output;
+  }
+  
+  return total;
+}
+
+// GOOD: Reuses objects (reduces GC pressure)
+export function goodGCPressureFunction(count: number): number {
+  let total = 0;
+  
+  // Reuse objects instead of creating new ones
+  const reusableObj = {
+    id: 0,
+    value: 0,
+    timestamp: 0,
+    processed: false
+  };
+  
+  const reusableResult = {
+    input: reusableObj,
+    output: 0,
+    metadata: {
+      created: new Date(),
+      index: 0
+    }
+  };
+  
+  for (let i = 0; i < count; i++) {
+    // Reuse existing objects - GOOD for GC
+    reusableObj.id = i;
+    reusableObj.value = Math.random();
+    reusableObj.timestamp = Date.now();
+    reusableObj.processed = false;
+    
+    reusableResult.output = reusableObj.value * 2;
+    reusableResult.metadata.index = i;
+    
+    total += reusableResult.output;
+  }
+  
+  return total;
+}
+
+// BAD: String concatenation in loop (creates many temporary strings)
+export function badStringConcatenation(items: string[]): string {
+  let result = '';
+  
+  for (const item of items) {
+    // Each += creates a new string object - BAD for GC
+    result += item + ', ';
+  }
+  
+  return result;
+}
+
+// GOOD: Use array join (single allocation)
+export function goodStringConcatenation(items: string[]): string {
+  // Single allocation - GOOD for GC
+  return items.join(', ');
+}
+
+// BAD: Array operations that create many intermediate arrays
+export function badArrayOperations(numbers: number[]): number[] {
+  return numbers
+    .map(x => x * 2)        // Creates new array
+    .filter(x => x > 10)    // Creates another new array
+    .map(x => x + 1)        // Creates another new array
+    .filter(x => x % 2 === 0); // Creates final array
+}
+
+// GOOD: Single pass with reduce (one allocation)
+export function goodArrayOperations(numbers: number[]): number[] {
+  return numbers.reduce((acc: number[], x: number) => {
+    const doubled = x * 2;
+    if (doubled > 10) {
+      const incremented = doubled + 1;
+      if (incremented % 2 === 0) {
+        acc.push(incremented);
+      }
+    }
+    return acc;
+  }, []);
+}
+
+// Object pool pattern for heavy reuse
+class ObjectPool<T> {
+  private pool: T[] = [];
+  private createFn: () => T;
+  private resetFn: (obj: T) => void;
+  
+  constructor(createFn: () => T, resetFn: (obj: T) => void, initialSize: number = 10) {
+    this.createFn = createFn;
+    this.resetFn = resetFn;
+    
+    // Pre-allocate objects
+    for (let i = 0; i < initialSize; i++) {
+      this.pool.push(this.createFn());
+    }
+  }
+  
+  acquire(): T {
+    return this.pool.pop() || this.createFn();
+  }
+  
+  release(obj: T): void {
+    this.resetFn(obj);
+    this.pool.push(obj);
+  }
+}
+
+// Example using object pool
+export function objectPoolExample(count: number): number {
+  const pool = new ObjectPool(
+    () => ({ id: 0, value: 0, result: 0 }),
+    (obj) => { obj.id = 0; obj.value = 0; obj.result = 0; },
+    50
+  );
+  
+  let total = 0;
+  
+  for (let i = 0; i < count; i++) {
+    const obj = pool.acquire();
+    obj.id = i;
+    obj.value = Math.random();
+    obj.result = obj.value * 2;
+    
+    total += obj.result;
+    
+    pool.release(obj); // Return to pool for reuse
+  }
+  
+  return total;
+}

package/src/global.d.ts

@@ -0,0 +1,7 @@
+declare global {
+  var __TRACK_LINE_EXECUTION__: ((filePath: string, lineNumber: number) => void) | undefined;
+  var __GET_LINEAGE_RESULTS__: (() => any) | undefined;
+  var __TEST_LINEAGE_TRACKER__: any;
+}
+
+export {};

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;
+  }
+}