argus-reviewer-e2e 0.1.2

package/dist/index/scan.js

@@ -0,0 +1,209 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import ts from 'typescript';
+import { writeAtomicJson } from '../fsutil.js';
+export const INDEX_SCHEMA_VERSION = 1;
+const EXCLUDE_DIRS = new Set([
+    'node_modules', 'dist', 'dist-e2e-vision', '.git', 'coverage',
+    '.vision-e2e-cache', '.argus-reviewer-cache', 'argus-reviewer-report', 'vision-e2e-report', 'journal',
+]);
+const SOURCE_RE = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+const LOCKFILE_RE = /^(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb|composer\.lock|Gemfile\.lock|Cargo\.lock|poetry\.lock)$/;
+const BINARY_RE = /\.(png|jpe?g|gif|webp|ico|woff2?|ttf|otf|eot|mp4|webm|pdf|zip|gz|tar|wasm|so|dylib|exe|bin)$/i;
+const MAX_FILES = 50_000;
+async function walk(root, dir, out) {
+    if (out.length >= MAX_FILES)
+        return;
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return; // unreadable/missing dirs are skipped, never fatal
+    }
+    for (const e of entries) {
+        if (out.length >= MAX_FILES)
+            return;
+        if (e.name.startsWith('.') && e.name !== '.storybook')
+            continue;
+        const p = join(dir, e.name);
+        if (e.isDirectory()) {
+            if (EXCLUDE_DIRS.has(e.name))
+                continue;
+            await walk(root, p, out);
+        }
+        else if (e.isFile()) {
+            if (LOCKFILE_RE.test(e.name) || BINARY_RE.test(e.name))
+                continue;
+            out.push(p);
+        }
+    }
+}
+function sha256(buf) {
+    return createHash('sha256').update(buf).digest('hex').slice(0, 16);
+}
+/** Resolve an import specifier to a repo-relative path when it's local. */
+function resolveImport(spec, fromFile, files) {
+    if (!spec.startsWith('.'))
+        return undefined;
+    const base = resolve(dirname(fromFile), spec);
+    const exts = ['ts', 'tsx', 'js', 'jsx', 'mts', 'cts', 'mjs', 'cjs'];
+    const candidates = [base, ...exts.map((e) => `${base}.${e}`), ...exts.map((e) => `${base}/index.${e}`)];
+    for (const cand of candidates) {
+        if (files.has(cand))
+            return cand;
+    }
+    return undefined;
+}
+/** Memoized per directory — sibling files share the same ancestor walk. */
+async function nearestPackageVersion(file, root, cache) {
+    const start = dirname(file);
+    const cached = cache.get(start);
+    if (cached !== undefined)
+        return cached;
+    const promise = (async () => {
+        let dir = start;
+        // Path-boundary containment: `startsWith(root)` alone would accept a
+        // sibling like `/repo-extra`; require an exact match or a subpath.
+        while (dir === root || dir.startsWith(root + '/')) {
+            try {
+                const raw = await readFile(join(dir, 'package.json'), 'utf8');
+                const parsed = JSON.parse(raw);
+                if (parsed.version)
+                    return parsed.version;
+            }
+            catch {
+                // no package.json at this level — keep walking up
+            }
+            if (dir === root)
+                break;
+            dir = dirname(dir);
+        }
+        return undefined;
+    })();
+    cache.set(start, promise);
+    return promise;
+}
+function inferPurpose(source, isSource) {
+    if (!isSource)
+        return undefined;
+    const doc = source.match(/^\s*\/\*\*([\s\S]*?)\*\//);
+    if (doc) {
+        const first = (doc[1] ?? '').split('\n').map((l) => l.replace(/^\s*\*\s?/, '').trim()).filter(Boolean)[0];
+        if (first !== undefined && first !== '')
+            return first.slice(0, 160);
+    }
+    const exports_ = [...source.matchAll(/export\s+(?:async\s+)?(?:function|class|const|interface|type)\s+(\w+)/g)]
+        .map((m) => m[1])
+        .slice(0, 4);
+    if (exports_.length > 0)
+        return `exports: ${exports_.join(', ')}`;
+    return undefined;
+}
+/** Scan a repo into a RepoIndex. Never throws on individual file failures. */
+export async function scanRepo(root) {
+    const abs = resolve(root);
+    const files = [];
+    await walk(abs, abs, files);
+    const fileSet = new Set(files);
+    const pkgCache = new Map();
+    // Bounded concurrency — Promise.all over up to 50k files would exhaust
+    // file descriptors. Chunks of 64 keep I/O saturated without EMFILE risk.
+    const CONCURRENCY = 64;
+    const sorted = files.sort();
+    const entries = [];
+    for (let i = 0; i < sorted.length; i += CONCURRENCY) {
+        const chunk = sorted.slice(i, i + CONCURRENCY);
+        const results = await Promise.allSettled(chunk.map(async (file) => {
+            const rel = relative(abs, file);
+            let buf;
+            try {
+                buf = await readFile(file);
+            }
+            catch {
+                return undefined; // unreadable files are skipped, never fatal
+            }
+            const isSource = SOURCE_RE.test(file);
+            const text = isSource ? buf.toString('utf8') : undefined;
+            const imports = [];
+            if (isSource && text !== undefined) {
+                try {
+                    const info = ts.preProcessFile(text, true, true);
+                    for (const spec of [...info.importedFiles.map((f) => f.fileName), ...info.referencedFiles.map((f) => f.fileName)]) {
+                        const dep = resolveImport(spec, file, fileSet);
+                        if (dep !== undefined)
+                            imports.push(relative(abs, dep));
+                    }
+                }
+                catch {
+                    // unparseable file — entry still exists with empty imports
+                }
+            }
+            const purpose = inferPurpose(text?.slice(0, 4000) ?? '', isSource);
+            const packageVersion = await nearestPackageVersion(file, abs, pkgCache);
+            const entry = { path: rel, imports, importedBy: [], contentHash: sha256(buf) };
+            if (purpose !== undefined)
+                entry.purpose = purpose;
+            if (packageVersion !== undefined)
+                entry.packageVersion = packageVersion;
+            return entry;
+        }));
+        for (const r of results) {
+            if (r.status === 'fulfilled' && r.value !== undefined)
+                entries.push(r.value);
+        }
+    }
+    // Build reverse edges in a second pass — no shared-map races during the
+    // parallel scan.
+    const importedBy = new Map();
+    for (const e of entries) {
+        for (const dep of e.imports) {
+            const list = importedBy.get(dep) ?? [];
+            list.push(e.path);
+            importedBy.set(dep, list);
+        }
+    }
+    for (const e of entries) {
+        e.importedBy = (importedBy.get(e.path) ?? []).sort();
+        e.imports.sort();
+    }
+    return {
+        schemaVersion: INDEX_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        root: abs,
+        entries,
+    };
+}
+export async function writeIndex(index, outPath) {
+    await writeAtomicJson(outPath, index);
+}
+const MAX_INDEX_BYTES = 32 * 1024 * 1024;
+function isIndexEntry(v) {
+    const e = v;
+    return (typeof e === 'object' &&
+        e !== null &&
+        typeof e.path === 'string' &&
+        Array.isArray(e.imports) &&
+        Array.isArray(e.importedBy) &&
+        typeof e.contentHash === 'string');
+}
+/** Load a previously written index; undefined when absent, oversized, or malformed. */
+export async function readIndex(path) {
+    try {
+        const stat = await import('node:fs/promises').then((fs) => fs.stat(path));
+        if (stat.size > MAX_INDEX_BYTES)
+            return undefined;
+        const raw = await readFile(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== INDEX_SCHEMA_VERSION || !Array.isArray(parsed.entries)) {
+            return undefined;
+        }
+        if (!parsed.entries.every(isIndexEntry))
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/journal/build.d.ts

@@ -0,0 +1,15 @@
+import { TestReport } from '../report/run.js';
+import { ErrorRecord, JournalEntry } from './schema.js';
+/** Assemble the immutable run record — lives here so the schema mapping is owned by the journal module. */
+export declare function buildJournalEntry(opts: {
+    runId: string;
+    repo: string;
+    commitSha: string | undefined;
+    branch: string | undefined;
+    startedAt: Date;
+    durationMs: number;
+    reports: TestReport[];
+    runErrors: ErrorRecord[];
+    /** Overall run outcome — aborts before the first test must record ok:false. */
+    ok?: boolean;
+}): JournalEntry;

package/dist/journal/build.js

@@ -0,0 +1,47 @@
+import { JOURNAL_SCHEMA_VERSION } from './schema.js';
+/** Assemble the immutable run record — lives here so the schema mapping is owned by the journal module. */
+export function buildJournalEntry(opts) {
+    const { reports } = opts;
+    const failed = reports.filter((r) => !r.ok).length;
+    return {
+        schemaVersion: JOURNAL_SCHEMA_VERSION,
+        runId: opts.runId,
+        repo: opts.repo,
+        commitSha: opts.commitSha,
+        branch: opts.branch,
+        startedAt: opts.startedAt.toISOString(),
+        durationMs: opts.durationMs,
+        ok: (opts.ok ?? true) && failed === 0,
+        totals: {
+            tests: reports.length,
+            passed: reports.length - failed,
+            failed,
+            visionCalls: reports.reduce((s, r) => s + r.visionCalls, 0),
+            visionCostUsd: reports.reduce((s, r) => s + r.visionCostUsd, 0),
+            budgetExceeded: reports.some((r) => r.budgetExceeded),
+        },
+        tests: reports.map((r) => ({
+            name: r.name,
+            file: r.file,
+            ok: r.ok,
+            durationMs: r.durationMs,
+            ...(r.failureMessage !== undefined ? { failureMessage: r.failureMessage } : {}),
+            steps: r.steps.map((s) => ({
+                instruction: s.instruction,
+                action: s.action,
+                ok: s.ok,
+                ...(s.reason !== undefined ? { reason: s.reason } : {}),
+                ...(s.healed ? { healed: true } : {}),
+                ...(s.model !== undefined ? { model: s.model } : {}),
+            })),
+            asserts: r.asserts.map((a) => ({
+                question: a.question,
+                verdict: a.verdict,
+                reasoning: a.reasoning,
+                ...(a.cached ? { cached: true } : {}),
+            })),
+            visionCalls: r.visionCalls,
+        })),
+        errors: opts.runErrors,
+    };
+}

package/dist/journal/schema.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Journal schema — one append-only record per run. Evidence store, not logs:
+ * every error and non-fatal recovery is a structured entry so failure modes
+ * can be analyzed across runs.
+ */
+export declare const JOURNAL_SCHEMA_VERSION = 1;
+export interface ErrorRecord {
+    /** Pipeline stage: boot | target | locate | assert | heal | report | index */
+    stage: string;
+    message: string;
+    /** Minimal context: step instruction, model, page URL — never secrets. */
+    context?: string;
+}
+export interface JournalStep {
+    instruction: string;
+    action: string;
+    ok: boolean;
+    reason?: string;
+    healed?: boolean;
+    model?: string;
+}
+export interface JournalAssert {
+    question: string;
+    verdict: 'pass' | 'fail';
+    reasoning: string;
+    cached?: boolean;
+}
+export interface JournalTest {
+    name: string;
+    file: string;
+    ok: boolean;
+    durationMs: number;
+    failureMessage?: string;
+    steps: JournalStep[];
+    asserts: JournalAssert[];
+    visionCalls: number;
+}
+export interface JournalEntry {
+    schemaVersion: typeof JOURNAL_SCHEMA_VERSION;
+    runId: string;
+    /** Repo identifier: `owner/name` from git remote, else directory basename. */
+    repo: string;
+    commitSha: string | undefined;
+    branch: string | undefined;
+    startedAt: string;
+    durationMs: number;
+    ok: boolean;
+    totals: {
+        tests: number;
+        passed: number;
+        failed: number;
+        visionCalls: number;
+        visionCostUsd: number;
+        budgetExceeded: boolean;
+    };
+    tests: JournalTest[];
+    /** Non-fatal recoveries + fatal errors — the failure-mode dataset. */
+    errors: ErrorRecord[];
+}

package/dist/journal/schema.js

@@ -0,0 +1,6 @@
+/**
+ * Journal schema — one append-only record per run. Evidence store, not logs:
+ * every error and non-fatal recovery is a structured entry so failure modes
+ * can be analyzed across runs.
+ */
+export const JOURNAL_SCHEMA_VERSION = 1;

package/dist/journal/store.d.ts

@@ -0,0 +1,10 @@
+import { JournalEntry } from './schema.js';
+export declare function journalDir(cacheDir: string): string;
+/**
+ * Append one immutable run record. Atomic via tmp+rename (src/fsutil.ts).
+ * Returns the written path, or undefined on failure — a journal write must
+ * never abort a run.
+ */
+export declare function writeJournal(cacheDir: string, entry: JournalEntry): Promise<string | undefined>;
+/** runId: timestamp + short random suffix — sortable and collision-safe. */
+export declare function newRunId(): string;

package/dist/journal/store.js

@@ -0,0 +1,26 @@
+import { join } from 'node:path';
+import { writeAtomicJson } from '../fsutil.js';
+export function journalDir(cacheDir) {
+    return join(cacheDir, 'journal');
+}
+/**
+ * Append one immutable run record. Atomic via tmp+rename (src/fsutil.ts).
+ * Returns the written path, or undefined on failure — a journal write must
+ * never abort a run.
+ */
+export async function writeJournal(cacheDir, entry) {
+    const path = join(journalDir(cacheDir), `${entry.runId}.json`);
+    try {
+        await writeAtomicJson(path, entry);
+        return path;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** runId: timestamp + short random suffix — sortable and collision-safe. */
+export function newRunId() {
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `${ts}-${rand}`;
+}

package/dist/live.d.ts

@@ -0,0 +1,2 @@
+export declare function liveLogPath(dir: string): string;
+export declare function liveLog(dir: string, source: string, level: string, msg: string): void;

package/dist/live.js

@@ -0,0 +1,46 @@
+/**
+ * Best-effort live log: appends NDJSON lines to <dir>/live.ndjson (the
+ * run's cache dir, normally <cwd>/.argus-reviewer-cache) so the local
+ * dashboard (`npm run app`) can follow runs started from any terminal.
+ * Bounded to ~1MB; never throws — observability must not break runs.
+ */
+import { appendFileSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync, } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+const MAX_BYTES = 1024 * 1024;
+const KEEP_BYTES = 256 * 1024;
+const MAX_MSG = 500;
+export function liveLogPath(dir) {
+    return resolve(join(dir, 'live.ndjson'));
+}
+export function liveLog(dir, source, level, msg) {
+    try {
+        const path = liveLogPath(dir);
+        // Non-recursive: callers pass the cache dir, which the flow store already
+        // creates. Recursive mkdir can spin forever on Node >= 26 when the path
+        // is a phantom procfs entry.
+        try {
+            mkdirSync(dirname(path));
+        }
+        catch { /* already exists or unwritable — appendFileSync decides */ }
+        const line = JSON.stringify({ ts: Date.now(), source, level, msg: msg.slice(0, MAX_MSG) }) + '\n';
+        try {
+            if (statSync(path).size > MAX_BYTES) {
+                const buf = readFileSync(path);
+                // Keep the tail but discard through the first newline so every
+                // retained line is a complete NDJSON record.
+                const start = Math.max(0, buf.length - KEEP_BYTES);
+                const nl = buf.indexOf(0x0a, start);
+                // Atomic replace gives live.ndjson a new inode, which is how
+                // tailers detect that rotation happened and re-seed. The tmp name is
+                // per-process so concurrent argus runs can't clobber each other's
+                // half-written rotation.
+                const tmp = `${path}.${process.pid}.tmp`;
+                writeFileSync(tmp, nl === -1 ? buf.subarray(start) : buf.subarray(nl + 1));
+                renameSync(tmp, path);
+            }
+        }
+        catch { /* file doesn't exist yet */ }
+        appendFileSync(path, line);
+    }
+    catch { /* live log is best-effort */ }
+}

package/dist/log.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Tiny leveled logger. Level comes from ARGUS_DEBUG=1 or config.logLevel;
+ * default 'warn'. Debug emits model call excerpts and recovery paths —
+ * never secret values.
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface Logger {
+    level: LogLevel;
+    debug: (msg: string) => void;
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+}
+export declare function createLogger(level: LogLevel, sink: {
+    err: (line: string) => void;
+}, live?: (level: LogLevel, msg: string) => void): Logger;
+export declare function resolveLogLevel(env: Record<string, string | undefined>, configured?: string): LogLevel;

package/dist/log.js

@@ -0,0 +1,24 @@
+const ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+export function createLogger(level, sink, live) {
+    const emit = (l, msg) => {
+        if (ORDER[l] >= ORDER[level])
+            sink.err(`[${l}] ${msg}`);
+        live?.(l, msg);
+    };
+    // `live` receives every level regardless of `level` — the local dashboard
+    // wants full detail even when the console stays quiet.
+    return {
+        level,
+        debug: (m) => emit('debug', m),
+        info: (m) => emit('info', m),
+        warn: (m) => emit('warn', m),
+        error: (m) => emit('error', m),
+    };
+}
+export function resolveLogLevel(env, configured) {
+    if (env.ARGUS_DEBUG === '1' || env.ARGUS_DEBUG === 'true')
+        return 'debug';
+    if (configured !== undefined && configured in ORDER)
+        return configured;
+    return 'warn';
+}

package/dist/report/comment.d.ts

@@ -0,0 +1,13 @@
+import { RunReport } from './run.js';
+export declare const SENTINEL = "<!-- argus-reviewer -->";
+export interface CommentOptions {
+    /** Link to the workflow run or artifact index. */
+    runUrl?: string;
+}
+/** Render the sticky PR comment markdown from a run report (or a missing-key state). */
+export declare function renderComment(report: RunReport | undefined, opts?: CommentOptions & {
+    missingKey?: boolean;
+}): string;
+export type CheckConclusion = 'success' | 'failure' | 'neutral';
+/** Map a run report (and optional missing-key flag) to a check-run conclusion. */
+export declare function conclusionFromReport(report: RunReport | undefined, missingKey?: boolean): CheckConclusion;

package/dist/report/comment.js

@@ -0,0 +1,135 @@
+export const SENTINEL = '<!-- argus-reviewer -->';
+function formatUsd(n) {
+    return `$${(n ?? 0).toFixed(6)}`;
+}
+function statusLine(report, missingKey) {
+    if (missingKey)
+        return '## argus-reviewer ⚪ skipped — no OpenRouter key';
+    if (!report)
+        return '## argus-reviewer ⚪ no report';
+    const emoji = report.ok ? '✅' : '❌';
+    const status = report.ok ? 'PASS' : 'FAIL';
+    const budget = report.totals.budgetExceeded ? ' (budget cap exceeded)' : '';
+    return `## argus-reviewer ${emoji} ${status}${budget}`;
+}
+function testRows(tests) {
+    const lines = ['### Tests', ''];
+    lines.push('| Test | Result | Calls | Cost | Failure |');
+    lines.push('| --- | --- | --- | --- | --- |');
+    for (const t of tests) {
+        const result = t.ok ? '✅ pass' : '❌ fail';
+        const failure = t.failureMessage ? t.failureMessage.replace(/\|/g, '\\|') : '';
+        lines.push(`| ${t.name} | ${result} | ${t.visionCalls} | ${formatUsd(t.visionCostUsd)} | ${failure} |`);
+    }
+    return lines;
+}
+function costRows(totals) {
+    const lines = ['### Cost ledger', ''];
+    lines.push('| Line item | Value |');
+    lines.push('| --- | --- |');
+    lines.push(`| Vision calls | ${totals.visionCalls} |`);
+    const perCall = totals.visionCalls > 0 ? formatUsd(totals.visionCostUsd / totals.visionCalls) : '$0.00';
+    lines.push(`| Per-call cost (avg) | ${perCall} |`);
+    for (const model of Object.keys(totals.callsByModel).sort()) {
+        lines.push(`| Calls (${model}) | ${totals.callsByModel[model]} |`);
+        lines.push(`| Spend (${model}) | ${formatUsd(totals.costByModel[model] ?? 0)} |`);
+    }
+    lines.push(`| Total vision spend | ${formatUsd(totals.visionCostUsd)} |`);
+    lines.push(`| Sandbox seconds | ${totals.sandboxSeconds.toFixed(1)}s |`);
+    return lines;
+}
+function healRows(tests) {
+    const lines = ['### Heal events', ''];
+    const heals = tests.flatMap((t) => t.healEvents);
+    if (heals.length === 0) {
+        lines.push('No heals this run.');
+    }
+    else {
+        for (const h of heals) {
+            lines.push(`- \`${h.instruction}\` healed with ${h.model ?? 'unknown model'}`);
+        }
+    }
+    return lines;
+}
+function assertRows(tests) {
+    const lines = ['### Assertions', ''];
+    let any = false;
+    for (const t of tests) {
+        if (t.asserts.length === 0)
+            continue;
+        any = true;
+        lines.push(`**${t.name}**`);
+        for (const a of t.asserts) {
+            const icon = a.verdict === 'pass' ? '✅' : '❌';
+            lines.push(`- ${icon} *${a.question}* — ${a.reasoning}`);
+        }
+        lines.push('');
+    }
+    if (!any) {
+        lines.push('No assertions recorded.');
+    }
+    return lines;
+}
+function evidenceRows(videos, runUrl) {
+    const lines = ['### Evidence', ''];
+    for (const v of videos) {
+        lines.push(`- video: ${v}`);
+    }
+    if (runUrl) {
+        lines.push(`- [workflow run / artifacts](${runUrl})`);
+    }
+    if (videos.length === 0 && !runUrl) {
+        lines.push('No artifact links configured.');
+    }
+    return lines;
+}
+function missingKeyBody() {
+    return [
+        '',
+        '`OPENROUTER_API_KEY` is not configured. Add it as a repository or workflow secret to run argus-reviewer.',
+        '',
+        'This status is intentionally neutral, not a failure.',
+        '',
+    ];
+}
+function noReportBody() {
+    return [
+        '',
+        'No run report was produced. The run may have failed before writing reports.',
+        '',
+    ];
+}
+/** Render the sticky PR comment markdown from a run report (or a missing-key state). */
+export function renderComment(report, opts = {}) {
+    const lines = [SENTINEL, ''];
+    lines.push(statusLine(report, opts.missingKey ?? false));
+    lines.push('');
+    if (opts.missingKey) {
+        lines.push(...missingKeyBody());
+    }
+    else if (!report) {
+        lines.push(...noReportBody());
+    }
+    else {
+        lines.push(`**Summary:** ${report.totals.passed}/${report.totals.tests} passed · ` +
+            `${report.totals.visionCalls} vision calls · ` +
+            `${formatUsd(report.totals.visionCostUsd)} spend · ` +
+            `${report.totals.sandboxSeconds.toFixed(1)}s sandbox · ` +
+            `${(report.durationMs / 1000).toFixed(1)}s wall`);
+        lines.push('');
+        lines.push(...testRows(report.tests));
+        lines.push(...costRows(report.totals));
+        lines.push(...healRows(report.tests));
+        lines.push(...assertRows(report.tests));
+        lines.push(...evidenceRows(report.artifacts.videos, opts.runUrl));
+    }
+    return lines.join('\n');
+}
+/** Map a run report (and optional missing-key flag) to a check-run conclusion. */
+export function conclusionFromReport(report, missingKey = false) {
+    if (missingKey)
+        return 'neutral';
+    if (!report)
+        return 'failure';
+    return report.ok ? 'success' : 'failure';
+}

package/dist/report/junit.d.ts

@@ -0,0 +1,10 @@
+export interface JunitCase {
+    name: string;
+    className: string | undefined;
+    durationMs: number;
+    ok: boolean;
+    failureMessage: string | undefined;
+}
+/** Render a JUnit XML report: one <testcase> per test with pass/fail + duration. */
+export declare function renderJunitXml(suiteName: string, cases: JunitCase[]): string;
+export declare function writeJunitXml(path: string, suiteName: string, cases: JunitCase[]): Promise<void>;