fchek 1.0.0

package/lib/coverage.js

@@ -0,0 +1,604 @@
+'use strict';
+
+/**
+ * coverage.js — code coverage report
+ *
+ * Python (.py)     → coverage.py
+ * C/C++ (.c .cpp)  → gcov (requires gcc -fprofile-arcs -ftest-coverage)
+ * Rust             → cargo-tarpaulin (Linux) or cargo llvm-cov (cross-platform)
+ * JS/TS            → c8 / nyc (via npm test --coverage)
+ */
+
+const { spawnSync, execSync } = require('child_process');
+const path   = require('path');
+const fs     = require('fs');
+const os     = require('os');
+const { output, ok, fail } = require('./output');
+const { findPython } = require('./python');
+
+const HELP = `
+fchek coverage <file_or_dir> [--html] [--threshold=<0-100>]
+
+Show which lines are NOT covered by tests.
+
+Supported:
+  .py          → coverage.py  (pip install coverage)
+  .c / .cpp    → gcov         (apt install gcc)
+  .rs / Cargo  → cargo-tarpaulin or cargo llvm-cov
+  .js / .ts    → c8           (npm install -g c8)
+  .go / go.mod → go test -coverprofile
+
+Options:
+  --html              Also generate HTML report (saved to ./coverage_html/)
+  --threshold=80      Fail (status: error) if total coverage < N%
+
+Examples:
+  fchek coverage test_auth.py
+  fchek coverage src/main.c
+  fchek coverage .              (Rust — runs cargo tarpaulin in cwd)
+  fchek coverage tests/         (JS — runs c8 in dir)
+  fchek coverage .              (Go  — runs go test -coverprofile in cwd)
+  fchek coverage test.py --threshold=80
+`.trim();
+
+const DEFAULT_TIMEOUT = 120_000;
+
+function commandExists(cmd) {
+  try {
+    execSync(process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch { return false; }
+}
+
+// ─── Python ──────────────────────────────────────────────────────────────────
+
+function parseCoverageReport(raw) {
+  const lines = raw.split('\n');
+  const files = [];
+  let total = null;
+
+  for (const line of lines) {
+    // Format: "src/foo.py    120     8    93%   45-52, 88"
+    const m = line.match(/^(\S+\.py)\s+(\d+)\s+(\d+)\s+(\d+)%\s*([\d\s,\-]*)?$/);
+    if (m) {
+      files.push({
+        file:        m[1],
+        stmts:       parseInt(m[2]),
+        missed:      parseInt(m[3]),
+        coverage_pct: parseInt(m[4]),
+        missing_lines: (m[5] || '').trim() || null,
+      });
+    }
+    const tot = line.match(/^TOTAL\s+\d+\s+\d+\s+(\d+)%/);
+    if (tot) total = parseInt(tot[1]);
+  }
+  return { files, total };
+}
+
+function runPythonCoverage(file, html, threshold, timeoutMs) {
+  const py = findPython();
+  if (!py) return output(fail('Python not found. Install: https://python.org'));
+
+  if (!commandExists('coverage')) {
+    // Try via python -m coverage
+    const check = spawnSync(py, ['-m', 'coverage', '--version'], {
+      encoding: 'utf8', timeout: 5000, windowsHide: true,
+    });
+    if (check.status !== 0) {
+      return output(fail('coverage.py not found. Install: pip install coverage'));
+    }
+  }
+
+  const covCmd = commandExists('coverage') ? 'coverage' : null;
+  const runArgs = covCmd
+    ? ['run', '--branch', file]
+    : ['-m', 'coverage', 'run', '--branch', file];
+
+  const runner = covCmd ? 'coverage' : py;
+  const runRes = spawnSync(runner, runArgs, { encoding: 'utf8', timeout: timeoutMs });
+  if (runRes.error?.code === 'ETIMEDOUT') {
+    return output(fail(`Coverage run timed out after ${timeoutMs}ms`));
+  }
+
+  const reportArgs = covCmd
+    ? ['report', '--show-missing']
+    : ['-m', 'coverage', 'report', '--show-missing'];
+  const reportRes = spawnSync(runner, reportArgs, { encoding: 'utf8', timeout: 30_000 });
+
+  const { files, total } = parseCoverageReport(reportRes.stdout || '');
+
+  if (html) {
+    const htmlArgs = covCmd ? ['html', '-d', 'coverage_html'] : ['-m', 'coverage', 'html', '-d', 'coverage_html'];
+    spawnSync(runner, htmlArgs, { encoding: 'utf8', timeout: 30_000 });
+  }
+
+  const uncovered = files.filter(f => f.coverage_pct < 100);
+
+  if (threshold !== null && total !== null && total < threshold) {
+    return output(fail(
+      `Coverage ${total}% is below threshold ${threshold}%. Uncovered files: ${uncovered.length}`
+    ));
+  }
+
+  output(ok({
+    file,
+    lang: 'python',
+    tool: 'coverage.py',
+    total_pct: total,
+    threshold: threshold,
+    passed_threshold: threshold !== null ? (total >= threshold) : null,
+    files,
+    uncovered_files: uncovered,
+    html_report: html ? path.resolve('coverage_html/index.html') : null,
+  }));
+}
+
+// ─── C/C++ via gcov ──────────────────────────────────────────────────────────
+
+function runGcov(file, timeoutMs) {
+  if (!commandExists('gcc') && !commandExists('clang')) {
+    return output(fail('gcc not found. Install: apt install build-essential'));
+  }
+  if (!commandExists('gcov')) {
+    return output(fail('gcov not found. Install: apt install gcc'));
+  }
+
+  const ext      = path.extname(file).toLowerCase();
+  const compiler = ext === '.cpp' || ext === '.cc' ? 'g++' : 'gcc';
+  const outBin   = path.join(os.tmpdir(), `fchek_cov_${path.basename(file, ext)}`);
+
+  const compile = spawnSync(
+    compiler,
+    ['-fprofile-arcs', '-ftest-coverage', '-g', '-O0', '-o', outBin, file],
+    { encoding: 'utf8' }
+  );
+  if (compile.status !== 0) {
+    return output(fail(`Compilation failed:\n${compile.stderr}`));
+  }
+
+  const run = spawnSync(outBin, [], { encoding: 'utf8', timeout: timeoutMs });
+  if (run.error?.code === 'ETIMEDOUT') {
+    try { fs.unlinkSync(outBin); } catch {}
+    return output(fail(`Execution timed out after ${timeoutMs}ms`));
+  }
+
+  const gcovRes = spawnSync('gcov', [file], { encoding: 'utf8', cwd: process.cwd() });
+
+  // Parse gcov output file
+  const gcovFile = path.basename(file) + '.gcov';
+  let coveredLines = 0, uncoveredLines = 0;
+  const missed = [];
+
+  if (fs.existsSync(gcovFile)) {
+    const gcovLines = fs.readFileSync(gcovFile, 'utf8').split('\n');
+    for (const gl of gcovLines) {
+      const m = gl.match(/^\s*(\d+|#+):\s*(\d+):/);
+      if (!m) continue;
+      const count  = m[1];
+      const lineNo = parseInt(m[2]);
+      if (lineNo === 0) continue;
+      if (count === '#####' || count.startsWith('#')) {
+        uncoveredLines++;
+        missed.push(lineNo);
+      } else {
+        coveredLines++;
+      }
+    }
+    try { fs.unlinkSync(gcovFile); } catch {}
+  }
+
+  const total = coveredLines + uncoveredLines;
+  const pct   = total > 0 ? Math.round((coveredLines / total) * 100) : 0;
+
+  try { fs.unlinkSync(outBin); } catch {}
+  // Cleanup gcda/gcno files
+  for (const ext2 of ['.gcda', '.gcno']) {
+    try { fs.unlinkSync(path.basename(file, path.extname(file)) + ext2); } catch {}
+  }
+
+  output(ok({
+    file:          path.resolve(file),
+    lang:          'c',
+    tool:          'gcov',
+    total_pct:     pct,
+    covered_lines: coveredLines,
+    missed_lines:  uncoveredLines,
+    missed_line_numbers: missed.slice(0, 50),
+  }));
+}
+
+// ─── Rust via cargo-tarpaulin or cargo llvm-cov ───────────────────────────────
+
+function runRustCoverage(dir, html, timeoutMs) {
+  const cwd = path.resolve(dir === '.' ? process.cwd() : dir);
+
+  if (!commandExists('cargo')) {
+    return output(fail('cargo not found. Install Rust: https://rustup.rs'));
+  }
+
+  // Prefer tarpaulin (Linux only) then llvm-cov (cross-platform)
+  const hasTarpaulin = (() => {
+    const r = spawnSync('cargo', ['tarpaulin', '--version'], { encoding: 'utf8', timeout: 5000 });
+    return r.status === 0;
+  })();
+
+  const hasLlvmCov = (() => {
+    const r = spawnSync('cargo', ['llvm-cov', '--version'], { encoding: 'utf8', timeout: 5000 });
+    return r.status === 0;
+  })();
+
+  if (!hasTarpaulin && !hasLlvmCov) {
+    return output(fail(
+      'No Rust coverage tool found.\n' +
+      'Install tarpaulin (Linux): cargo install cargo-tarpaulin\n' +
+      'Install llvm-cov (all platforms): cargo install cargo-llvm-cov'
+    ));
+  }
+
+  let result;
+  let tool;
+
+  if (hasTarpaulin && process.platform === 'linux') {
+    tool = 'cargo-tarpaulin';
+    const args = html
+      ? ['tarpaulin', '--out', 'Json', '--output-dir', '/tmp/fchek_tarp', '--out', 'Html']
+      : ['tarpaulin', '--out', 'Json', '--output-dir', '/tmp/fchek_tarp'];
+    result = spawnSync('cargo', args, { encoding: 'utf8', cwd, timeout: timeoutMs });
+  } else {
+    tool = 'cargo-llvm-cov';
+    const args = html
+      ? ['llvm-cov', '--json', '--output-path', '/tmp/fchek_llvmcov.json', '--html']
+      : ['llvm-cov', '--json', '--output-path', '/tmp/fchek_llvmcov.json'];
+    result = spawnSync('cargo', args, { encoding: 'utf8', cwd, timeout: timeoutMs });
+  }
+
+  if (result.error?.code === 'ETIMEDOUT') {
+    return output(fail(`Rust coverage timed out after ${timeoutMs}ms`));
+  }
+
+  // Try to parse JSON output
+  let totalPct = null;
+  try {
+    const jsonFile = tool === 'cargo-tarpaulin'
+      ? '/tmp/fchek_tarp/tarpaulin-report.json'
+      : '/tmp/fchek_llvmcov.json';
+    if (fs.existsSync(jsonFile)) {
+      const data = JSON.parse(fs.readFileSync(jsonFile, 'utf8'));
+      // tarpaulin: { "coverage": 85.3 }
+      // llvm-cov:  { "data": [{ "totals": { "lines": { "percent": 85.3 } } }] }
+      totalPct = data.coverage
+        ?? data?.data?.[0]?.totals?.lines?.percent
+        ?? null;
+      if (totalPct) totalPct = Math.round(totalPct);
+    }
+  } catch {}
+
+  output(ok({
+    dir: cwd,
+    lang: 'rust',
+    tool,
+    total_pct: totalPct,
+    raw_output: (result.stdout || result.stderr || '').slice(0, 3000),
+    html_report: html ? path.join(cwd, 'target/llvm-cov/html/index.html') : null,
+  }));
+}
+
+// ─── C# via coverlet ─────────────────────────────────────────────────────────
+
+function runCSharpCoverage(target, html, threshold, timeoutMs) {
+  if (!commandExists('dotnet')) {
+    return output(fail('dotnet not found. Install .NET SDK: https://dotnet.microsoft.com/download'));
+  }
+
+  // Find test project (.csproj with test references)
+  let projDir = path.resolve(fs.statSync(target).isDirectory() ? target : path.dirname(target));
+  for (let i = 0; i < 6; i++) {
+    const found = fs.readdirSync(projDir).find(f => f.endsWith('.csproj') || f.endsWith('.sln'));
+    if (found) break;
+    const parent = path.dirname(projDir);
+    if (parent === projDir) { projDir = null; break; }
+    projDir = parent;
+  }
+
+  if (!projDir) {
+    return output(fail('No .csproj or .sln found.'));
+  }
+
+  const coverageDir = path.join(os.tmpdir(), 'fchek_coverage_' + Date.now());
+  fs.mkdirSync(coverageDir, { recursive: true });
+
+  const testArgs = [
+    'test', projDir,
+    '--collect', 'XPlat Code Coverage',
+    '--results-directory', coverageDir,
+    '--no-build',
+    '-v', 'quiet',
+  ];
+
+  const testRes = spawnSync('dotnet', testArgs, {
+    encoding: 'utf8', cwd: projDir, timeout: timeoutMs,
+  });
+
+  if (testRes.error?.code === 'ETIMEDOUT') {
+    return output(fail(`Coverage timed out after ${timeoutMs}ms`));
+  }
+
+  // Find coverage.cobertura.xml
+  let coberturaFile = null;
+  function findCobertura(dir) {
+    try {
+      for (const name of fs.readdirSync(dir)) {
+        const full = path.join(dir, name);
+        if (fs.statSync(full).isDirectory()) findCobertura(full);
+        else if (name === 'coverage.cobertura.xml') coberturaFile = full;
+      }
+    } catch {}
+  }
+  findCobertura(coverageDir);
+
+  let totalPct = null;
+  let fileResults = [];
+
+  if (coberturaFile) {
+    const xml = fs.readFileSync(coberturaFile, 'utf8');
+    // Parse line-rate from <coverage line-rate="0.85" ...>
+    const rateMatch = xml.match(/line-rate="([\d.]+)"/);
+    if (rateMatch) totalPct = Math.round(parseFloat(rateMatch[1]) * 100);
+
+    // Parse per-file coverage
+    const classMatches = [...xml.matchAll(/<class name="([^"]+)"[^>]*line-rate="([\d.]+)"/g)];
+    for (const m of classMatches) {
+      fileResults.push({
+        class: m[1],
+        coverage_pct: Math.round(parseFloat(m[2]) * 100),
+      });
+    }
+  }
+
+  // Generate HTML report with reportgenerator if available
+  let htmlReport = null;
+  if (html && coberturaFile && commandExists('reportgenerator')) {
+    const reportDir = path.join(projDir, 'coverage_html');
+    spawnSync('reportgenerator', [
+      `-reports:${coberturaFile}`,
+      `-targetdir:${reportDir}`,
+      '-reporttypes:Html',
+    ], { encoding: 'utf8', timeout: 30000 });
+    htmlReport = path.join(reportDir, 'index.html');
+  } else if (html && !commandExists('reportgenerator')) {
+    htmlReport = null;
+  }
+
+  // Cleanup temp
+  try { fs.rmSync(coverageDir, { recursive: true }); } catch {}
+
+  if (threshold !== null && totalPct !== null && totalPct < threshold) {
+    return output(fail(`Coverage ${totalPct}% is below threshold ${threshold}%`));
+  }
+
+  output(ok({
+    target: projDir,
+    lang: 'csharp',
+    tool: 'dotnet test + coverlet',
+    total_pct: totalPct,
+    threshold,
+    passed_threshold: threshold !== null ? (totalPct >= threshold) : null,
+    files: fileResults,
+    uncovered_files: fileResults.filter(f => f.coverage_pct < 100),
+    html_report: htmlReport,
+    html_note: html && !commandExists('reportgenerator')
+      ? 'Install reportgenerator for HTML: dotnet tool install -g dotnet-reportgenerator-globaltool'
+      : null,
+    test_output: (testRes.stdout || '').slice(0, 2000),
+  }));
+}
+
+// ─── JS/TS via c8 ────────────────────────────────────────────────────────────
+
+function runJsCoverage(dir, html, threshold, timeoutMs) {
+  if (!commandExists('c8') && !commandExists('npx')) {
+    return output(fail('c8 not found. Install: npm install -g c8'));
+  }
+
+  const cwd = path.resolve(dir);
+  const runner = commandExists('c8') ? 'c8' : 'npx';
+  const baseArgs = commandExists('c8') ? [] : ['c8'];
+  const thresholdArgs = threshold !== null ? [`--lines=${threshold}`] : [];
+  const reporterArgs  = html ? ['--reporter=html', '--reporter=text'] : ['--reporter=text'];
+  const args = [...baseArgs, ...thresholdArgs, ...reporterArgs, 'npm', 'test'];
+
+  const res = spawnSync(runner, args, { encoding: 'utf8', cwd, timeout: timeoutMs });
+
+  if (res.error?.code === 'ETIMEDOUT') {
+    return output(fail(`JS coverage timed out after ${timeoutMs}ms`));
+  }
+
+  // Parse text output for total
+  const totalMatch = (res.stdout || '').match(/All files\s*\|\s*([\d.]+)/);
+  const totalPct = totalMatch ? Math.round(parseFloat(totalMatch[1])) : null;
+
+  const failed = res.status !== 0 && threshold !== null;
+
+  if (failed) {
+    return output(fail(
+      `Coverage ${totalPct ?? '?'}% is below threshold ${threshold}%`
+    ));
+  }
+
+  output(ok({
+    dir: cwd,
+    lang:      'javascript',
+    tool:      'c8',
+    total_pct: totalPct,
+    threshold,
+    raw_output: (res.stdout || '').slice(0, 3000),
+    html_report: html ? path.join(cwd, 'coverage/index.html') : null,
+  }));
+}
+
+// ─── Go via go test -coverprofile ────────────────────────────────────────────
+
+function runGoCoverage(dir, html, threshold, timeoutMs) {
+  if (!commandExists('go')) {
+    return output(fail('go not found. Install Go: https://go.dev'));
+  }
+
+  const cwd = path.resolve(fs.statSync(dir).isDirectory() ? dir : path.dirname(dir));
+
+  // Find go.mod root
+  let goRoot = cwd;
+  for (let i = 0; i < 6; i++) {
+    if (fs.existsSync(path.join(goRoot, 'go.mod'))) break;
+    const parent = path.dirname(goRoot);
+    if (parent === goRoot) { goRoot = cwd; break; }
+    goRoot = parent;
+  }
+
+  const coverFile = path.join(os.tmpdir(), `fchek_go_cover_${process.pid}.out`);
+
+  // Run tests with coverage
+  const testRes = spawnSync(
+    'go', ['test', '-coverprofile=' + coverFile, '-covermode=atomic', './...'],
+    { encoding: 'utf8', cwd: goRoot, timeout: timeoutMs }
+  );
+
+  if (testRes.error?.code === 'ETIMEDOUT') {
+    return output(fail(`Go coverage timed out after ${timeoutMs}ms`));
+  }
+
+  if (testRes.status !== 0 && !fs.existsSync(coverFile)) {
+    return output(fail(
+      `go test failed:\n${(testRes.stderr || testRes.stdout || '').slice(0, 1000)}`
+    ));
+  }
+
+  // Get total coverage percent from output: "coverage: 83.3% of statements"
+  const combined = (testRes.stdout || '') + (testRes.stderr || '');
+  const totalMatch = combined.match(/coverage:\s*([\d.]+)%/);
+  const totalPct = totalMatch ? Math.round(parseFloat(totalMatch[1])) : null;
+
+  // Parse per-file coverage using "go tool cover -func"
+  let fileResults = [];
+  if (fs.existsSync(coverFile)) {
+    const funcRes = spawnSync(
+      'go', ['tool', 'cover', `-func=${coverFile}`],
+      { encoding: 'utf8', cwd: goRoot, timeout: 15000 }
+    );
+
+    for (const line of (funcRes.stdout || '').split('\n')) {
+      // Format: path/to/file.go:funcName    83.3%
+      const m = line.match(/^(.+\.go):(\w+)\s+([\d.]+)%$/);
+      if (m && m[2] !== 'total') {
+        fileResults.push({
+          file:         m[1],
+          function:     m[2],
+          coverage_pct: Math.round(parseFloat(m[3])),
+        });
+      }
+    }
+
+    // Generate HTML report
+    let htmlReport = null;
+    if (html) {
+      const htmlOut = path.join(goRoot, 'coverage.html');
+      spawnSync('go', ['tool', 'cover', `-html=${coverFile}`, `-o=${htmlOut}`],
+        { encoding: 'utf8', cwd: goRoot, timeout: 15000 });
+      if (fs.existsSync(htmlOut)) htmlReport = htmlOut;
+    }
+
+    try { fs.unlinkSync(coverFile); } catch {}
+
+    if (threshold !== null && totalPct !== null && totalPct < threshold) {
+      return output(fail(`Coverage ${totalPct}% is below threshold ${threshold}%`));
+    }
+
+    return output(ok({
+      dir:      goRoot,
+      lang:     'go',
+      tool:     'go test -coverprofile',
+      total_pct: totalPct,
+      threshold,
+      passed_threshold: threshold !== null ? (totalPct >= threshold) : null,
+      functions:        fileResults,
+      uncovered_functions: fileResults.filter(f => f.coverage_pct === 0),
+      html_report:      htmlReport,
+      test_output:      combined.slice(0, 2000),
+    }));
+  }
+
+  // No cover file — test probably failed but we got partial output
+  try { fs.unlinkSync(coverFile); } catch {}
+  return output(ok({
+    dir:       goRoot,
+    lang:      'go',
+    tool:      'go test -coverprofile',
+    total_pct: totalPct,
+    threshold,
+    passed_threshold: threshold !== null && totalPct !== null ? (totalPct >= threshold) : null,
+    functions: [],
+    test_output: combined.slice(0, 2000),
+    note: 'No coverage file generated — tests may have failed.',
+  }));
+}
+
+// ─── Entry point ─────────────────────────────────────────────────────────────
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') {
+    console.log(HELP);
+    return;
+  }
+
+  const target    = args[0];
+  const html      = args.includes('--html');
+  const thrArg    = args.find(a => a.startsWith('--threshold='));
+  const threshold = thrArg ? parseInt(thrArg.replace('--threshold=', ''), 10) : null;
+
+  const ext = path.extname(target).toLowerCase();
+
+  const isDir = fs.statSync(target).isDirectory();
+
+  // C# detection
+  if (ext === '.cs') {
+    return runCSharpCoverage(target, html, threshold, DEFAULT_TIMEOUT);
+  }
+  if (isDir) {
+    // Check for .csproj anywhere in directory
+    const hasCsproj = (() => {
+      try {
+        const entries = fs.readdirSync(target, { recursive: true });
+        return entries.some(e => typeof e === 'string' ? e.endsWith('.csproj') : false);
+      } catch {
+        // recursive not supported in older Node — fallback
+        try { return fs.readdirSync(target).some(f => f.endsWith('.csproj') || f.endsWith('.sln')); } catch { return false; }
+      }
+    })();
+    if (hasCsproj) return runCSharpCoverage(target, html, threshold, DEFAULT_TIMEOUT);
+  }
+
+  // Detect by extension or by directory markers
+  if (ext === '.py') {
+    return runPythonCoverage(target, html, threshold, DEFAULT_TIMEOUT);
+  }
+  if (['.c', '.cpp', '.cc'].includes(ext)) {
+    return runGcov(target, DEFAULT_TIMEOUT);
+  }
+  if (ext === '.rs' || target === '.' || fs.existsSync(path.join(target, 'Cargo.toml'))) {
+    return runRustCoverage(target, html, DEFAULT_TIMEOUT);
+  }
+  if (['.js', '.ts', '.mjs'].includes(ext) || fs.existsSync(path.join(target, 'package.json'))) {
+    return runJsCoverage(target, html, threshold, DEFAULT_TIMEOUT);
+  }
+  if (ext === '.go' || fs.existsSync(path.join(target, 'go.mod'))) {
+    return runGoCoverage(target, html, threshold, DEFAULT_TIMEOUT);
+  }
+  // Also detect Go dir by presence of .go files
+  if (isDir) {
+    const hasGo = (() => { try { return fs.readdirSync(target).some(f => f.endsWith('.go')); } catch { return false; } })();
+    if (hasGo) return runGoCoverage(target, html, threshold, DEFAULT_TIMEOUT);
+  }
+
+  output(fail(`Cannot detect language for: ${target}. Supported: .py .c .cpp .rs (Cargo.toml) .js .ts .go (go.mod)`));
+}
+
+module.exports = { run };