toolroll 0.5.0

package/dist/check-progress.js

@@ -0,0 +1,290 @@
+/** Live facts extracted from the approved check's ordinary output. */
+export const CHECK_SUITES = ["unit", "flows", "app"];
+const emptySuite = () => ({ state: "pending", passed: 0, failed: 0, skipped: 0, total: null });
+function cleanLine(value) {
+    return value
+        .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\r/g, "")
+        .trim();
+}
+function safeCount(raw) {
+    if (raw === undefined || !/^[0-9]{1,9}$/.test(raw))
+        return null;
+    const value = Number(raw);
+    return Number.isSafeInteger(value) ? value : null;
+}
+function suiteWords(name, suite) {
+    const words = countWords(name, suite);
+    return suite.groups === undefined ? words : `${words} · ${suite.groups.passed}/${suite.groups.total} groups`;
+}
+function countWords(name, suite) {
+    const completed = suite.passed + suite.failed + suite.skipped;
+    if (suite.state === "passed") {
+        const count = suite.total !== null && suite.skipped > 0 ? `${suite.passed}/${suite.total}` : String(suite.passed);
+        return `${name} ✓ ${count}`;
+    }
+    if (suite.state === "failed") {
+        return `${name} ✕ ${suite.failed}${suite.total === null ? "" : `/${suite.total}`}`;
+    }
+    if (suite.state === "running")
+        return `${name} ${completed}${suite.total === null ? "" : `/${suite.total}`}`;
+    if (suite.state === "unknown")
+        return `${name} ?${completed === 0 ? "" : ` ${completed}`}`;
+    return `${name} …`;
+}
+export function checkProgressLine(suites) {
+    return CHECK_SUITES.map(name => suiteWords(name, suites[name])).join(" · ");
+}
+/** A machine-only count line that is safe to send through a push provider. */
+export function isCheckProgressLine(value) {
+    const suite = String.raw `(?:unit|flows|app) (?:…|\?(?: [0-9]{1,9})?|[0-9]{1,9}(?:\/[0-9]{1,9})?|✓ [0-9]{1,9}(?:\/[0-9]{1,9})?|✕ [0-9]{1,9}(?:\/[0-9]{1,9})?)(?: · [0-9]{1,9}\/[0-9]{1,9} groups)?`;
+    return new RegExp(`^${suite}(?: · ${suite}){2}$`).test(value);
+}
+export function parseCheckProgressSnapshot(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (value.version !== 1 || typeof value.final !== "boolean" || typeof value.line !== "string" || !isCheckProgressLine(value.line) || value.suites === null || typeof value.suites !== "object")
+            return null;
+        const suites = {};
+        for (const name of CHECK_SUITES) {
+            const suite = value.suites[name];
+            if (suite === undefined || !["pending", "running", "passed", "failed", "unknown"].includes(String(suite.state)))
+                return null;
+            if (![suite.passed, suite.failed, suite.skipped].every(one => Number.isSafeInteger(one) && Number(one) >= 0))
+                return null;
+            if (suite.total !== null && (!Number.isSafeInteger(suite.total) || Number(suite.total) < 0))
+                return null;
+            const completed = Number(suite.passed) + Number(suite.failed) + Number(suite.skipped);
+            if (suite.total !== null && completed > Number(suite.total))
+                return null;
+            if (value.final && (suite.state === "pending" || suite.state === "running"))
+                return null;
+            suites[name] = { state: suite.state, passed: Number(suite.passed), failed: Number(suite.failed), skipped: Number(suite.skipped), total: suite.total === null ? null : Number(suite.total) };
+            if (suite.groups !== undefined) {
+                const groups = suite.groups;
+                if (groups === null || typeof groups !== "object" || ![groups.passed, groups.failed, groups.total].every(one => Number.isSafeInteger(one) && Number(one) >= 0))
+                    return null;
+                if (Number(groups.passed) + Number(groups.failed) > Number(groups.total))
+                    return null;
+                suites[name].groups = { passed: Number(groups.passed), failed: Number(groups.failed), total: Number(groups.total) };
+            }
+        }
+        if (checkProgressLine(suites) !== value.line)
+            return null;
+        return { version: 1, final: value.final, line: value.line, suites };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Incrementally reads stdout and stderr. Each stream keeps its own partial
+ * line so simultaneous journey output cannot splice two records together.
+ */
+export class CheckProgressTracker {
+    update;
+    suites = {
+        unit: emptySuite(),
+        flows: emptySuite(),
+        app: emptySuite(),
+    };
+    buffers = { stdout: "", stderr: "" };
+    events = new Set();
+    last = "";
+    recognized = false;
+    parallel = null;
+    constructor(update) {
+        this.update = update;
+    }
+    feed(chunk, stream = "stdout") {
+        const joined = this.buffers[stream] + chunk;
+        const lines = joined.split(/\n/);
+        this.buffers[stream] = lines.pop() ?? "";
+        for (const line of lines)
+            this.read(line);
+    }
+    finish() {
+        for (const stream of ["stdout", "stderr"]) {
+            if (this.buffers[stream] !== "")
+                this.read(this.buffers[stream]);
+            this.buffers[stream] = "";
+        }
+        if (!this.recognized)
+            return null;
+        for (const name of CHECK_SUITES) {
+            if (this.suites[name].state === "pending" || this.suites[name].state === "running") {
+                this.suites[name].state = "unknown";
+            }
+        }
+        return this.emit(true, true);
+    }
+    snapshot(final = false) {
+        const suites = Object.fromEntries(CHECK_SUITES.map(name => {
+            const suite = { ...this.suites[name] };
+            if (suite.groups !== undefined)
+                suite.groups = { ...suite.groups };
+            return [name, suite];
+        }));
+        return { version: 1, final, line: checkProgressLine(suites), suites };
+    }
+    emit(final = false, force = false) {
+        const snapshot = this.snapshot(final);
+        const identity = JSON.stringify(snapshot);
+        if (force || identity !== this.last) {
+            this.last = identity;
+            this.update(snapshot);
+        }
+        return snapshot;
+    }
+    read(raw) {
+        const line = cleanLine(raw);
+        if (line === "")
+            return;
+        const testFiles = /\bTest Files\b(.+)$/.exec(line);
+        if (testFiles !== null) {
+            const tail = testFiles[1] ?? "";
+            const passed = safeCount(/\b([0-9]+)\s+passed\b/.exec(tail)?.[1]) ?? 0;
+            const failed = safeCount(/\b([0-9]+)\s+failed\b/.exec(tail)?.[1]) ?? 0;
+            const total = safeCount(/\(([0-9]+)\)\s*$/.exec(tail)?.[1]) ?? passed + failed;
+            if (passed + failed > 0 || total > 0) {
+                this.recognized = true;
+                this.suites.unit = { state: failed > 0 ? "failed" : "passed", passed, failed, skipped: Math.max(0, total - passed - failed), total };
+                this.emit();
+            }
+            return;
+        }
+        // scripts/e2e-parallel.mjs: "Running 7 groups at once: console, task, …", then every group's
+        // lines as "[group] [app] …", then "✅ group  3.1 min" per group and "N of M groups passed …".
+        const starting = /^Running ([0-9]+) groups at once: (.+)$/.exec(line);
+        if (starting !== null) {
+            const total = safeCount(starting[1]);
+            const names = starting[2].split(",").map(one => one.trim()).filter(one => one !== "");
+            if (total !== null && names.length === total)
+                this.parallel = { suite: null, total, groups: new Map(names.map(one => [one, emptyGroup()])) };
+            return;
+        }
+        const parallel = this.parallel;
+        if (parallel !== null) {
+            const exited = /^(✅|❌)\s+(\S+)\s+[0-9.]+ min$/.exec(line);
+            const group = exited === null ? undefined : parallel.groups.get(exited[2]);
+            if (group !== undefined && parallel.suite !== null) {
+                group.result = exited[1] === "✅" ? "passed" : "failed";
+                this.summarize(parallel);
+                return;
+            }
+            const summary = /^([0-9]+) of ([0-9]+) groups passed\b/.exec(line);
+            if (summary !== null && parallel.suite !== null && safeCount(summary[2]) === parallel.total) {
+                const passed = safeCount(summary[1]) ?? 0;
+                this.summarize(parallel, passed === parallel.total);
+                this.parallel = null;
+                return;
+            }
+        }
+        const grouped = /^\[\s*([A-Za-z0-9_.-]+)\s*\]\s*\[(flows|app)\]\s*(.*)$/i.exec(line);
+        if (grouped !== null && parallel !== null && parallel.groups.has(grouped[1])) {
+            this.readGroup(parallel, grouped[1], grouped[2].toLowerCase(), grouped[3] ?? "");
+            return;
+        }
+        const labeled = /^\s*\[(flows|app)\]\s*(.*)$/i.exec(line) ?? /^\s*(flows|app)\s*:\s*(.*)$/i.exec(line);
+        if (labeled === null)
+            return;
+        this.recognized = true;
+        const name = labeled[1].toLowerCase();
+        const body = labeled[2] ?? "";
+        const totals = /\b([0-9]+)\s+passed\s*,\s*([0-9]+)\s+failed(?:\s*,\s*([0-9]+)\s+skipped)?\b/i.exec(body);
+        if (totals !== null) {
+            const passed = safeCount(totals[1]) ?? 0;
+            const failed = safeCount(totals[2]) ?? 0;
+            const skipped = safeCount(totals[3]) ?? 0;
+            this.suites[name] = { state: failed > 0 ? "failed" : "passed", passed, failed, skipped, total: passed + failed + skipped };
+            this.emit();
+            return;
+        }
+        const fraction = /\b([0-9]+)\s*\/\s*([0-9]+)\b/.exec(body);
+        if (fraction !== null) {
+            const completed = safeCount(fraction[1]);
+            const total = safeCount(fraction[2]);
+            if (completed !== null && total !== null && completed <= total) {
+                const current = this.suites[name];
+                const passed = Math.max(current.passed, completed);
+                if (passed + current.failed + current.skipped <= total) {
+                    this.suites[name] = { ...current, state: "running", passed, total };
+                    this.emit();
+                }
+            }
+            return;
+        }
+        const event = /\b(PASS|FAIL|SKIP)\b/i.exec(body)?.[1]?.toUpperCase();
+        if (event === undefined)
+            return;
+        const identity = `${name}:${event}:${body}`;
+        if (this.events.has(identity))
+            return;
+        this.events.add(identity);
+        const current = this.suites[name];
+        this.suites[name] = {
+            ...current,
+            state: event === "FAIL" ? "failed" : current.state === "failed" ? "failed" : "running",
+            passed: current.passed + (event === "PASS" ? 1 : 0),
+            failed: current.failed + (event === "FAIL" ? 1 : 0),
+            skipped: current.skipped + (event === "SKIP" ? 1 : 0),
+        };
+        this.emit();
+    }
+    /** One group's journey line: count its events, and take its own totals line as that group's result. */
+    readGroup(parallel, name, suite, body) {
+        if (parallel.suite !== null && parallel.suite !== suite)
+            return;
+        parallel.suite = suite;
+        this.recognized = true;
+        const group = parallel.groups.get(name);
+        const totals = /\b([0-9]+)\s+passed\s*,\s*([0-9]+)\s+failed(?:\s*,\s*([0-9]+)\s+skipped)?\b/i.exec(body);
+        if (totals !== null) {
+            group.passed = safeCount(totals[1]) ?? 0;
+            group.failed = safeCount(totals[2]) ?? 0;
+            group.skipped = safeCount(totals[3]) ?? 0;
+            group.total = group.passed + group.failed + group.skipped;
+            group.result ??= group.failed > 0 ? "failed" : "passed";
+            this.summarize(parallel);
+            return;
+        }
+        const event = /^\s*(?:[0-9]+s\s+)?(PASS|FAIL|SKIP)\b/i.exec(body)?.[1]?.toUpperCase();
+        if (event === undefined || group.total !== null)
+            return;
+        const identity = `${suite}:${name}:${event}:${body}`;
+        if (this.events.has(identity))
+            return;
+        this.events.add(identity);
+        if (event === "PASS")
+            group.passed += 1;
+        else if (event === "FAIL")
+            group.failed += 1;
+        else
+            group.skipped += 1;
+        this.summarize(parallel);
+    }
+    /** The suite is the sum of its groups; its total is known once every group has reported one. */
+    summarize(parallel, allPassed) {
+        const name = parallel.suite;
+        if (name === null)
+            return;
+        const groups = [...parallel.groups.values()];
+        const sum = (pick) => groups.reduce((total, group) => total + pick(group), 0);
+        const passedGroups = groups.filter(group => group.result === "passed").length;
+        const failedGroups = groups.filter(group => group.result === "failed").length;
+        const failed = sum(group => group.failed);
+        const total = groups.every(group => group.total !== null) ? sum(group => group.total ?? 0) : null;
+        const state = allPassed === false || failed > 0 || failedGroups > 0 ? "failed"
+            : allPassed === true || passedGroups === parallel.total ? "passed" : "running";
+        this.suites[name] = {
+            state,
+            passed: sum(group => group.passed),
+            failed,
+            skipped: sum(group => group.skipped),
+            total,
+            groups: { passed: passedGroups, failed: failedGroups, total: parallel.total },
+        };
+        this.emit();
+    }
+}
+const emptyGroup = () => ({ passed: 0, failed: 0, skipped: 0, total: null, result: null });

package/dist/child-database.d.ts

@@ -0,0 +1,12 @@
+import type { ExecResult, RunOptions } from "./exec.js";
+export declare const CHILD_DATABASE_ENV = "TOOLROLL_DB";
+/** Both names, so neither an ambient TOOLROLL_DB nor an older tool reading STANDING_ORDERS_DB reaches the live store. */
+export declare function childDatabaseEnv(file: string): Record<string, string>;
+/** Self-hosted agents and project commands must not open their supervisor's store. */
+export declare function isolatedChildDatabase(label: string): {
+    dir: string;
+    file: string;
+};
+export declare function removeChildDatabase(dir: string): void;
+/** Override after environment filtering, even if an ambient override names the live DB. */
+export declare function runWithIsolatedDatabase(runner: (file: string, args: readonly string[], options: RunOptions) => Promise<ExecResult>, file: string, args: readonly string[], options: RunOptions): Promise<ExecResult>;

package/dist/child-database.js

@@ -0,0 +1,30 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { envTwins } from "./names.js";
+export const CHILD_DATABASE_ENV = "TOOLROLL_DB";
+/** Both names, so neither an ambient TOOLROLL_DB nor an older tool reading STANDING_ORDERS_DB reaches the live store. */
+export function childDatabaseEnv(file) {
+    return envTwins("DB", file);
+}
+/** Self-hosted agents and project commands must not open their supervisor's store. */
+export function isolatedChildDatabase(label) {
+    const dir = mkdtempSync(join(tmpdir(), `toolroll-${label}-`));
+    return { dir, file: join(dir, "orders.db") };
+}
+export function removeChildDatabase(dir) {
+    rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+}
+/** Override after environment filtering, even if an ambient override names the live DB. */
+export async function runWithIsolatedDatabase(runner, file, args, options) {
+    const isolated = isolatedChildDatabase("check");
+    try {
+        return await runner(file, args, {
+            ...options,
+            env: { ...options.env, ...childDatabaseEnv(isolated.file) },
+        });
+    }
+    finally {
+        removeChildDatabase(isolated.dir);
+    }
+}