flake-monster 0.1.0

package/src/cli/commands/inject.js

@@ -0,0 +1,64 @@
+import { resolve } from 'node:path';
+import { AdapterRegistry } from '../../adapters/registry.js';
+import { createJavaScriptAdapter } from '../../adapters/javascript/index.js';
+import { InjectorEngine } from '../../core/engine.js';
+import { FlakeProfile } from '../../core/profile.js';
+import { parseSeed } from '../../core/seed.js';
+import { ProjectWorkspace, getFlakeMonsterDir } from '../../core/workspace.js';
+import { loadConfig, mergeWithCliOptions } from '../../core/config.js';
+
+export function registerInjectCommand(program) {
+  program
+    .command('inject')
+    .description('Inject async delays into source files')
+    .argument('[globs...]', 'File patterns to process', ['src/**/*.js'])
+    .option('-m, --mode <mode>', 'Injection density: light, medium, hardcore', 'medium')
+    .option('-s, --seed <seed>', 'Random seed for deterministic delays (or "auto")', 'auto')
+    .option('--in-place', 'Modify files in-place (default)', true)
+    .option('--workspace', 'Create a workspace copy instead of modifying files in-place', false)
+    .option('--min-delay <ms>', 'Minimum delay in milliseconds', '0')
+    .option('--max-delay <ms>', 'Maximum delay in milliseconds', '50')
+    .action(async (globs, options) => {
+      try {
+        const projectRoot = resolve('.');
+        const config = await loadConfig(projectRoot);
+        const merged = mergeWithCliOptions(config, options);
+        const seed = parseSeed(options.seed);
+
+        const profile = FlakeProfile.fromConfig(merged);
+        const registry = new AdapterRegistry();
+        registry.register(createJavaScriptAdapter());
+        const engine = new InjectorEngine(registry, profile);
+
+        const useWorkspace = options.workspace;
+        let targetDir = projectRoot;
+        let workspace = null;
+
+        if (useWorkspace) {
+          workspace = new ProjectWorkspace({ sourceDir: projectRoot, runId: `inject-seed-${seed}` });
+          await workspace.create();
+          targetDir = workspace.root;
+          console.log(`Workspace created: ${workspace.root}`);
+        }
+
+        const manifest = await engine.injectAll(targetDir, globs, seed);
+        const flakeDir = getFlakeMonsterDir(useWorkspace ? targetDir : projectRoot);
+        await manifest.save(flakeDir);
+
+        const totalFiles = Object.keys(manifest.getFiles()).length;
+        const totalInjections = manifest.getTotalInjections();
+
+        console.log(`\nInjected ${totalInjections} delays into ${totalFiles} file(s)`);
+        console.log(`Mode: ${profile.mode} | Seed: ${seed}`);
+
+        if (useWorkspace) {
+          console.log(`\nWorkspace: ${workspace.root}`);
+          console.log('Run your tests against the workspace, then clean up with:');
+          console.log(`  flake-monster restore`);
+        }
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/restore.js

@@ -0,0 +1,107 @@
+import { resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { AdapterRegistry } from '../../adapters/registry.js';
+import { createJavaScriptAdapter } from '../../adapters/javascript/index.js';
+import { InjectorEngine } from '../../core/engine.js';
+import { FlakeProfile } from '../../core/profile.js';
+import { Manifest } from '../../core/manifest.js';
+import { getFlakeMonsterDir } from '../../core/workspace.js';
+import { loadConfig } from '../../core/config.js';
+
+/**
+ * Prompt the user for a yes/no answer.
+ * @param {string} question
+ * @returns {Promise<boolean>}
+ */
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === 'y');
+    });
+  });
+}
+
+/**
+ * Print recovery scan results to the terminal.
+ * @param {{ file: string, matches: { line: number, content: string, reason: string }[] }[]} scanResults
+ */
+function printScanResults(scanResults) {
+  let totalMatches = 0;
+
+  for (const { file, matches } of scanResults) {
+    console.log(`\n  ${file} (${matches.length} match${matches.length === 1 ? '' : 'es'}):`);
+    for (const m of matches) {
+      const tag = m.reason === 'stamp' ? 'stamp' : m.reason === 'identifier' ? 'ident' : 'import';
+      console.log(`    L${m.line} [${tag}] ${m.content.trim()}`);
+      totalMatches++;
+    }
+  }
+
+  console.log(`\n  Total: ${totalMatches} line(s) across ${scanResults.length} file(s)`);
+}
+
+export function registerRestoreCommand(program) {
+  program
+    .command('restore')
+    .description('Remove all injected delays and restore original source')
+    .option('--in-place', 'Restore in-place modified files (default)', true)
+    .option('--recover', 'Interactive scan and confirm, use when traces of injected code remain after a normal restore', false)
+    .option('--dir <path>', 'Directory to restore (defaults to project root)')
+    .action(async (options) => {
+      try {
+        const projectRoot = resolve('.');
+        const config = await loadConfig(projectRoot);
+
+        const registry = new AdapterRegistry();
+        registry.register(createJavaScriptAdapter());
+
+        const targetDir = options.dir ? resolve(options.dir) : projectRoot;
+        const flakeDir = getFlakeMonsterDir(targetDir);
+
+        const manifest = await Manifest.load(flakeDir);
+        if (!manifest) {
+          console.log('No manifest found. Nothing to restore.');
+          console.log(`Looked in: ${flakeDir}`);
+          return;
+        }
+
+        const profile = FlakeProfile.fromConfig({ ...config, mode: manifest.mode });
+        const engine = new InjectorEngine(registry, profile);
+
+        if (options.recover) {
+          // Recovery mode: scan first, show results, then confirm
+          console.log('Recovery mode: scanning for injected lines...');
+
+          const scanResults = await engine.scanAll(targetDir, manifest);
+
+          if (scanResults.length === 0) {
+            console.log('No injected lines found. Files appear clean.');
+            return;
+          }
+
+          printScanResults(scanResults);
+
+          const proceed = await confirm('\n  Remove these lines? (y/N) ');
+          if (!proceed) {
+            console.log('  Aborted. No files were modified.');
+            return;
+          }
+
+          const { filesRestored, injectionsRemoved } = await engine.restoreAll(targetDir, manifest);
+          await Manifest.delete(flakeDir);
+
+          console.log(`\n  Recovered ${filesRestored} file(s), removed ${injectionsRemoved} line(s)`);
+        } else {
+          const { filesRestored, injectionsRemoved } = await engine.restoreAll(targetDir, manifest);
+          await Manifest.delete(flakeDir);
+
+          console.log(`Restored ${filesRestored} file(s), removed ${injectionsRemoved} injection(s)`);
+        }
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/test.js

@@ -0,0 +1,215 @@
+import { resolve } from 'node:path';
+import { execSync } from 'node:child_process';
+import { AdapterRegistry } from '../../adapters/registry.js';
+import { createJavaScriptAdapter } from '../../adapters/javascript/index.js';
+import { InjectorEngine } from '../../core/engine.js';
+import { FlakeProfile } from '../../core/profile.js';
+import { parseSeed, deriveSeed } from '../../core/seed.js';
+import { ProjectWorkspace, getFlakeMonsterDir } from '../../core/workspace.js';
+import { loadConfig, mergeWithCliOptions } from '../../core/config.js';
+import { Reporter } from '../../core/reporter.js';
+import { detectRunner, parseTestOutput } from '../../core/parsers/index.js';
+import { analyzeFlakiness } from '../../core/flake-analyzer.js';
+
+function execInDir(command, cwd) {
+  try {
+    const stdout = execSync(command, {
+      cwd,
+      env: { ...process.env },
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { exitCode: 0, stdout, stderr: '' };
+  } catch (err) {
+    return {
+      exitCode: err.status ?? 1,
+      stdout: err.stdout || '',
+      stderr: err.stderr || '',
+    };
+  }
+}
+
+export function registerTestCommand(program) {
+  program
+    .command('test')
+    .description('Run tests multiple times with injected delays to find flakes')
+    .option('-r, --runs <n>', 'Number of test runs', '10')
+    .option('-m, --mode <mode>', 'Injection density: light, medium, hardcore', 'medium')
+    .option('-s, --seed <seed>', 'Base seed (or "auto")', 'auto')
+    .option('-c, --cmd <command>', 'Test command to execute', 'npm test')
+    .option('--in-place', 'Modify source files directly (default)', true)
+    .option('--workspace', 'Use workspace copies instead of modifying source files directly', false)
+    .option('--keep-on-fail', 'Keep workspace on test failure for inspection', false)
+    .option('--keep-all', 'Keep all workspaces (pass or fail)', false)
+    .option('--min-delay <ms>', 'Minimum delay in milliseconds', '0')
+    .option('--max-delay <ms>', 'Maximum delay in milliseconds', '50')
+    .option('-f, --format <format>', 'Output format: text or json', 'text')
+    .option('--runner <runner>', 'Test runner: jest, node-test, tap, or auto', 'auto')
+    .argument('[globs...]', 'File patterns to process', ['src/**/*.js'])
+    .action(async (globs, options) => {
+      try {
+        const projectRoot = resolve('.');
+        const config = await loadConfig(projectRoot);
+        const merged = mergeWithCliOptions(config, options);
+
+        const baseSeed = parseSeed(options.seed);
+        const runs = Number(options.runs);
+        const testCmd = options.cmd;
+        const inPlace = !options.workspace;
+        const jsonOutput = options.format === 'json';
+
+        // Resolve which runner parser to use
+        const runner = options.runner === 'auto'
+          ? detectRunner(testCmd)
+          : options.runner;
+
+        const profile = FlakeProfile.fromConfig(merged);
+        const registry = new AdapterRegistry();
+        registry.register(createJavaScriptAdapter());
+        const engine = new InjectorEngine(registry, profile);
+        const reporter = new Reporter({ quiet: jsonOutput });
+
+        reporter.log(`FlakeMonster test harness`);
+        reporter.log(`  Runs: ${runs} | Mode: ${profile.mode} | Base seed: ${baseSeed}`);
+        reporter.log(`  Command: ${testCmd}`);
+        reporter.log(`  Patterns: ${globs.join(', ')}`);
+        if (runner) {
+          reporter.log(`  Runner: ${runner}`);
+        }
+        if (inPlace) {
+          reporter.log('  Mode: in-place (source files will be modified and restored)');
+        }
+        reporter.log('');
+
+        const results = [];
+        let lastManifest = null;
+
+        for (let i = 0; i < runs; i++) {
+          const runSeed = deriveSeed(baseSeed, `run:${i}`);
+
+          if (inPlace) {
+            // Restore previous run's injections before re-injecting
+            if (lastManifest) {
+              await engine.restoreAll(projectRoot, lastManifest);
+            }
+
+            // Inject directly into source
+            const manifest = await engine.injectAll(projectRoot, globs, runSeed);
+            const flakeDir = getFlakeMonsterDir(projectRoot);
+            await manifest.save(flakeDir);
+            lastManifest = manifest;
+
+            // Run tests in project root
+            const start = Date.now();
+            const { exitCode, stdout, stderr } = execInDir(testCmd, projectRoot);
+            const durationMs = Date.now() - start;
+
+            // Parse test output if we have a runner
+            const parsed = runner ? parseTestOutput(runner, stdout) : null;
+
+            const result = {
+              runIndex: i,
+              seed: runSeed,
+              exitCode,
+              stdout,
+              stderr,
+              durationMs,
+              workspacePath: projectRoot,
+              kept: false,
+              parsed: parsed?.parsed ?? false,
+              tests: parsed?.tests ?? [],
+            };
+
+            reporter.printRunResult(result, runs);
+            results.push(result);
+          } else {
+            // Create workspace
+            const workspace = new ProjectWorkspace({
+              sourceDir: projectRoot,
+              runId: `run-${i}-seed-${runSeed}`,
+            });
+            await workspace.create();
+
+            // Inject
+            const manifest = await engine.injectAll(workspace.root, globs, runSeed);
+            const flakeDir = getFlakeMonsterDir(workspace.root);
+            await manifest.save(flakeDir);
+
+            // Run tests
+            const start = Date.now();
+            const { exitCode, stdout, stderr } = workspace.exec(testCmd);
+            const durationMs = Date.now() - start;
+
+            const failed = exitCode !== 0;
+            const shouldKeep = (failed && options.keepOnFail) || options.keepAll;
+
+            // Parse test output if we have a runner
+            const parsed = runner ? parseTestOutput(runner, stdout) : null;
+
+            const result = {
+              runIndex: i,
+              seed: runSeed,
+              exitCode,
+              stdout,
+              stderr,
+              durationMs,
+              workspacePath: workspace.root,
+              kept: shouldKeep,
+              parsed: parsed?.parsed ?? false,
+              tests: parsed?.tests ?? [],
+            };
+
+            reporter.printRunResult(result, runs);
+            results.push(result);
+
+            // Cleanup
+            if (!shouldKeep) {
+              await workspace.destroy();
+            }
+          }
+        }
+
+        // Restore source files after all in-place runs
+        if (inPlace && lastManifest) {
+          await engine.restoreAll(projectRoot, lastManifest);
+          reporter.log('\n  Source files restored to original state.');
+        }
+
+        // Run flakiness analysis if we have parsed results
+        const analysis = runner ? analyzeFlakiness(results) : null;
+
+        if (jsonOutput) {
+          // JSON output for CI consumption
+          const output = {
+            version: 1,
+            baseSeed,
+            runs: results.map(r => ({
+              runIndex: r.runIndex,
+              seed: r.seed,
+              exitCode: r.exitCode,
+              durationMs: r.durationMs,
+              parsed: r.parsed,
+              totalPassed: r.tests.filter(t => t.status === 'passed').length,
+              totalFailed: r.tests.filter(t => t.status === 'failed').length,
+            })),
+            analysis: analysis ?? { totalTests: 0, flakyTests: [], stableTests: [], alwaysFailingTests: [] },
+          };
+          console.log(JSON.stringify(output));
+        } else {
+          reporter.summarize(results, runs);
+        }
+
+        // Exit with failure if any run failed
+        const anyFailed = results.some((r) => r.exitCode !== 0);
+        if (anyFailed) process.exit(1);
+      } catch (err) {
+        // If in-place mode fails mid-run, still try to restore
+        if (!options?.workspace) {
+          console.error('\nError during in-place test run. Attempting to restore source files...');
+          console.error('If restoration fails, run: flake-monster restore');
+        }
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/index.js

@@ -0,0 +1,19 @@
+import { Command } from 'commander';
+import { registerInjectCommand } from './commands/inject.js';
+import { registerRestoreCommand } from './commands/restore.js';
+import { registerTestCommand } from './commands/test.js';
+
+export function createCli() {
+  const program = new Command();
+
+  program
+    .name('flake-monster')
+    .description('Source-to-source test hardener, injects async delays to surface flaky tests')
+    .version('0.1.0');
+
+  registerInjectCommand(program);
+  registerRestoreCommand(program);
+  registerTestCommand(program);
+
+  return program;
+}

package/src/core/config.js

@@ -0,0 +1,57 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const CONFIG_FILENAMES = ['.flakemonsterrc.json', 'flakemonster.config.json'];
+
+const DEFAULTS = {
+  include: ['src/**/*.js'],
+  exclude: ['**/node_modules/**', '**/dist/**', '**/build/**'],
+  mode: 'medium',
+  minDelayMs: 0,
+  maxDelayMs: 50,
+  distribution: 'uniform',
+  testCommand: 'npm test',
+  runs: 10,
+  keepOnFail: true,
+  skipTryCatch: false,
+  skipGenerators: true,
+};
+
+/**
+ * Load config from project root, merging with defaults.
+ * CLI flags override config file values.
+ * @param {string} projectRoot
+ * @returns {Promise<Object>}
+ */
+export async function loadConfig(projectRoot) {
+  for (const filename of CONFIG_FILENAMES) {
+    try {
+      const raw = await readFile(join(projectRoot, filename), 'utf-8');
+      const fileConfig = JSON.parse(raw);
+      return { ...DEFAULTS, ...fileConfig };
+    } catch {
+      // File doesn't exist or isn't valid JSON — try next
+    }
+  }
+  return { ...DEFAULTS };
+}
+
+/**
+ * Merge loaded config with CLI options (CLI wins).
+ * @param {Object} config
+ * @param {Object} cliOptions
+ * @returns {Object}
+ */
+export function mergeWithCliOptions(config, cliOptions) {
+  const merged = { ...config };
+  if (cliOptions.mode) merged.mode = cliOptions.mode;
+  if (cliOptions.seed) merged.seed = cliOptions.seed;
+  if (cliOptions.minDelay) merged.minDelayMs = Number(cliOptions.minDelay);
+  if (cliOptions.maxDelay) merged.maxDelayMs = Number(cliOptions.maxDelay);
+  if (cliOptions.cmd) merged.testCommand = cliOptions.cmd;
+  if (cliOptions.runs) merged.runs = Number(cliOptions.runs);
+  if (cliOptions.keepOnFail) merged.keepOnFail = true;
+  if (cliOptions.keepAll) merged.keepAll = true;
+  if (cliOptions.skipTryCatch) merged.skipTryCatch = true;
+  return merged;
+}

package/src/core/engine.js

@@ -0,0 +1,156 @@
+import { readFile, writeFile, copyFile, mkdir } from 'node:fs/promises';
+import { join, relative, dirname } from 'node:path';
+import fg from 'fast-glob';
+import { Manifest, hashContent } from './manifest.js';
+
+/**
+ * Language-agnostic injection orchestrator.
+ * Routes files to the correct adapter and manages manifests.
+ * Never touches ASTs directly, all parsing/manipulation is in adapters.
+ */
+export class InjectorEngine {
+  /**
+   * @param {import('../adapters/registry.js').AdapterRegistry} registry
+   * @param {import('./profile.js').FlakeProfile} profile
+   */
+  constructor(registry, profile) {
+    this.registry = registry;
+    this.profile = profile;
+  }
+
+  /**
+   * Inject delays into all matching files in a directory.
+   * @param {string} rootDir - Directory to process (workspace or project root)
+   * @param {string[]} globs - File patterns to process
+   * @param {number} seed
+   * @returns {Promise<Manifest>}
+   */
+  async injectAll(rootDir, globs, seed) {
+    const manifest = new Manifest();
+    manifest.seed = seed;
+    manifest.mode = this.profile.mode;
+
+    // Resolve globs to file list
+    const files = await fg(globs, { cwd: rootDir, absolute: false });
+
+    const adaptersUsed = new Set();
+    let totalInjections = 0;
+
+    for (const filePath of files) {
+      const adapter = this.registry.getAdapterForFile(filePath);
+      if (!adapter) continue;
+
+      const absPath = join(rootDir, filePath);
+      const source = await readFile(absPath, 'utf-8');
+      const originalHash = hashContent(source);
+
+      const options = this.profile.toInjectOptions(filePath, seed);
+      const result = adapter.inject(source, options);
+
+      if (result.points.length === 0) continue;
+
+      await writeFile(absPath, result.source, 'utf-8');
+      const modifiedHash = hashContent(result.source);
+
+      manifest.addFile(filePath, adapter.id, originalHash, modifiedHash, result);
+      totalInjections += result.points.length;
+      adaptersUsed.add(adapter.id);
+    }
+
+    // Copy runtime files for each adapter used
+    for (const adapterId of adaptersUsed) {
+      const adapter = this.registry.getAdapter(adapterId);
+      const info = adapter.getRuntimeInfo();
+      const destPath = join(rootDir, info.runtimeFileName);
+      await copyFile(info.runtimeSourcePath, destPath);
+      manifest.addRuntimeFile(info.runtimeFileName);
+    }
+
+    return manifest;
+  }
+
+  /**
+   * Scan files for recovery matches without modifying anything.
+   * Returns per-file match results for preview before recovery.
+   * @param {string} rootDir
+   * @param {Manifest} manifest
+   * @returns {Promise<{ file: string, matches: { line: number, content: string, reason: string }[] }[]>}
+   */
+  async scanAll(rootDir, manifest) {
+    const results = [];
+    const files = manifest.getFiles();
+
+    for (const [filePath, entry] of Object.entries(files)) {
+      const adapter = this.registry.getAdapter(entry.adapter);
+      if (!adapter || !adapter.scan) continue;
+
+      const absPath = join(rootDir, filePath);
+      let source;
+      try {
+        source = await readFile(absPath, 'utf-8');
+      } catch {
+        continue;
+      }
+
+      const matches = adapter.scan(source);
+      if (matches.length > 0) {
+        results.push({ file: filePath, matches });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Remove all injections from files listed in the manifest.
+   * @param {string} rootDir
+   * @param {Manifest} manifest
+   * @returns {Promise<{ filesRestored: number, injectionsRemoved: number }>}
+   */
+  async restoreAll(rootDir, manifest) {
+    let filesRestored = 0;
+    let injectionsRemoved = 0;
+
+    const files = manifest.getFiles();
+
+    for (const [filePath, entry] of Object.entries(files)) {
+      const adapter = this.registry.getAdapter(entry.adapter);
+      if (!adapter) {
+        console.warn(`No adapter found for "${entry.adapter}", skipping ${filePath}`);
+        continue;
+      }
+
+      const absPath = join(rootDir, filePath);
+      let source;
+      try {
+        source = await readFile(absPath, 'utf-8');
+      } catch {
+        console.warn(`File not found: ${filePath}, skipping`);
+        continue;
+      }
+
+      // Verify file hasn't been manually modified
+      const currentHash = hashContent(source);
+      if (!manifest.isFileUnmodified(filePath, currentHash)) {
+        console.warn(`Warning: ${filePath} was modified after injection. Restoring anyway.`);
+      }
+
+      const result = adapter.remove(source);
+      await writeFile(absPath, result.source, 'utf-8');
+      filesRestored++;
+      injectionsRemoved += result.removedCount;
+    }
+
+    // Remove runtime files
+    const { unlink } = await import('node:fs/promises');
+    for (const runtimeFile of manifest.runtimeFiles) {
+      try {
+        await unlink(join(rootDir, runtimeFile));
+      } catch {
+        // Already gone
+      }
+    }
+
+    return { filesRestored, injectionsRemoved };
+  }
+}

package/src/core/flake-analyzer.js

@@ -0,0 +1,64 @@
+/**
+ * Analyzes test results across multiple runs to classify tests as
+ * flaky, stable-pass, or always-failing.
+ *
+ * @param {Object[]} results - Array of run results, each with:
+ *   { runIndex, seed, exitCode, parsed, tests: [{ name, status }] }
+ * @returns {{ totalTests, flakyTests, stableTests, alwaysFailingTests }}
+ */
+export function analyzeFlakiness(results) {
+  // Build map: testName → { passedRuns: number[], failedRuns: number[] }
+  const testMap = new Map();
+
+  for (const run of results) {
+    if (!run.parsed || !run.tests) continue;
+
+    for (const test of run.tests) {
+      if (test.status === 'skipped') continue;
+
+      if (!testMap.has(test.name)) {
+        testMap.set(test.name, { file: test.file, passedRuns: [], failedRuns: [] });
+      }
+      const entry = testMap.get(test.name);
+      if (test.status === 'passed') {
+        entry.passedRuns.push(run.runIndex);
+      } else if (test.status === 'failed') {
+        entry.failedRuns.push(run.runIndex);
+      }
+    }
+  }
+
+  const flakyTests = [];
+  const stableTests = [];
+  const alwaysFailingTests = [];
+
+  for (const [name, entry] of testMap) {
+    const hasPasses = entry.passedRuns.length > 0;
+    const hasFailures = entry.failedRuns.length > 0;
+
+    if (hasPasses && hasFailures) {
+      const totalRuns = entry.passedRuns.length + entry.failedRuns.length;
+      flakyTests.push({
+        name,
+        file: entry.file,
+        passedRuns: entry.passedRuns,
+        failedRuns: entry.failedRuns,
+        flakyRate: entry.failedRuns.length / totalRuns,
+      });
+    } else if (hasPasses) {
+      stableTests.push({ name, file: entry.file, verdict: 'stable-pass' });
+    } else if (hasFailures) {
+      alwaysFailingTests.push({ name, file: entry.file, verdict: 'always-failing' });
+    }
+  }
+
+  // Sort flaky tests by flaky rate descending
+  flakyTests.sort((a, b) => b.flakyRate - a.flakyRate);
+
+  return {
+    totalTests: testMap.size,
+    flakyTests,
+    stableTests,
+    alwaysFailingTests,
+  };
+}