fchek 1.0.0

package/lib/profile.js

@@ -0,0 +1,453 @@
+'use strict';
+
+const { execSync, spawnSync } = 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 profile <file> [app|web]
+
+Profile code and show hot functions by CPU time.
+
+Supported languages:
+  .py          → py-spy (preferred) or cProfile (fallback)
+  .js / .ts    → node --cpu-prof (generates .cpuprofile JSON)
+  .rs / Cargo  → cargo-flamegraph (cargo install flamegraph) or perf
+  .c / .cpp    → valgrind --tool=callgrind  [Linux only]
+
+Options:
+  app   Run as standalone app (default)
+  web   Python web mode — attach to running process by PID (requires --pid)
+
+Platform notes:
+  valgrind does not work on macOS >= 10.15 or Windows.
+  On macOS: use Instruments.app manually. On Windows: use WSL.
+  cargo-flamegraph requires: cargo install flamegraph  +  perf (Linux) or DTrace (macOS).
+
+Examples:
+  fchek profile main.py
+  fchek profile server.py web
+  fchek profile main.cpp
+  fchek profile app.js
+  fchek profile src/main.rs
+`.trim();
+
+const DEFAULT_TIMEOUT_MS = 60_000; // 1 minute max
+
+function commandExists(cmd) {
+  try {
+    execSync(
+      process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`,
+      { stdio: 'ignore' }
+    );
+    return true;
+  } catch { return false; }
+}
+
+function detectLang(file) {
+  const ext = path.extname(file).toLowerCase();
+  if (ext === '.py') return 'python';
+  if (['.c', '.cpp', '.cc'].includes(ext)) return 'c';
+  if (['.js', '.mjs', '.cjs'].includes(ext)) return 'javascript';
+  if (ext === '.ts') return 'typescript';
+  if (ext === '.rs') return 'rust';
+  return null;
+}
+
+function parseCProfileOutput(raw) {
+  const lines = raw.split('\n');
+  const entries = [];
+  // cProfile text format: ncalls  tottime  percall  cumtime  percall filename:lineno(function)
+  for (const line of lines) {
+    const m = line.match(/^\s*(\d+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)\s+(.+)$/);
+    if (m) {
+      entries.push({
+        ncalls:   parseInt(m[1]),
+        tottime:  parseFloat(m[2]),
+        cumtime:  parseFloat(m[4]),
+        location: m[6].trim(),
+      });
+    }
+  }
+  return entries.slice(0, 20); // top 20
+}
+
+function profilePython(file, mode, timeoutMs) {
+  const absFile = path.resolve(file);
+
+  // Try py-spy first — it gives the best per-function breakdown
+  if (commandExists('py-spy')) {
+    const outSvg = path.join(os.tmpdir(), 'fchek_profile.svg');
+    const spyRes = spawnSync(
+      'py-spy',
+      ['record', '-o', outSvg, '--duration', '5', '--', 'python', absFile],
+      { encoding: 'utf8', timeout: timeoutMs }
+    );
+
+    if (spyRes.error && spyRes.error.code === 'ETIMEDOUT') {
+      return output(fail(`Profile timed out after ${timeoutMs}ms — possible infinite loop in code`));
+    }
+
+    // py-spy top for text summary
+    const topRes = spawnSync(
+      'py-spy',
+      ['top', '--noninteractive', '--duration', '3', '--', 'python', absFile],
+      { encoding: 'utf8', timeout: timeoutMs }
+    );
+
+    const raw = topRes.stdout || topRes.stderr || '';
+    return output(ok({
+      file:     absFile,
+      lang:     'python',
+      mode,
+      tool:     'py-spy',
+      timeout_ms: timeoutMs,
+      raw_summary: raw.slice(0, 4000),
+      flame_graph: fs.existsSync(outSvg) ? outSvg : null,
+    }));
+  }
+
+  // Fallback: cProfile via subprocess — script written to tmpfile to avoid -c issues on Windows
+  const py = findPython();
+  if (!py) {
+    return output(fail('Python not found. Install Python 3: https://python.org'));
+  }
+
+  const script = [
+    'import cProfile, pstats, io, sys',
+    'TARGET = ' + JSON.stringify(absFile),
+    'sys.argv = [TARGET]',
+    'pr = cProfile.Profile()',
+    'pr.enable()',
+    'with open(TARGET) as f:',
+    '    code = f.read()',
+    'try:',
+    '    exec(compile(code, TARGET, "exec"), {"__file__": TARGET, "__name__": "__main__"})',
+    'except SystemExit:',
+    '    pass',
+    'pr.disable()',
+    's = io.StringIO()',
+    'pstats.Stats(pr, stream=s).sort_stats("cumulative").print_stats(25)',
+    'print(s.getvalue())',
+  ].join('\n');
+
+  const tmpScript = path.join(os.tmpdir(), 'fchek_profile_' + process.pid + '.py');
+  fs.writeFileSync(tmpScript, script, 'utf8');
+
+  const res = spawnSync(py, [tmpScript], {
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    windowsHide: true,
+  });
+  try { fs.unlinkSync(tmpScript); } catch {}
+
+  if (res.error && res.error.code === 'ETIMEDOUT') {
+    return output(fail(`Profile timed out after ${timeoutMs}ms — possible infinite loop`));
+  }
+  if (res.error) {
+    return output(fail(`Python not found: ${res.error.message}`));
+  }
+
+  const entries = parseCProfileOutput(res.stdout || '');
+
+  output(ok({
+    file:     absFile,
+    lang:     'python',
+    mode,
+    tool:     'cProfile',
+    timeout_ms: timeoutMs,
+    top_functions: entries,
+    raw_summary: (res.stdout || '').slice(0, 4000),
+    stderr: (res.stderr || '').slice(0, 500) || null,
+  }));
+}
+
+// ─── JS/TS via node --cpu-prof ────────────────────────────────────────────────
+
+function profileJs(file, timeoutMs) {
+  const absFile = path.resolve(file);
+  const ext     = path.extname(file).toLowerCase();
+  const isTs    = ext === '.ts';
+  const workDir = path.dirname(absFile);
+
+  // For TypeScript: compile first with tsc, then profile the JS
+  let targetFile = absFile;
+  let tmpJs = null;
+
+  if (isTs) {
+    if (!commandExists('tsc') && !commandExists('npx')) {
+      return output(fail('tsc not found. Install: npm install -g typescript'));
+    }
+    tmpJs = path.join(os.tmpdir(), `fchek_profile_${process.pid}.js`);
+    const tscArgs = commandExists('tsc')
+      ? ['--outFile', tmpJs, '--module', 'none', '--target', 'ES2020', absFile]
+      : ['tsc', '--outFile', tmpJs, '--module', 'none', '--target', 'ES2020', absFile];
+    const tscRunner = commandExists('tsc') ? 'tsc' : 'npx';
+    const tscRes = spawnSync(tscRunner, tscArgs, {
+      encoding: 'utf8', timeout: 30000, windowsHide: true,
+    });
+    if (tscRes.status !== 0 || !fs.existsSync(tmpJs)) {
+      return output(fail(`TypeScript compilation failed:\n${(tscRes.stderr || tscRes.stdout || '').slice(0, 500)}`));
+    }
+    targetFile = tmpJs;
+  }
+
+  // node --cpu-prof --cpu-prof-dir=<tmpdir> <file>
+  const profDir = os.tmpdir();
+  const res = spawnSync(
+    'node',
+    ['--cpu-prof', `--cpu-prof-dir=${profDir}`, targetFile],
+    {
+      encoding:    'utf8',
+      cwd:         workDir,
+      timeout:     timeoutMs,
+      windowsHide: true,
+    }
+  );
+
+  if (tmpJs) { try { fs.unlinkSync(tmpJs); } catch {} }
+
+  if (res.error?.code === 'ETIMEDOUT') {
+    return output(fail(`Profile timed out after ${timeoutMs}ms — possible infinite loop`));
+  }
+
+  // Find the generated .cpuprofile file (node names it isolate-*-*.cpuprofile)
+  let cpuprofileFile = null;
+  try {
+    const files = fs.readdirSync(profDir)
+      .filter(f => f.endsWith('.cpuprofile'))
+      .map(f => ({ f, mtime: fs.statSync(path.join(profDir, f)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime);
+    if (files.length > 0) cpuprofileFile = path.join(profDir, files[0].f);
+  } catch {}
+
+  // Parse .cpuprofile to extract hot functions
+  const topFunctions = [];
+  if (cpuprofileFile && fs.existsSync(cpuprofileFile)) {
+    try {
+      const profile = JSON.parse(fs.readFileSync(cpuprofileFile, 'utf8'));
+      // V8 cpuprofile: nodes[] with callFrame + hitCount
+      const nodes = profile.nodes || [];
+      const totalHits = nodes.reduce((s, n) => s + (n.hitCount || 0), 0) || 1;
+
+      const sorted = nodes
+        .filter(n => n.hitCount > 0 && n.callFrame?.functionName)
+        .sort((a, b) => (b.hitCount || 0) - (a.hitCount || 0))
+        .slice(0, 20);
+
+      for (const node of sorted) {
+        const f = node.callFrame;
+        topFunctions.push({
+          function:   f.functionName || '(anonymous)',
+          url:        f.url ? path.basename(f.url) : null,
+          line:       f.lineNumber != null ? f.lineNumber + 1 : null,
+          hit_count:  node.hitCount,
+          pct:        Math.round((node.hitCount / totalHits) * 100 * 10) / 10,
+        });
+      }
+    } catch {}
+  }
+
+  output(ok({
+    file:          absFile,
+    lang:          isTs ? 'typescript' : 'javascript',
+    tool:          'node --cpu-prof',
+    timeout_ms:    timeoutMs,
+    top_functions: topFunctions,
+    cpuprofile:    cpuprofileFile,
+    exit_code:     res.status,
+    stderr:        (res.stderr || '').slice(0, 500) || null,
+    note:          cpuprofileFile
+      ? `Full profile saved: ${cpuprofileFile} (open in Chrome DevTools → Performance tab)`
+      : 'No .cpuprofile generated — script may have exited too fast.',
+  }));
+}
+
+// ─── Rust via cargo-flamegraph ────────────────────────────────────────────────
+
+function profileRust(file, timeoutMs) {
+  const absFile = path.resolve(file);
+
+  // Find Cargo.toml root
+  let cargoRoot = path.dirname(absFile);
+  for (let i = 0; i < 6; i++) {
+    if (fs.existsSync(path.join(cargoRoot, 'Cargo.toml'))) break;
+    const parent = path.dirname(cargoRoot);
+    if (parent === cargoRoot) { cargoRoot = path.dirname(absFile); break; }
+    cargoRoot = parent;
+  }
+
+  if (!commandExists('cargo')) {
+    return output(fail('cargo not found. Install Rust: https://rustup.rs'));
+  }
+
+  // Check if cargo-flamegraph is installed
+  const hasFlamegraph = (() => {
+    const r = spawnSync('cargo', ['flamegraph', '--version'],
+      { encoding: 'utf8', timeout: 5000, windowsHide: true });
+    return r.status === 0;
+  })();
+
+  if (!hasFlamegraph) {
+    // Fallback: cargo build --release + time + basic stats
+    const buildRes = spawnSync(
+      'cargo', ['build', '--release'],
+      { encoding: 'utf8', cwd: cargoRoot, timeout: timeoutMs, windowsHide: true }
+    );
+    if (buildRes.status !== 0) {
+      return output(fail(
+        `cargo-flamegraph not installed and cargo build failed.\n` +
+        `Install flamegraph: cargo install flamegraph\n` +
+        `Build error: ${(buildRes.stderr || '').slice(0, 400)}`
+      ));
+    }
+
+    // Run with time measurement
+    const t0 = Date.now();
+    const runRes = spawnSync(
+      'cargo', ['run', '--release'],
+      { encoding: 'utf8', cwd: cargoRoot, timeout: timeoutMs, windowsHide: true }
+    );
+    const elapsed = Date.now() - t0;
+
+    return output(ok({
+      file:      absFile,
+      lang:      'rust',
+      tool:      'cargo run --release (basic timing)',
+      timeout_ms: timeoutMs,
+      elapsed_ms: elapsed,
+      exit_code:  runRes.status,
+      stdout:     (runRes.stdout || '').slice(0, 2000),
+      stderr:     (runRes.stderr || '').slice(0, 500) || null,
+      note:       'For detailed flamegraph: cargo install flamegraph  then re-run fchek profile',
+      install_hint: 'cargo install flamegraph',
+    }));
+  }
+
+  // cargo flamegraph --output <tmpfile.svg>
+  const svgOut = path.join(os.tmpdir(), `fchek_flamegraph_${process.pid}.svg`);
+  const fgRes = spawnSync(
+    'cargo', ['flamegraph', '--output', svgOut],
+    {
+      encoding:    'utf8',
+      cwd:         cargoRoot,
+      timeout:     timeoutMs,
+      windowsHide: true,
+      env:         { ...process.env, CARGO_PROFILE_RELEASE_DEBUG: '1' },
+    }
+  );
+
+  if (fgRes.error?.code === 'ETIMEDOUT') {
+    return output(fail(`Rust profile timed out after ${timeoutMs}ms`));
+  }
+
+  const hasSvg = fs.existsSync(svgOut);
+
+  output(ok({
+    file:       absFile,
+    lang:       'rust',
+    tool:       'cargo-flamegraph',
+    timeout_ms: timeoutMs,
+    exit_code:  fgRes.status,
+    flamegraph: hasSvg ? svgOut : null,
+    stderr:     (fgRes.stderr || '').slice(0, 1000) || null,
+    note:       hasSvg
+      ? `Flamegraph saved: ${svgOut} (open in browser)`
+      : 'Flamegraph not generated — check stderr for details.',
+  }));
+}
+
+// ─── C/C++ via valgrind/callgrind ─────────────────────────────────────────────
+
+function profileC(file, timeoutMs) {
+  const absFile = path.resolve(file);
+
+  if (process.platform !== 'linux') {
+    return output(fail(
+      `C/C++ profiling via valgrind is only supported on Linux.\n` +
+      `On macOS: use Instruments.app. On Windows: use WSL.`
+    ));
+  }
+
+  if (!commandExists('valgrind')) {
+    return output(fail('valgrind not found. Install: apt install valgrind'));
+  }
+
+  const ext      = path.extname(file).toLowerCase();
+  const compiler = (ext === '.cpp' || ext === '.cc') ? 'g++' : 'gcc';
+
+  if (!commandExists(compiler)) {
+    return output(fail(`${compiler} not found. Install: apt install build-essential`));
+  }
+
+  const outBin = path.join(os.tmpdir(), `fchek_${path.basename(file, ext)}.out`);
+  const compile = spawnSync(compiler, ['-g', '-O1', '-o', outBin, absFile], { encoding: 'utf8' });
+
+  if (compile.status !== 0) {
+    return output(fail(`Compilation failed:\n${compile.stderr}`));
+  }
+
+  const cgOut = path.join(os.tmpdir(), 'fchek_callgrind.out');
+  const vg = spawnSync(
+    'valgrind',
+    ['--tool=callgrind', `--callgrind-out-file=${cgOut}`, outBin],
+    { encoding: 'utf8', timeout: timeoutMs }
+  );
+
+  if (vg.error && vg.error.code === 'ETIMEDOUT') {
+    try { fs.unlinkSync(outBin); } catch {}
+    return output(fail(`Profile timed out after ${timeoutMs}ms`));
+  }
+
+  let annotation = null;
+  if (commandExists('callgrind_annotate') && fs.existsSync(cgOut)) {
+    const ann = spawnSync('callgrind_annotate', ['--auto=yes', cgOut], { encoding: 'utf8' });
+    annotation = ann.stdout ? ann.stdout.slice(0, 5000) : null;
+  }
+
+  try { fs.unlinkSync(outBin); } catch {}
+  try { fs.unlinkSync(cgOut); } catch {}
+
+  output(ok({
+    file:        absFile,
+    lang:        'c',
+    tool:        'valgrind/callgrind',
+    timeout_ms:  timeoutMs,
+    valgrind_output: (vg.stderr || '').slice(0, 3000),
+    annotation,
+  }));
+}
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') {
+    console.log(HELP);
+    return;
+  }
+
+  const file    = args[0];
+  const mode    = args[1] || 'app';
+  const timeout = parseInt(
+    (args.find(a => a.startsWith('--timeout=')) || '').replace('--timeout=', '') || DEFAULT_TIMEOUT_MS,
+    10
+  );
+
+  if (!fs.existsSync(file)) {
+    return output(fail(`File not found: ${file}`));
+  }
+
+  const lang = detectLang(file);
+  if (!lang) {
+    return output(fail(`Unsupported file type: ${path.extname(file)}. Supported: .py .js .ts .rs .c .cpp`));
+  }
+
+  if (lang === 'python')     return profilePython(file, mode, timeout);
+  if (lang === 'javascript') return profileJs(file, timeout);
+  if (lang === 'typescript') return profileJs(file, timeout);
+  if (lang === 'rust')       return profileRust(file, timeout);
+  if (lang === 'c')          return profileC(file, timeout);
+}
+
+module.exports = { run };

package/lib/python.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * python.js — find a working Python interpreter on any platform.
+ *
+ * On Windows, "python3" is often a Microsoft Store alias that prints an error
+ * instead of running. This helper finds the first interpreter that actually works.
+ */
+
+const { spawnSync } = require('child_process');
+
+let _cachedPython = undefined;
+
+function findPython() {
+  if (_cachedPython !== undefined) return _cachedPython;
+
+  const candidates = process.platform === 'win32'
+    ? ['python', 'python3', 'py']       // on Windows "python" is usually real, "python3" is Store alias
+    : ['python3', 'python'];             // on Linux/macOS python3 is preferred
+
+  for (const p of candidates) {
+    try {
+      const r = spawnSync(p, ['-c', 'import sys; print(sys.version_info[0])'], {
+        encoding: 'utf8',
+        timeout:  4000,
+        // suppress Windows Store popup
+        windowsHide: true,
+      });
+      // Must exit 0 AND print a version number (not a Store redirect error)
+      if (r.status === 0 && r.stdout && r.stdout.trim().match(/^[23]$/)) {
+        _cachedPython = p;
+        return p;
+      }
+    } catch {}
+  }
+
+  _cachedPython = null;
+  return null;
+}
+
+module.exports = { findPython };

package/lib/race.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const { execSync, spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek race <file.cpp> [--asan | --tsan | --ubsan | --all]
+
+Compile and check for data races / memory errors using sanitizers.
+Automatically detects project build system (CMake, Makefile, Cargo, plain gcc).
+
+Flags:
+  --tsan   ThreadSanitizer — data races (default)
+  --asan   AddressSanitizer — buffer overflows, use-after-free, leaks
+  --ubsan  UndefinedBehaviorSanitizer — integer overflow, null deref
+  --all    Run all three sanitizers
+
+Platform notes:
+  Linux   — full support (gcc/clang + valgrind)
+  macOS   — use clang (Apple clang supports -fsanitize=address/thread)
+  Windows — use WSL; native MinGW does NOT support sanitizers
+
+Examples:
+  fchek race threaded.cpp
+  fchek race memory.cpp --asan
+  fchek race app.cpp --all
+`.trim();
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+function commandExists(cmd) {
+  try {
+    execSync(
+      process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`,
+      { stdio: 'ignore' }
+    );
+    return true;
+  } catch { return false; }
+}
+
+function detectBuildSystem(startDir) {
+  let dir = path.resolve(startDir);
+  for (let i = 0; i < 5; i++) {
+    if (fs.existsSync(path.join(dir, 'CMakeLists.txt'))) return { type: 'cmake', dir };
+    if (fs.existsSync(path.join(dir, 'Makefile')))        return { type: 'make',  dir };
+    if (fs.existsSync(path.join(dir, 'Cargo.toml')))      return { type: 'cargo', dir };
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { type: 'single', dir: startDir };
+}
+
+function pickCompiler() {
+  if (commandExists('clang++')) return { cc: 'clang', cxx: 'clang++' };
+  if (commandExists('g++'))     return { cc: 'gcc',   cxx: 'g++' };
+  return null;
+}
+
+function parseSanitizerOutput(raw, name) {
+  const issues = [];
+  const lines  = raw.split('\n');
+  let cur = null;
+  for (const line of lines) {
+    if (/ERROR:|WARNING:|runtime error:/i.test(line)) {
+      if (cur) issues.push(cur);
+      cur = { sanitizer: name, headline: line.trim(), stack: [] };
+    } else if (cur && line.trim()) {
+      cur.stack.push(line.trim());
+      if (cur.stack.length >= 8) { issues.push(cur); cur = null; }
+    }
+  }
+  if (cur) issues.push(cur);
+  return issues;
+}
+
+function runSanitizer(file, sanitizerFlag, sanitizerName, compiler, timeoutMs) {
+  const base   = path.basename(file, path.extname(file));
+  const outBin = path.join(
+    require('os').tmpdir(),
+    `fchek_${base}_${sanitizerName}.out`
+  );
+
+  const compileArgs = [
+    '-g', '-O1',
+    `-fsanitize=${sanitizerFlag}`,
+    '-fno-omit-frame-pointer',
+    '-o', outBin, file
+  ];
+
+  const compile = spawnSync(compiler.cxx, compileArgs, { encoding: 'utf8' });
+  if (compile.status !== 0) {
+    return { sanitizer: sanitizerName, compiled: false, error: compile.stderr.trim() };
+  }
+
+  const run = spawnSync(outBin, [], {
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    env: {
+      ...process.env,
+      ASAN_OPTIONS:  'symbolize=1:detect_leaks=1:abort_on_error=0',
+      TSAN_OPTIONS:  'symbolize=1:abort_on_error=0',
+      UBSAN_OPTIONS: 'print_stacktrace=1:abort_on_error=0',
+    },
+  });
+
+  try { fs.unlinkSync(outBin); } catch {}
+
+  const timedOut = run.error && run.error.code === 'ETIMEDOUT';
+  const combined = (run.stdout || '') + (run.stderr || '');
+  const hasFinding = /ERROR:|WARNING:|runtime error:/i.test(combined);
+
+  return {
+    sanitizer:  sanitizerName,
+    compiled:   true,
+    timed_out:  timedOut,
+    issues:     hasFinding ? parseSanitizerOutput(combined, sanitizerName) : [],
+    raw_output: combined.slice(0, 3000),
+  };
+}
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') {
+    console.log(HELP);
+    return;
+  }
+
+  const file  = args[0];
+  const flags = args.slice(1);
+
+  if (!fs.existsSync(file)) {
+    return output(fail(`File not found: ${file}`));
+  }
+
+  const ext = path.extname(file).toLowerCase();
+  if (!['.c', '.cpp', '.cc'].includes(ext)) {
+    return output(fail(`Unsupported file type: ${ext}. Supported: .c .cpp .cc`));
+  }
+
+  if (process.platform === 'win32') {
+    return output(fail(
+      'Sanitizers are not supported on native Windows.\n' +
+      'Use WSL: wsl --install, then run fchek inside WSL.'
+    ));
+  }
+
+  const compiler = pickCompiler();
+  if (!compiler) {
+    return output(fail('No C++ compiler found. Install: apt install build-essential'));
+  }
+
+  const buildSystem = detectBuildSystem(path.dirname(path.resolve(file)));
+
+  const runAll  = flags.includes('--all');
+  const useAsan = flags.includes('--asan');
+  const useTsan = flags.includes('--tsan');
+  const useUbsan = flags.includes('--ubsan');
+
+  const sanitizers = runAll
+    ? [['thread', 'ThreadSanitizer'], ['address', 'AddressSanitizer'], ['undefined', 'UBSanitizer']]
+    : useAsan  ? [['address', 'AddressSanitizer']]
+    : useUbsan ? [['undefined', 'UBSanitizer']]
+    : [['thread', 'ThreadSanitizer']];
+
+  const results = sanitizers.map(([flag, name]) =>
+    runSanitizer(file, flag, name, compiler, DEFAULT_TIMEOUT_MS)
+  );
+
+  const totalIssues = results.reduce((n, r) => n + (r.issues ? r.issues.length : 0), 0);
+
+  output(ok({
+    file:         path.resolve(file),
+    build_system: buildSystem.type,
+    compiler:     compiler.cxx,
+    timeout_ms:   DEFAULT_TIMEOUT_MS,
+    sanitizers:   results,
+    summary: {
+      total_issues: totalIssues,
+      verdict: totalIssues === 0 ? 'clean' : 'issues_found',
+    },
+  }));
+}
+
+module.exports = { run };