analyze-coverage

Test Coverage Analysis with Gap Detection

Runs test coverage suite, compares against baseline, flags untested critical paths, and generates specific test suggestions for uncovered code. Supports Jest, pytest, Go, and Rust test frameworks.

Usage

/analyze-coverage [--update-baseline] [--pr] [--changed-only] [--min <percent>] [--format json|markdown]

• --update-baseline: Save current coverage as new baseline for comparison
• --pr: Post results as GitHub PR comment
• --changed-only: Only analyze files changed in current branch
• --min <percent>: Fail if coverage below threshold (default: 50)
• --format: Output format (markdown, json, text)

Workflow

Phase 1: Framework Detection

Automatically detects test framework and coverage tooling.

import { execSync } from "child_process";
import * as fs from "fs";
import * as path from "path";

class CoverageAnalyzer {
  constructor() {
    this.framework = null;
    this.coverageTool = null;
    this.config = null;
    this.reportPath = null;
  }

  detectFramework() {
    // Check package.json for test scripts and dependencies
    let packageJson = {};
    try {
      const pkg = fs.readFileSync("package.json", "utf-8");
      packageJson = JSON.parse(pkg);
    } catch (err) {
      console.log("ℹ No package.json found; checking for other frameworks");
    }

    // Jest detection
    if (packageJson.devDependencies?.jest || fs.existsSync("jest.config.js")) {
      this.framework = "jest";
      this.coverageTool = "jest";
      this.reportPath = "coverage/coverage-final.json";
      return this;
    }

    // Check for pytest (Python)
    if (fs.existsSync("pyproject.toml") || fs.existsSync("setup.cfg")) {
      try {
        execSync("python -m pytest --version", { stdio: "pipe" });
        this.framework = "pytest";
        this.coverageTool = "pytest-cov";
        this.reportPath = ".coverage";
        return this;
      } catch (err) {
        console.log("ℹ pytest not found");
      }
    }

    // Go coverage detection
    if (fs.existsSync("go.mod")) {
      this.framework = "go";
      this.coverageTool = "go test";
      this.reportPath = "coverage.out";
      return this;
    }

    // Rust coverage detection
    if (fs.existsSync("Cargo.toml")) {
      this.framework = "rust";
      this.coverageTool = "cargo tarpaulin";
      this.reportPath = "cobertura.xml";
      return this;
    }

    throw new Error("Could not detect test framework. Supported: Jest, pytest, Go, Rust");
  }

  loadBaselineIfExists() {
    const baselinePath = ".coverage-baseline.json";
    try {
      const baseline = JSON.parse(fs.readFileSync(baselinePath, "utf-8"));
      console.log(`✓ Loaded baseline coverage: ${baseline.summary.lines.pct}%`);
      return baseline;
    } catch (err) {
      console.log("ℹ No baseline found; creating fresh baseline");
      return null;
    }
  }
}

const analyzer = new CoverageAnalyzer();
analyzer.detectFramework();
const baseline = analyzer.loadBaselineIfExists();

console.log(`✓ Detected framework: ${analyzer.framework}`);
console.log(`✓ Coverage tool: ${analyzer.coverageTool}`);