jest-test-lineage-reporter 2.0.1 → 2.1.0

package/src/depth-example.ts

@@ -0,0 +1,66 @@
+// Example file to demonstrate call depth tracking
+
+export function directFunction(x: number): number {
+  return x * 2; // This will be depth 1 when called directly from tests
+}
+export function oneLevel(x: number): number {
+  return directFunction(x) + 1; // directFunction will be depth 2 here
+}
+export function twoLevels(x: number): number {
+  return oneLevel(x) + 1; // directFunction will be depth 3 here
+}
+export function threeLevels(x: number): number {
+  return twoLevels(x) + 1; // directFunction will be depth 4 here
+}
+
+// Complex function that calls multiple other functions
+export function complexFunction(x: number): number {
+  const a = directFunction(x); // depth 2
+  const b = oneLevel(x); // directFunction will be depth 3 here
+  const c = twoLevels(x); // directFunction will be depth 4 here
+  return a + b + c;
+}
+
+// Recursive function to test deep call stacks
+export function recursiveFunction(n: number, depth: number = 0): number {
+  if (depth >= 3) {
+    return directFunction(n); // This will be very deep
+  }
+  return recursiveFunction(n, depth + 1) + 1;
+}
+
+// Global array to hold leaked memory - this will cause actual memory leaks
+const memoryLeakStorage: any[] = [];
+export function memoryLeakFunction(size: number): number {
+  // Create large objects and store them globally (this leaks memory!)
+  const largeObject = {
+    id: Date.now(),
+    data: new Array(size).fill(0).map((_, i) => ({
+      index: i,
+      value: Math.random(),
+      timestamp: new Date(),
+      largeString: 'x'.repeat(1000),
+      // 1KB string per item
+      metadata: {
+        created: Date.now(),
+        processed: false,
+        tags: ['memory', 'leak', 'test', 'large'],
+        history: new Array(100).fill(0).map(() => Math.random())
+      }
+    }))
+  };
+
+  // Store in global array - this prevents garbage collection (memory leak!)
+  memoryLeakStorage.push(largeObject);
+
+  // Also call our tracked function
+  return directFunction(size);
+}
+export function clearMemoryLeaks(): number {
+  const count = memoryLeakStorage.length;
+  memoryLeakStorage.length = 0; // Clear the array
+  return count;
+}
+export function getMemoryLeakCount(): number {
+  return memoryLeakStorage.length;
+}

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