flakeradar 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 flakeradar contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,309 @@
+<div align="center">
+
+# 🛰️ flakeradar
+
+**Find, rank, and diagnose flaky tests in any language — straight from JUnit XML.**
+
+[![npm version](https://img.shields.io/npm/v/flakeradar?color=cb3837&logo=npm)](https://www.npmjs.com/package/flakeradar)
+[![CI](https://github.com/shravnn/flakeradar/actions/workflows/ci.yml/badge.svg)](https://github.com/shravnn/flakeradar/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/flakeradar?color=blue)](./LICENSE)
+[![node](https://img.shields.io/node/v/flakeradar)](https://nodejs.org)
+[![zero dependencies](https://img.shields.io/badge/runtime%20deps-0-brightgreen)](./package.json)
+
+Run your suite N times (or point it at your CI history) and flakeradar tells you
+**which tests are flaky, how often they fail, and _why_.**
+
+<img src="docs/demo.svg" alt="flakeradar ranking flaky tests with likely root causes" width="820">
+
+</div>
+
+---
+
+## Why
+
+Flaky tests are the most corrosive thing in a CI pipeline: they erode trust in
+the suite, waste hours on re-runs, and bury real bugs in the noise. Most tools
+just tell you a test *sometimes* fails. flakeradar goes further — it **ranks**
+flakes by how disruptive they are and **guesses the root cause**, turning "ugh,
+it failed again" into "here's the flaky test, here's how often, here's why."
+
+- 🌐 **Language-agnostic** — anything that emits JUnit XML: pytest, Jest, Vitest, Go, Gradle/Maven, RSpec, PHPUnit, Mocha…
+- 🧠 **Root-cause hints** — timing/async, resource, order-dependency, concurrency, external-dependency, or randomness
+- 📊 **Ranked, not just listed** — worst offenders first
+- 🐛 **Separates flaky from broken** — always-failing tests are real bugs, reported apart from the noise
+- 📎 **Shareable Markdown report** — paste straight into a GitHub issue or PR
+- 🚦 **CI-ready** — `--fail-on-flaky` gates merges; JSON output for dashboards
+- 📦 **Zero runtime dependencies** — one small package, nothing transitive
+
+## Contents
+
+- [Quick start](#quick-start)
+- [Two ways to use it](#two-ways-to-use-it)
+- [Framework recipes](#framework-recipes)
+- [Use it in CI](#use-it-in-ci)
+- [How it works](#how-it-works)
+- [Output & exit codes](#output-formats)
+- [Options](#options)
+- [Use as a library](#use-as-a-library)
+- [FAQ](#faq)
+
+---
+
+## Quick start
+
+No install needed:
+
+```bash
+# Analyze existing CI reports (each XML file = one run):
+npx flakeradar analyze "test-reports/**/*.xml"
+
+# Or run a suite repeatedly and watch for flakiness:
+npx flakeradar run -n 20 -- pytest --junitxml={out}
+```
+
+Or install it:
+
+```bash
+npm install -g flakeradar
+```
+
+Try it right now on the bundled example reports:
+
+```bash
+npx flakeradar analyze "examples/*.xml"
+```
+
+```text
+flakeradar — flakiness report
+
+Runs analyzed: 5   Green runs: 0%   Crashed: 0
+Unique tests: 5   Flaky: 3   Always-failing: 1
+
+Flaky tests (ranked, worst first):
+#  Test                                      Fails  Rate  Flips  Likely cause      Conf
+1  checkout.CheckoutTest::test_places_order    2/5   40%      4  timing/async       95%
+2  db.UserRepoTest::test_create_user           2/5   40%      3  order/state leak   95%
+3  api.PaymentTest::test_charge_card           1/5   20%      2  resource/network   95%
+
+Top offender: checkout.CheckoutTest::test_places_order
+  likely: timing/async (95% confident)
+  → Replace fixed sleeps with polling/awaits and raise timeouts.
+  sample failures:
+    • TimeoutError: timed out after 5000ms waiting for order confirmation
+
+Always-failing (broken every run — likely a real bug, not flakiness):
+  ✗ math.TaxTest::test_tax_rate  (5/5 failed)
+```
+
+---
+
+## Two ways to use it
+
+### 1. `run` — reproduce flakiness locally
+
+Run a test command many times back-to-back. Put the `{out}` token where your
+runner writes its JUnit XML; flakeradar swaps in a fresh path each run.
+
+```bash
+flakeradar run -n 25 -- pytest --junitxml={out}
+```
+
+If your runner writes to a fixed path (or many files), use `--report` instead:
+
+```bash
+flakeradar run -n 15 -r "build/test-results/test/*.xml" -- ./gradlew test
+```
+
+Stop as soon as a flake shows up:
+
+```bash
+flakeradar run -n 50 --stop-on-first-flaky -- go test ./... 2>&1
+```
+
+### 2. `analyze` — mine your CI history
+
+Already have per-run JUnit reports archived from CI? Point flakeradar at them.
+Each file is treated as one run by default.
+
+```bash
+flakeradar analyze "ci-artifacts/**/junit.xml"
+
+# One run per directory instead of per file:
+flakeradar analyze --group-by dir "ci-artifacts/*/"
+```
+
+---
+
+## Framework recipes
+
+| Framework | Command |
+|-----------|---------|
+| **pytest** | `flakeradar run -n 20 -- pytest --junitxml={out}` |
+| **Jest** | `flakeradar run -n 20 -r junit.xml -- npx jest --reporters=default --reporters=jest-junit` |
+| **Vitest** | `flakeradar run -n 20 -r junit.xml -- npx vitest run --reporter=junit --outputFile=junit.xml` |
+| **Go** | `flakeradar run -n 20 -- sh -c "gotestsum --junitfile={out} ./..."` |
+| **Gradle** | `flakeradar run -n 15 -r "build/test-results/test/*.xml" -- ./gradlew test` |
+| **Maven** | `flakeradar run -n 15 -r "target/surefire-reports/*.xml" -- mvn -q test` |
+| **RSpec** | `flakeradar run -n 20 -- bundle exec rspec --format RspecJunitFormatter --out {out}` |
+| **PHPUnit** | `flakeradar run -n 20 -- phpunit --log-junit {out}` |
+
+> Tip: for runners that only write to a fixed file, pass that path to `--report`
+> (`-r`). For runners that accept an output path, use the `{out}` token.
+
+---
+
+## Use it in CI
+
+Detect flakiness that slips past a single run, and comment a report on the PR.
+
+```yaml
+# .github/workflows/flaky.yml
+name: flaky-test-check
+on: [pull_request]
+
+jobs:
+  flaky:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 20 }
+
+      # ... set up your language + install deps ...
+
+      - name: Hunt for flaky tests
+        run: npx flakeradar run -n 15 --markdown -- pytest --junitxml={out} > flaky.md
+
+      - name: Comment report on the PR
+        if: always()
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          path: flaky.md
+```
+
+Or gate on your existing archived reports:
+
+```bash
+flakeradar analyze --fail-on-flaky "artifacts/**/*.xml"
+```
+
+---
+
+## How it works
+
+**Flakiness detection.** A test is **flaky** when it both passes and fails across
+the runs analyzed. A test that fails *every* run isn't flaky — it's **broken**, and
+flakeradar reports those separately so you don't confuse a real bug with noise.
+
+Each flaky test gets:
+
+- **Fails / Rate** — how many runs failed, and the failure rate.
+- **Flips** — how many times it switched between pass and fail across the run
+  sequence. High flips = highly nondeterministic.
+- **Score** — `failures + flips`, used to rank the worst offenders first.
+
+**Root-cause classification.** flakeradar scans each test's failure output and
+matches it against tuned signatures to guess a category:
+
+| Category | Typical signals | Suggested fix |
+|----------|-----------------|---------------|
+| `timing/async` | `TimeoutError`, `deadline exceeded`, `waited for` | Poll/await instead of fixed sleeps; raise timeouts |
+| `concurrency/race` | `data race`, `deadlock`, `ConcurrentModification` | Synchronize shared state; remove shared mutation |
+| `resource/network` | `EADDRINUSE`, `ECONNREFUSED`, `too many open files` | Isolate ports/temp files per test |
+| `order/state leak` | `duplicate key`, `already exists`, `unique constraint` | Reset fixtures/DB between tests; randomize order |
+| `external dep` | `503`, `429 rate limit`, `bad gateway` | Mock the dependency or add tolerant retries |
+| `randomness/time` | `random`, `uuid`, `Date.now`, `timezone` | Seed RNG; freeze the clock in tests |
+
+The classifier is a heuristic — a strong hint about where to look, not a verdict.
+
+---
+
+## Output formats
+
+| Flag | Output |
+|------|--------|
+| _(default)_ | Colored terminal report |
+| `--markdown` | GitHub-flavored Markdown (tables + collapsible failure samples) |
+| `--json` | Stable `flakeradar/v1` JSON for dashboards and scripts |
+
+### Exit codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | Success (no flaky tests, or `--fail-on-flaky` not set) |
+| `1` | Usage error, or no reports/test data found |
+| `2` | Flaky or always-failing tests detected **and** `--fail-on-flaky` was set |
+
+---
+
+## Options
+
+### `flakeradar run [options] -- <test command>`
+
+| Option | Description |
+|--------|-------------|
+| `-n, --runs <N>` | Number of times to run the suite (default `10`) |
+| `-r, --report <glob>` | Where the command writes its JUnit XML each run |
+| `-o, --output <dir>` | Directory for `{out}` report files (default `.flakeradar/runs`) |
+| `--stop-on-first-flaky` | Stop as soon as any flaky test is detected |
+| `--keep-going` | Keep running even if a run crashes (default: stop) |
+| `--fail-on-flaky` | Exit `2` if any flaky/always-failing test is found |
+| `--json` / `--markdown` | Choose output format |
+| `--no-color` | Disable ANSI colors |
+
+### `flakeradar analyze [options] <glob...>`
+
+| Option | Description |
+|--------|-------------|
+| `--group-by <file\|dir>` | Treat each file (default) or each directory as one run |
+| `--fail-on-flaky` | Exit `2` if any flaky/always-failing test is found |
+| `--json` / `--markdown` | Choose output format |
+| `--no-color` | Disable ANSI colors |
+
+---
+
+## Use as a library
+
+The analysis engine is exported too, for custom integrations:
+
+```ts
+import { parseJUnitXml, analyze, runFromResults } from "flakeradar";
+
+const runs = reportStrings.map((xml, i) => runFromResults(`run ${i + 1}`, parseJUnitXml(xml)));
+const report = analyze(runs);
+
+console.log(report.summary.flakyCount, "flaky tests");
+for (const t of report.flaky) {
+  console.log(t.id, t.failureRate, t.cause?.category);
+}
+```
+
+---
+
+## FAQ
+
+**How many runs do I need?** At least 2 to detect any flakiness. For confidence,
+10–30 runs is a good range — the rarer the flake, the more runs you need to catch it.
+
+**Does it need my CI or a service?** No. It's a local CLI. Nothing is uploaded.
+
+**My runner exits non-zero on failure — is that a problem?** No. flakeradar reads
+the JUnit report regardless of exit code. A run only counts as *crashed* if it
+produces no report at all.
+
+---
+
+## Contributing
+
+Issues and PRs welcome.
+
+```bash
+npm install
+npm test          # run the test suite (vitest)
+npm run build     # compile TypeScript to dist/
+node bin/flakeradar.js analyze "examples/*.xml"
+```
+
+## License
+
+[MIT](./LICENSE) © [shravnn](https://github.com/shravnn)

package/bin/flakeradar.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { main } from "../dist/cli.js";
+
+main(process.argv.slice(2))
+  .then((code) => {
+    process.exitCode = code;
+  })
+  .catch((err) => {
+    console.error(err instanceof Error ? err.stack ?? err.message : String(err));
+    process.exitCode = 1;
+  });

package/dist/analysis/classify.d.ts

@@ -0,0 +1,10 @@
+import type { CauseCategory, CauseGuess, FailureSample } from "../types.js";
+/**
+ * Classify the likely root cause of a flaky test from its failure samples.
+ * Returns the best-scoring category with a rough confidence, or `unknown`
+ * when no signal is found.
+ */
+export declare function classifyCause(samples: FailureSample[]): CauseGuess;
+/** Short human label for a cause category (used in tables). */
+export declare function causeLabel(category: CauseCategory): string;
+//# sourceMappingURL=classify.d.ts.map

package/dist/analysis/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../src/analysis/classify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAsG5E;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,UAAU,CAkDlE;AAED,+DAA+D;AAC/D,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAiB1D"}

package/dist/analysis/classify.js

@@ -0,0 +1,163 @@
+const p = (re, weight = 1) => ({ re, weight });
+/**
+ * Ordered strongest-signal-first. Each failure sample votes for categories;
+ * the category with the highest total weight wins. These patterns are tuned
+ * against real failure output from pytest, Jest, JUnit, RSpec and Go.
+ */
+const CATEGORIES = [
+    {
+        category: "timing",
+        hint: "Timing/async: a wait, sleep, or deadline is racing the code. Replace fixed sleeps with polling/awaits and raise timeouts.",
+        patterns: [
+            p(/\btimed?\s?out\b/i, 3),
+            p(/\btimeout(error|exception)?\b/i, 3),
+            p(/context deadline exceeded/i, 3),
+            p(/deadline exceeded/i, 2),
+            p(/\bwait(ed|ing)? for\b/i, 2),
+            p(/element .*not (visible|found|clickable)/i, 2),
+            p(/\bflaky\b/i, 1),
+            p(/eventually/i, 1),
+            p(/retry|retries exhausted/i, 1),
+        ],
+    },
+    {
+        category: "concurrency",
+        hint: "Concurrency/race: shared mutable state or a race condition. Look for goroutines/threads, locks, and unsynchronised access.",
+        patterns: [
+            p(/\bdata race\b/i, 3),
+            p(/race condition/i, 3),
+            p(/\bdeadlock\b/i, 3),
+            p(/concurrent (map|modification)/i, 3),
+            p(/ConcurrentModification/i, 3),
+            p(/\bgoroutine\b/i, 1),
+            p(/\bmutex\b|\block (held|contention)\b/i, 2),
+            p(/thread|threadpool/i, 1),
+        ],
+    },
+    {
+        category: "resource",
+        hint: "Resource/network: a port, socket, DB, or file handle is contended or unavailable. Isolate ports/temp files per test.",
+        patterns: [
+            p(/address already in use/i, 3),
+            p(/EADDRINUSE/i, 3),
+            p(/ECONNREFUSED|connection refused/i, 3),
+            p(/EADDRNOTAVAIL|ENOTFOUND|no such host/i, 2),
+            p(/port \d+ (is )?(already )?(in use|unavailable)/i, 3),
+            p(/too many open files|EMFILE/i, 3),
+            p(/broken pipe|EPIPE|ECONNRESET/i, 2),
+            p(/socket|bind|listen/i, 1),
+            p(/disk|ENOSPC|no space left/i, 2),
+        ],
+    },
+    {
+        category: "external",
+        hint: "External dependency: a downstream service, API, or rate limit is flaky. Mock the dependency or add tolerant retries.",
+        patterns: [
+            p(/\b5\d\d\b.*(error|status|response)/i, 2),
+            p(/\b(429|rate.?limit(ed|ing)?)\b/i, 3),
+            p(/\b503\b|service unavailable/i, 3),
+            p(/\b502\b|bad gateway/i, 2),
+            p(/upstream|downstream service/i, 2),
+            p(/gateway timeout/i, 2),
+            p(/\bDNS\b/i, 1),
+        ],
+    },
+    {
+        category: "order-dependency",
+        hint: "Order/state leakage: the test depends on state left by another test. Reset fixtures/DB between tests and randomise order.",
+        patterns: [
+            p(/already exists|duplicate key|unique constraint/i, 3),
+            p(/leftover|not cleaned up|dirty state/i, 2),
+            p(/expected .* to be empty/i, 2),
+            p(/no such (row|record|entity)|not found/i, 1),
+            p(/global (state|variable)/i, 2),
+            p(/cache (hit|stale|invalidation)/i, 1),
+            p(/singleton/i, 1),
+        ],
+    },
+    {
+        category: "randomness",
+        hint: "Randomness/time: nondeterministic inputs (random, UUIDs, current date/time). Seed RNG and freeze the clock in tests.",
+        patterns: [
+            p(/\brandom\b|\bseed\b/i, 2),
+            p(/\bUUID\b/i, 1),
+            p(/current (date|time)|now\(\)|Date\.now|time\.Now/i, 2),
+            p(/timezone|utc|locale/i, 1),
+            p(/floating point|precision|rounding/i, 1),
+            p(/ordering of (keys|map|set)/i, 2),
+            p(/non.?deterministic/i, 2),
+        ],
+    },
+];
+/**
+ * Classify the likely root cause of a flaky test from its failure samples.
+ * Returns the best-scoring category with a rough confidence, or `unknown`
+ * when no signal is found.
+ */
+export function classifyCause(samples) {
+    const haystacks = samples
+        .flatMap((s) => [s.message ?? "", s.details ?? ""])
+        .filter((s) => s.length > 0);
+    if (haystacks.length === 0) {
+        return {
+            category: "unknown",
+            confidence: 0,
+            hint: "No failure output was captured, so the cause can't be inferred. Enable verbose test output to help.",
+        };
+    }
+    const scores = new Map();
+    for (const def of CATEGORIES) {
+        let score = 0;
+        for (const hay of haystacks) {
+            for (const { re, weight } of def.patterns) {
+                if (re.test(hay))
+                    score += weight;
+            }
+        }
+        if (score > 0)
+            scores.set(def.category, score);
+    }
+    if (scores.size === 0) {
+        return {
+            category: "unknown",
+            confidence: 0.1,
+            hint: "Failure text didn't match known flakiness signatures. Inspect the assertion and recent changes manually.",
+        };
+    }
+    let best = "unknown";
+    let bestScore = 0;
+    let total = 0;
+    for (const [cat, score] of scores) {
+        total += score;
+        if (score > bestScore) {
+            best = cat;
+            bestScore = score;
+        }
+    }
+    const def = CATEGORIES.find((c) => c.category === best);
+    // Confidence blends absolute evidence with dominance over other categories.
+    const dominance = bestScore / total;
+    const saturation = Math.min(1, bestScore / 4);
+    const confidence = Math.round(Math.min(0.95, 0.35 + 0.4 * dominance + 0.25 * saturation) * 100) / 100;
+    return { category: best, confidence, hint: def.hint };
+}
+/** Short human label for a cause category (used in tables). */
+export function causeLabel(category) {
+    switch (category) {
+        case "timing":
+            return "timing/async";
+        case "concurrency":
+            return "concurrency/race";
+        case "resource":
+            return "resource/network";
+        case "external":
+            return "external dep";
+        case "order-dependency":
+            return "order/state leak";
+        case "randomness":
+            return "randomness/time";
+        case "unknown":
+            return "unknown";
+    }
+}
+//# sourceMappingURL=classify.js.map

package/dist/analysis/classify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/analysis/classify.ts"],"names":[],"mappings":"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"}

package/dist/analysis/flakiness.d.ts

@@ -0,0 +1,11 @@
+import type { AnalysisReport, Run, TestResult, TestVerdict } from "../types.js";
+/** Compare flaky verdicts: worst (most worth investigating) first. */
+export declare function compareFlaky(a: TestVerdict, b: TestVerdict): number;
+/**
+ * Analyze a sequence of runs and produce a ranked flakiness report.
+ * Run order is significant — flips are computed along it.
+ */
+export declare function analyze(runs: Run[]): AnalysisReport;
+/** Convenience: build a Run from already-parsed results. */
+export declare function runFromResults(label: string, results: TestResult[]): Run;
+//# sourceMappingURL=flakiness.d.ts.map

package/dist/analysis/flakiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flakiness.d.ts","sourceRoot":"","sources":["../../src/analysis/flakiness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAEd,GAAG,EAEH,UAAU,EAEV,WAAW,EACZ,MAAM,aAAa,CAAC;AA4JrB,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,MAAM,CAKnE;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,cAAc,CAsBnD;AAED,4DAA4D;AAC5D,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,GAAG,CAExE"}