@mindlace/chreode 0.1.0 → 0.2.0

package/dist/reporters/vitest.js

@@ -0,0 +1,47 @@
+import { repoRelative, truncateError } from '../flakes/log.js';
+import { defaultAppend, headSha, resolveKind, wants } from './options.js';
+/**
+ * Records every test that passed after at least one retry. vitest reporters are a root-level
+ * option, so instantiate this in the root config's `reporters`; it sees every project and
+ * filters with `projects`. Imports vitest's types only.
+ */
+export class VitestFlakeReporter {
+    options;
+    append;
+    constructor(options = {}) {
+        this.options = options;
+        this.append = options.append ?? defaultAppend;
+    }
+    onTestRunEnd(testModules) {
+        for (const testModule of testModules) {
+            const project = testModule.project.name;
+            if (!wants(this.options.projects, project))
+                continue;
+            const where = { project, file: repoRelative(testModule.moduleId) };
+            this.walk(testModule.children.array(), [], where);
+        }
+    }
+    walk(entities, titles, where) {
+        for (const entity of entities) {
+            if (entity.type === 'suite') {
+                this.walk(entity.children.array(), [...titles, entity.name], where);
+                continue;
+            }
+            const result = entity.result();
+            if (result.state !== 'passed' || (entity.diagnostic()?.retryCount ?? 0) === 0)
+                continue;
+            this.append({
+                kind: resolveKind(this.options.kind, where.project, where.project || 'unit'),
+                runner: 'vitest',
+                project: where.project,
+                file: where.file,
+                title: [...titles, entity.name].join(' › '),
+                // A test that passed on retry still reports the errors of its failed attempts.
+                firstAttemptError: truncateError(result.errors?.[0]?.message),
+                ...headSha(),
+                at: new Date().toISOString()
+            });
+        }
+    }
+}
+export default VitestFlakeReporter;

package/dist/run/stderr.d.ts

@@ -1,4 +1,5 @@
 import type { AllowlistEntry } from '../config/types.js';
+export declare function stripAnsi(s: string): string;
 /** Classify captured stderr line by line: blank and allowlisted lines are benign,
  *  everything else is returned ANSI-stripped. */
 export declare function policeStderr(buffer: string, allowlist: readonly AllowlistEntry[]): {

package/dist/run/stderr.js

@@ -1,12 +1,15 @@
 // ANSI SGR color codes must not defeat allowlist matching. The escape character is built at
 // runtime so no control character appears in source (keeps no-control-regex quiet).
 const ANSI_SGR = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g');
+export function stripAnsi(s) {
+    return s.replace(ANSI_SGR, '');
+}
 /** Classify captured stderr line by line: blank and allowlisted lines are benign,
  *  everything else is returned ANSI-stripped. */
 export function policeStderr(buffer, allowlist) {
     const offendingLines = buffer
         .split(/\r?\n/)
-        .map((line) => line.replace(ANSI_SGR, ''))
+        .map(stripAnsi)
         .filter((line) => line.trim() !== '')
         .filter((line) => !allowlist.some((entry) => {
         entry.pattern.lastIndex = 0;

package/dist/signoff/plan.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedConfig, ResolvedStep, RuleConfig } from '../config/types.js';
+import type { Matcher, ResolvedConfig, ResolvedStep, RuleConfig } from '../config/types.js';
 export declare class PlanError extends Error {
     constructor(message: string);
 }
@@ -38,6 +38,7 @@ export interface Plan {
     /** Steps that would have run but for --skip: these go in the status description. */
     skippedByFlag: string[];
 }
+export declare function matchesAny(path: string, matchers: Matcher | Matcher[]): boolean;
 export declare function matchRule(path: string, rules: readonly RuleConfig[]): RuleConfig | null;
 export declare function allTriggers(steps: readonly ResolvedStep[]): string[];
 /** Rules can only make a run smaller by matching: an unmatched path fires everything. */

package/dist/signoff/plan.js

@@ -14,10 +14,12 @@ function tester(m) {
         return m.test(path);
     };
 }
+export function matchesAny(path, matchers) {
+    return (Array.isArray(matchers) ? matchers : [matchers]).some((m) => tester(m)(path));
+}
 export function matchRule(path, rules) {
     for (const rule of rules) {
-        const matchers = Array.isArray(rule.match) ? rule.match : [rule.match];
-        if (matchers.some((m) => tester(m)(path)))
+        if (matchesAny(path, rule.match))
             return rule;
     }
     return null;

package/dist/signoff/preconditions.d.ts

@@ -7,4 +7,6 @@ export interface Preconditions {
     /** git user.email: named in the status description. */
     signer: string;
 }
-export declare function checkPreconditions(baseBranch: string, exec?: Exec): Preconditions;
+export declare function checkPreconditions(baseBranch: string, exec?: Exec, opts?: {
+    flakes: boolean;
+}): Preconditions;

package/dist/signoff/preconditions.js

@@ -1,3 +1,4 @@
+import { FLAKE_LOG_FILE } from '../flakes/log.js';
 import { defaultExec } from '../run/exec.js';
 export class PreconditionError extends Error {
     constructor(message) {
@@ -5,7 +6,7 @@ export class PreconditionError extends Error {
         this.name = 'PreconditionError';
     }
 }
-export function checkPreconditions(baseBranch, exec = defaultExec) {
+export function checkPreconditions(baseBranch, exec = defaultExec, opts = { flakes: false }) {
     if (exec('git', ['status', '--porcelain']).trim() !== '') {
         throw new PreconditionError('working tree is dirty; commit or stash before signing off');
     }
@@ -29,6 +30,15 @@ export function checkPreconditions(baseBranch, exec = defaultExec) {
     if (behind !== '') {
         throw new PreconditionError('HEAD is behind its upstream; pull before signing off');
     }
+    if (opts.flakes) {
+        try {
+            exec('git', ['check-ignore', '-q', FLAKE_LOG_FILE]);
+        }
+        catch {
+            throw new PreconditionError('`flakes` is configured but .chreode/ is not gitignored (the flake log would dirty ' +
+                'the tree); add the line `.chreode/` to .gitignore');
+        }
+    }
     try {
         exec('gh', ['auth', 'status']);
     }

package/dist/signoff/run.d.ts

@@ -1,4 +1,5 @@
 import type { ResolvedConfig } from '../config/types.js';
+import type { FlakeLedgerDeps } from '../flakes/ledger.js';
 import { type MachineLock } from '../lock/machine-lock.js';
 import { type Exec, type Run } from '../run/exec.js';
 import { type StepOutcome } from '../run/step.js';
@@ -19,6 +20,10 @@ export interface SignoffDeps {
     lock: MachineLock;
     runStep: (step: PlannedStep) => Promise<StepOutcome>;
     tail: TailEffects;
+    /** Files, bumps and lists flake issues. */
+    ledger: FlakeLedgerDeps;
+    /** Absolute path of the flake log; steps see it as CHREODE_FLAKE_LOG. */
+    flakeLog: string;
     log: (m: string) => void;
     warn: (m: string) => void;
     error: (m: string) => void;

package/dist/signoff/run.js

@@ -1,3 +1,7 @@
+import { resolve } from 'node:path';
+import { ghLedgerDeps } from '../flakes/gh.js';
+import { FLAKE_LOG_FILE } from '../flakes/log.js';
+import { escalationFailure, runFlakePhase } from '../flakes/phase.js';
 import { committedPaths, isWorktree, resolveBase, resolveRef } from '../git/change-set.js';
 import { mergeBaseBranch } from '../git/merge.js';
 import { repoInfo } from '../github/status.js';
@@ -7,9 +11,9 @@ import { StepFailure, runStep, runSteps } from '../run/step.js';
 import { PlanError, describeSkip, planSignoff } from './plan.js';
 import { PreconditionError, checkPreconditions } from './preconditions.js';
 import { defaultTailEffects, runTail } from './tail.js';
-function defaultDeps(config, opts) {
+function defaultDeps(config, opts, stepEnv = {}) {
     // Children can detect the gate (e.g. to quiet build-tool stderr) via CHREODE_SIGNOFF=1.
-    const env = { ...process.env, CHREODE_SIGNOFF: '1' };
+    const env = { ...process.env, CHREODE_SIGNOFF: '1', ...stepEnv };
     let repo = null;
     const getRepo = () => (repo ??= repoInfo(defaultExec));
     return {
@@ -18,6 +22,9 @@ function defaultDeps(config, opts) {
         lock: signoffLock(),
         runStep: (step) => runStep(step, { allowStderr: opts.allowStderr, allowlist: config.stderrAllowlist, env }),
         tail: defaultTailEffects(getRepo, config.statusContext),
+        ledger: ghLedgerDeps(defaultExec),
+        // The CLI has already chdir'd to the repo root.
+        flakeLog: resolve(FLAKE_LOG_FILE),
         log: (m) => console.log(m),
         warn: (m) => console.warn(m),
         error: (m) => console.error(m)
@@ -58,7 +65,7 @@ export async function runSignoff(loadConfig, opts, overrides = {}) {
     // 1. Preconditions
     let pre;
     try {
-        pre = checkPreconditions(baseBranch, d.exec);
+        pre = checkPreconditions(baseBranch, d.exec, { flakes: config.flakes !== null });
     }
     catch (err) {
         if (err instanceof PreconditionError) {
@@ -156,16 +163,41 @@ export async function runSignoff(loadConfig, opts, overrides = {}) {
         d.log('[chreode] --dry-run: stopping before the run');
         return 0;
     }
-    // 5. Run
-    let allowedStderr;
+    // 5. Run. Steps learn the sha under test and where reporters record flakes.
+    d = {
+        ...defaultDeps(config, opts, { CHREODE_HEAD: head, CHREODE_FLAKE_LOG: d.flakeLog }),
+        ...overrides
+    };
+    let allowedStderr = [];
+    let stepsFailed = false;
     try {
         allowedStderr = await runSteps(plan.steps, d.lock, d.runStep);
     }
     catch (err) {
         if (!(err instanceof StepFailure))
             d.error(`[chreode] ${message(err)}`);
-        return 1;
+        stepsFailed = true;
+    }
+    // 6. Flakes: after the steps, passed or failed, so a flake is charged to the run that saw
+    //    it. Network, not machine load: the lock is already released.
+    let escalated = false;
+    if (config.flakes !== null) {
+        const outcome = runFlakePhase({
+            logPath: d.flakeLog,
+            ctx: { branch: pre.branch, sha: head },
+            config: config.flakes,
+            ledger: d.ledger,
+            log: d.log,
+            warn: d.warn
+        });
+        const failure = escalationFailure(outcome, config.flakes);
+        if (failure !== undefined) {
+            d.error(failure);
+            escalated = true;
+        }
     }
+    if (stepsFailed || escalated)
+        return 1;
     // What was tested must be exactly HEAD.
     const changed = checkoutChange(head, d.exec);
     if (changed) {
@@ -173,7 +205,7 @@ export async function runSignoff(loadConfig, opts, overrides = {}) {
             `commit the change and re-run signoff. Nothing was posted.`);
         return 1;
     }
-    // 6. Tail
+    // 7. Tail
     try {
         runTail({
             sha: head,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindlace/chreode",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A deterministic, selective, unavoidable local-CI gate for agent-written code",
   "keywords": [
     "ci",
@@ -37,6 +37,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./reporters/playwright": {
+      "types": "./dist/reporters/playwright.d.ts",
+      "default": "./dist/reporters/playwright.js"
+    },
+    "./reporters/vitest": {
+      "types": "./dist/reporters/vitest.d.ts",
+      "default": "./dist/reporters/vitest.js"
     }
   },
   "scripts": {
@@ -55,14 +63,28 @@
     "picomatch": "^4.0.7",
     "proper-lockfile": "^4.1.2"
   },
+  "peerDependencies": {
+    "playwright": ">=1.40",
+    "vitest": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.64.0",
     "@types/node": "^24.0.0",
     "@types/picomatch": "^4.0.3",
     "@types/proper-lockfile": "^4.1.4",
     "eslint": "^10.8.0",
     "eslint-config-prettier": "^10.1.8",
     "globals": "^17.7.0",
+    "playwright": "^1.64.0",
     "prettier": "^3.9.6",
     "tsx": "^4.23.1",
     "typescript": "~6.0.3",