cloving 1.3.0 → 1.5.0

package/dist/src/testing.js

@@ -5,7 +5,7 @@ import { join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { workflowTestLoader } from "../tools/workflow-test-loader.js";
 import { authorizeEffect } from "./effect-authorization.js";
-import { record } from "./protocol.js";
+import { scenarioResult, } from "./testing-requests.js";
 import { stepBridgeKey, } from "./step-bridge.js";
 export function fakeStepBridge(scenario) {
     const { bridge, requests, budget } = scenarioBridge(scenario);
@@ -22,7 +22,12 @@ export function fakeStepBridge(scenario) {
     Object.defineProperty(globalThis, sleepKey, {
         configurable: true,
         value: (milliseconds) => {
-            requests.push(["sleep", { seconds: milliseconds / 1000 }]);
+            requests.push([
+                "sleep",
+                milliseconds instanceof Date
+                    ? { until: milliseconds.toISOString() }
+                    : { seconds: milliseconds / 1000 },
+            ]);
             return Promise.resolve();
         },
     });
@@ -50,6 +55,7 @@ function scenarioBridge(scenario) {
     const budget = { spent: 0 };
     const bridge = {
         ...scenarioEffects(scenario, { requests, budget }),
+        ...scenarioCommandWaits(scenario, requests),
         gate: (request) => {
             requests.push(["gate", request]);
             return Promise.resolve(scenario.gate ?? {
@@ -75,6 +81,30 @@ function scenarioBridge(scenario) {
     };
     return { bridge, requests, budget };
 }
+function scenarioCommandWaits(scenario, requests) {
+    const waits = new Map(Object.entries(scenario.commandWaits ?? {}).map(([name, values]) => [
+        name,
+        [...values],
+    ]));
+    return {
+        openCommandWait: (request) => {
+            requests.push(["waitForCommand", request]);
+            if (!waits.get(request.name)?.length)
+                return Promise.reject(new Error("no-scenario-result"));
+            return Promise.resolve({
+                kind: "pending",
+                deadline: 0,
+                nextCheckAt: 0,
+            });
+        },
+        checkCommandWait: (request) => {
+            const result = waits.get(request.name)?.shift();
+            if (result === undefined)
+                return Promise.reject(new Error("no-scenario-result"));
+            return Promise.resolve(result);
+        },
+    };
+}
 function scenarioEffects(scenario, state) {
     const { requests, budget } = state;
     const effects = new Map(Object.entries(scenario.effects ?? {}).map(([key, values]) => [
@@ -133,93 +163,10 @@ const given = ${JSON.stringify(scenario)};
 const workflow = workflows[given.exportName];
 if (typeof workflow !== "function") throw new Error("workflow-test-export-missing");
 using bridge = fakeStepBridge(given);
-const outcome = await workflow(given.input, given.decision);
+const outcome = await workflow(given.input);
 await writeFile(process.argv[2], JSON.stringify({ outcome, requests: bridge.requests,
   ...(given.effectLimit === undefined ? {} : { spent: bridge.spent }) }));`;
 }
-function scenarioResult(value) {
-    const result = record(value);
-    return (result !== undefined &&
-        Object.hasOwn(result, "outcome") &&
-        Array.isArray(result["requests"]) &&
-        result["requests"].every(scenarioRequest) &&
-        (result["spent"] === undefined || typeof result["spent"] === "number"));
-}
-function scenarioRequest(value) {
-    if (!Array.isArray(value) || value.length !== 2)
-        return false;
-    const request = record(value[1]);
-    if (request === undefined)
-        return false;
-    switch (value[0]) {
-        case "effect":
-            return protectedRequest(request);
-        case "gate":
-        case "waitForDecision":
-            return gateRequest(request);
-        case "handoff":
-            return handoffRequest(request);
-        case "waitForRun":
-            return runWaitRequest(request);
-        case "sleep":
-            return sleepRequest(request);
-        default:
-            return false;
-    }
-}
-function runWaitRequest(request) {
-    return (typeof request["runId"] === "string" &&
-        typeof request["maximumWaitSeconds"] === "number");
-}
-function sleepRequest(request) {
-    const seconds = request["seconds"];
-    return (typeof seconds === "number" &&
-        Number.isInteger(seconds) &&
-        seconds >= 1 &&
-        seconds <= 86400);
-}
-function gateRequest(request) {
-    return (typeof request["gateId"] === "string" &&
-        (request["kind"] === "question" || request["kind"] === "approval") &&
-        typeof request["prompt"] === "string" &&
-        optionalText(request["expiresAt"]));
-}
-function handoffRequest(request) {
-    const input = record(request["input"]);
-    return (typeof request["workflowId"] === "string" &&
-        input !== undefined &&
-        Object.values(input).every(handoffValue));
-}
-function protectedRequest(request) {
-    return (protectedScope(request["scope"]) &&
-        ["capability", "method", "target", "payload"].every((key) => typeof request[key] === "string") &&
-        typeof request["units"] === "number" &&
-        optionalText(request["resource"]));
-}
-function protectedScope(value) {
-    const scope = record(value);
-    if (scope === undefined)
-        return false;
-    const stage = record(scope["stage"]);
-    return (typeof scope["phase"] === "string" &&
-        typeof scope["operation"] === "string" &&
-        typeof scope["round"] === "number" &&
-        optionalText(scope["key"]) &&
-        (scope["stage"] === undefined ||
-            (stage !== undefined &&
-                ["id", "visit", "branch"].every((key) => typeof stage[key] === "string"))));
-}
-function optionalText(value) {
-    return value === undefined || typeof value === "string";
-}
-function handoffValue(value) {
-    if (value === null || ["string", "boolean", "number"].includes(typeof value))
-        return true;
-    if (Array.isArray(value))
-        return value.every(handoffValue);
-    const fields = record(value);
-    return fields !== undefined && Object.values(fields).every(handoffValue);
-}
 export async function runScenario(scenario) {
     const temporary = await mkdtemp(join(tmpdir(), "cloving-scenario-"));
     try {

package/dist/src/worker-usage.d.ts

@@ -16,6 +16,7 @@ export interface WorkerTurnUsage {
     readonly costUsd: number | null;
 }
 export interface WorkerAttemptUsage {
+    readonly resumedAfter?: "daemon-restart";
     readonly models?: readonly WorkerModelUsage[];
     readonly retryKind?: RetryKind | null;
     readonly attempt: number;

package/dist/src/worker-usage.js

@@ -85,6 +85,9 @@ export function attemptsOf(value) {
         return [
             {
                 ...retryKindField(field("retryKind")),
+                ...(field("resumedAfter") === "daemon-restart"
+                    ? { resumedAfter: "daemon-restart" }
+                    : {}),
                 attempt,
                 model,
                 ...(models === undefined ? {} : { models }),

package/dist/src/workflow-candidate.d.ts

@@ -13,6 +13,7 @@ export interface CandidateEffect {
     readonly method: string | null;
 }
 export interface CandidateAnalysis {
+    readonly commandWaits?: readonly (string | null)[];
     readonly localSources?: readonly string[];
     readonly imports: readonly CandidateImport[];
     readonly effects: readonly CandidateEffect[];

package/dist/src/workflow-candidate.js

@@ -15,6 +15,7 @@ const workflowModules = [
     "cloving/workflows/steps/wait-for-run",
     "cloving/workflows/steps/run-command",
     "cloving/workflows/steps/sleep",
+    "cloving/workflows/steps/wait-for-command",
 ];
 export function workflowHelperPath(source, imported) {
     if (!imported.startsWith("./"))
@@ -66,7 +67,7 @@ export function checkWorkflowCandidate(input) {
     if (!isCandidateDeclaration(input.declaration))
         return candidateDeclarationRefusals(input.declaration);
     const { analysis, declaration, installedExports } = input;
-    const codes = [];
+    const codes = commandWaitRefusals(analysis, declaration);
     if (analysis.imports.some((entry) => !allowedImport(entry, analysis)))
         codes.push("forbidden-import");
     if (analysis.imports.some((entry) => {
@@ -100,3 +101,13 @@ export function candidateDeclarationRefusals(value) {
     const codes = workflowQueueRefusals(record(value)?.["workflow"]);
     return codes.length > 0 ? codes : ["invalid-declaration"];
 }
+function commandWaitRefusals(analysis, declaration) {
+    const waits = analysis.commandWaits ?? [];
+    const codes = [];
+    if (waits.includes(null))
+        codes.push("dynamic-effect");
+    if (waits.some((name) => name !== null &&
+        !Object.hasOwn(declaration.workflow.commandWaits ?? {}, name)))
+        codes.push("undeclared-effect");
+    return codes;
+}

package/dist/src/workflow-contracts.d.ts

@@ -17,6 +17,7 @@ export type CycleOutcome = {
     readonly ticketStatus?: "complete" | "partial";
     readonly issueUpdate?: "failed";
     readonly reason?: string;
+    readonly report?: string;
 };
 export type Validation<Value> = {
     readonly kind: "valid";

package/dist/src/workflow-contracts.js

@@ -43,7 +43,7 @@ const outcomes = {
     },
     handoff_requested: {
         keys: ["cycleId", "kind", "promotionId"],
-        optional: ["ticketStatus", "issueUpdate", "reason"],
+        optional: ["ticketStatus", "issueUpdate", "reason", "report"],
         parse: (fields) => {
             const cycleId = textField(fields, {
                 key: "cycleId",
@@ -58,6 +58,9 @@ const outcomes = {
             const ticketStatus = fields["ticketStatus"];
             const issueUpdate = fields["issueUpdate"];
             const reason = fields["reason"];
+            const report = fields["report"];
+            if (!validReport(report))
+                return null;
             if (issueUpdate !== undefined && issueUpdate !== "failed")
                 return null;
             if (ticketStatus !== undefined && !isTicketStatus(ticketStatus))
@@ -68,11 +71,15 @@ const outcomes = {
                 kind: "handoff_requested",
                 cycleId,
                 promotionId,
-                ...Object.fromEntries(Object.entries({ issueUpdate, ticketStatus, reason }).filter(([, value]) => value !== undefined)),
+                ...Object.fromEntries(Object.entries({ issueUpdate, ticketStatus, reason, report }).filter(([, value]) => value !== undefined)),
             };
         },
     },
 };
+function validReport(report) {
+    return (report === undefined ||
+        (typeof report === "string" && report.length > 0 && report.length <= 65536));
+}
 export function validateDevelopmentInput(value) {
     const fields = exactFields(value, { required: ["cycleId"] });
     const cycleId = fields && textField(fields, { key: "cycleId", pattern: identifier });

package/dist/src/workflow-declaration.d.ts

@@ -31,6 +31,7 @@ export interface DeclaredWorkflow extends WorkflowDeclaration {
 }
 export type WorkflowQueueCode = "queue-needs-ticket-field" | "queue-input-incomplete";
 export declare function workflowQueueRefusals(value: unknown): readonly WorkflowQueueCode[];
+export declare function workflowStagesOf(value: unknown): WorkflowStages;
 export declare function isWorkflowStages(value: unknown): value is readonly WorkflowStage[];
 export declare function isWorkflowNames(value: unknown): value is readonly string[];
 export declare function isCommandWaits(value: unknown, permissions: {

package/dist/src/workflow-declaration.js

@@ -89,6 +89,9 @@ function isStage(value) {
 function unique(values) {
     return new Set(values).size === values.length;
 }
+export function workflowStagesOf(value) {
+    return Object.fromEntries(Object.entries(record(value) ?? {}).flatMap(([workflowId, stages]) => isWorkflowStages(stages) ? [[workflowId, stages]] : []));
+}
 export function isWorkflowStages(value) {
     if (!Array.isArray(value) || value.length < 1 || value.length > 12)
         return false;

package/dist/src/workflow-discovery.d.ts

@@ -1,19 +1,8 @@
-export interface WorkflowReservation {
-    readonly baseName?: string;
-    readonly workflowId?: string;
-    readonly functionName?: string;
-}
 export interface WorkflowDiscoveryIdentity {
     readonly queue?: boolean;
     readonly baseName: string;
     readonly workflowId: string | undefined;
     readonly functionNames: readonly string[];
 }
-export type WorkflowConflictCode = "workflow-conflict" | "bundled-name-reserved" | "queue-workflow-conflict";
-export declare function workflowConflicts(candidates: readonly WorkflowDiscoveryIdentity[], bundled: readonly WorkflowReservation[]): readonly (readonly WorkflowConflictCode[])[];
-export declare const bundledWorkflowIds: {
-    readonly ticket: "develop-ticket";
-    readonly issue: "develop-issue";
-    readonly prompt: "develop-prompt";
-    readonly prd: "develop-prd";
-};
+export type WorkflowConflictCode = "workflow-conflict" | "queue-workflow-conflict";
+export declare function workflowConflicts(candidates: readonly WorkflowDiscoveryIdentity[]): readonly (readonly WorkflowConflictCode[])[];

package/dist/src/workflow-discovery.js

@@ -5,32 +5,20 @@ function identityKeys(identity) {
         ...identity.functionNames.map((name) => `function:${name}`),
     ];
 }
-export function workflowConflicts(candidates, bundled) {
+export function workflowConflicts(candidates) {
     const keys = candidates.map(identityKeys);
     const counts = new Map();
     for (const names of keys) {
         for (const name of new Set(names))
             counts.set(name, (counts.get(name) ?? 0) + 1);
     }
-    const reserved = new Set(bundled.flatMap((entry) => identityKeys({
-        ...entry,
-        functionNames: entry.functionName === undefined ? [] : [entry.functionName],
-    })));
     const queued = candidates.filter((candidate) => candidate.queue === true);
     return keys.map((names, index) => {
         const codes = [];
         if (queued.length > 1 && candidates[index]?.queue === true)
             codes.push("queue-workflow-conflict");
-        if (names.some((name) => reserved.has(name)))
-            codes.push("bundled-name-reserved");
         if (names.some((name) => (counts.get(name) ?? 0) > 1))
             codes.push("workflow-conflict");
         return codes;
     });
 }
-export const bundledWorkflowIds = {
-    ticket: "develop-ticket",
-    issue: "develop-issue",
-    prompt: "develop-prompt",
-    prd: "develop-prd",
-};

package/dist/src/workflow-refusals.js

@@ -12,7 +12,6 @@ const refusalCodes = new Set([
     "effect-limit",
     "direct-effect",
     "workflow-conflict",
-    "bundled-name-reserved",
     "unsafe-workflow-path",
     "workflow-read-failed",
     "workflow-source-changed",

package/dist/src/workflows.d.ts

@@ -1,6 +1,5 @@
 export { loadCycle, type CycleLoad } from "./steps/load-cycle.ts";
 export { protectedEffect } from "./steps/protected-effect.ts";
-export { decisionGate } from "./steps/decision-gate.ts";
 export { waitForDecision } from "./steps/wait-for-decision.ts";
 export { reviewByPerson } from "./steps/review-by-person.ts";
 export { reviewByAgent } from "./steps/review-by-agent.ts";
@@ -11,6 +10,7 @@ export type { MergeCheckName, MergeReason, MergeRequest, MergeResult, PullReques
 export { handoff } from "./steps/handoff.ts";
 export { waitForRun } from "./steps/wait-for-run.ts";
 export { runCommand } from "./steps/run-command.ts";
+export { waitForCommand, type CommandWaitRequest, type CommandWaitOutcome, } from "./steps/wait-for-command.ts";
 export { sleep } from "./steps/sleep.ts";
 export type { CommandRequest, GateRequest, GateResult, DecisionResult, HandoffRequest, HandoffValue, RunWaitRequest, RunWaitOutcome, ProtectedRequest, ProtectedResult, ProtectedScope, } from "./step-bridge.ts";
 export type { CycleOutcome, DevelopmentInput } from "./workflow-contracts.ts";

package/dist/src/workflows.js

@@ -1,6 +1,5 @@
 export { loadCycle } from "./steps/load-cycle.js";
 export { protectedEffect } from "./steps/protected-effect.js";
-export { decisionGate } from "./steps/decision-gate.js";
 export { waitForDecision } from "./steps/wait-for-decision.js";
 export { reviewByPerson } from "./steps/review-by-person.js";
 export { reviewByAgent } from "./steps/review-by-agent.js";
@@ -9,5 +8,6 @@ export { mergeWhenGreen } from "./steps/merge-when-green.js";
 export { handoff } from "./steps/handoff.js";
 export { waitForRun } from "./steps/wait-for-run.js";
 export { runCommand } from "./steps/run-command.js";
+export { waitForCommand, } from "./steps/wait-for-command.js";
 export { sleep } from "./steps/sleep.js";
 export { ticketStatus } from "./ticket-status.js";

package/dist/tools/compile-workflows.js

@@ -8,6 +8,9 @@ if (!sourceDirectory || !outputDirectory) {
 }
 const output = resolve(outputDirectory);
 class WorkflowBuilder extends BaseBuilder {
+    async getInputFiles() {
+        return (await super.getInputFiles()).toSorted();
+    }
     async build() {
         const inputFiles = await this.getInputFiles();
         await mkdir(output, { recursive: true });

package/dist/tools/project-configuration.d.ts

@@ -1,4 +1,9 @@
-import { resolveSettings } from "../src/project-settings.ts";
+import { resolveSettings, type TurnSettings } from "../src/project-settings.ts";
+import { type TurnProfiles } from "../src/turn-profile.ts";
+type ProjectConfiguration = ReturnType<typeof resolveSettings>;
 export declare function topLevel(given: string): string;
 export declare function projectRoot(given: string): Promise<string>;
-export declare function projectConfiguration(repository: string, environment: Readonly<NodeJS.ProcessEnv>): Promise<ReturnType<typeof resolveSettings>>;
+export declare function projectConfiguration(repository: string, environment: Readonly<NodeJS.ProcessEnv>): Promise<ProjectConfiguration>;
+export declare function configuredTurnSettings(configuration: ProjectConfiguration): Promise<TurnSettings>;
+export declare function configurationDigests(configuration: ProjectConfiguration, profiles: TurnProfiles): Readonly<Record<string, string>>;
+export {};

package/dist/tools/project-configuration.js

@@ -3,8 +3,10 @@ import { createHash } from "node:crypto";
 import { readFile, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
-import { configurationRoot, resolveSettings } from "../src/project-settings.js";
+import { configurationRoot, resolveSettings, settingDigests, } from "../src/project-settings.js";
 import { repositoryFileName } from "../src/repository-identity.js";
+import { parseFallbackModels, parseTokenPrices } from "../src/token-prices.js";
+import { isProfilesFile } from "../src/turn-profile.js";
 async function settingsFile(file) {
     try {
         return await readFile(file.path, "utf8");
@@ -45,3 +47,30 @@ export async function projectConfiguration(repository, environment) {
         }),
     });
 }
+async function configuredProfiles(configuration) {
+    const path = configuration.environment["CLOVING_PROFILES"];
+    if (path === undefined)
+        return configuration.profiles;
+    try {
+        const value = JSON.parse(await readFile(path, "utf8"));
+        if (isProfilesFile(value))
+            return value.profiles;
+    }
+    catch {
+        throw new Error("invalid-profiles");
+    }
+    throw new Error("invalid-profiles");
+}
+export async function configuredTurnSettings(configuration) {
+    const { environment } = configuration;
+    const tokenPrices = parseTokenPrices(environment["CLOVING_TOKEN_PRICES"]);
+    const fallbackModels = parseFallbackModels(environment["CLOVING_FALLBACK_MODELS"]);
+    return {
+        profiles: await configuredProfiles(configuration),
+        fallbackModels,
+        tokenPrices,
+    };
+}
+export function configurationDigests(configuration, profiles) {
+    return settingDigests({ ...configuration, profiles }, (text) => createHash("sha256").update(text).digest("hex"));
+}

package/dist/tools/red-green-command.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/red-green-command.js

@@ -0,0 +1,174 @@
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { record } from "../src/protocol.js";
+import { configuration } from "../src/configuration-schema.js";
+import { parseCommandSeconds } from "../src/command-settings.js";
+import { redGreenProcess } from "./red-green-process.js";
+function git(argumentsList) {
+    return execFileSync("git", [...argumentsList], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+async function run(input) {
+    const temporary = mkdtempSync(join(tmpdir(), "cloving-red-green-"));
+    const tree = join(temporary, "tree");
+    try {
+        git(["worktree", "add", "--detach", tree, input.revision]);
+        if (input.revision !== input.head)
+            git([
+                "--literal-pathspecs",
+                "-C",
+                tree,
+                "restore",
+                "--source",
+                input.head,
+                "--worktree",
+                "--",
+                ...input.files,
+            ]);
+        const options = {
+            directory: tree,
+            signal: input.signal,
+            milliseconds: input.milliseconds,
+        };
+        const prepared = input.prepare === undefined
+            ? undefined
+            : await redGreenProcess(input.prepare, options);
+        if (prepared !== undefined && prepared.status !== 0)
+            return { ...prepared, prepareFailed: true };
+        const tested = await redGreenProcess([...input.test, ...input.files], options);
+        return tested;
+    }
+    finally {
+        git(["worktree", "remove", "--force", tree]);
+        rmSync(temporary, { recursive: true, force: true });
+    }
+}
+async function redGreenCommand(signal) {
+    if (process.argv.slice(2).includes("--help")) {
+        process.stdout.write('Usage: cloving red-green\n\nReads {"head":"<full commit ID>"} on standard input.\nCLOVING_RED_GREEN configures test, testFiles, prepare, assertionPattern and skipPattern.\nPrints one JSON verdict from temporary detached worktrees.\n');
+        return;
+    }
+    let text = "";
+    for await (const chunk of process.stdin)
+        text += String(chunk);
+    const head = inputHead(text);
+    const { settings, assertion, skip } = redGreenSettings();
+    const { test, testFiles: prefixes, prepare } = settings;
+    if (git(["cat-file", "-t", head]).trim() !== "commit")
+        throw new Error("invalid-red-green-input: head must be a full commit ID");
+    if (git(["rev-parse", "--verify", head]).trim() !== head.toLowerCase())
+        throw new Error("invalid-red-green-input: head must be a full commit ID");
+    const base = git(["merge-base", head, "refs/remotes/origin/HEAD"]).trim();
+    const files = changedTests({ base, head, prefixes });
+    if (files.length === 0) {
+        process.stdout.write(JSON.stringify({
+            verdict: "no-test-change",
+            base,
+            head,
+            files,
+            output: "",
+        }) + "\n");
+        return;
+    }
+    const milliseconds = parseCommandSeconds(process.env["CLOVING_COMMAND_SECONDS"]) * 1000;
+    const options = { head, files, test, prepare, signal, milliseconds };
+    const red = await run({ ...options, revision: base });
+    signal.throwIfAborted();
+    const green = await run({ ...options, revision: head });
+    signal.throwIfAborted();
+    const result = classify({ red, green, assertion, skip });
+    process.stdout.write(JSON.stringify({
+        ...result,
+        output: result.output.slice(-16000),
+        base,
+        head,
+        files,
+    }) + "\n");
+}
+function changedTests(input) {
+    return git([
+        "diff",
+        "--no-renames",
+        "--name-only",
+        "--diff-filter=AMT",
+        "-z",
+        input.base,
+        input.head,
+    ])
+        .split("\0")
+        .filter((file) => input.prefixes.some((prefix) => file.startsWith(prefix)));
+}
+function classify(input) {
+    const { red, green, assertion, skip } = input;
+    for (const result of [red, green])
+        if (result.prepareFailed === true)
+            return { verdict: "prepare-failed", output: result.output };
+    for (const result of [red, green])
+        if (skip.test(result.output))
+            return { verdict: "skipped-test", output: result.output };
+    if (red.status === 0)
+        return { verdict: "false-red", output: red.output };
+    if (red.status === null || !assertion.test(red.output))
+        return { verdict: "red-not-assertion", output: red.output };
+    if (green.status !== 0)
+        return { verdict: "green-failed", output: green.output };
+    return { verdict: "accepted", output: green.output };
+}
+function inputHead(text) {
+    let input;
+    try {
+        input = JSON.parse(text);
+    }
+    catch {
+        throw new Error("invalid-red-green-input: expected JSON with a full commit ID in head");
+    }
+    const head = record(input)?.["head"];
+    if (typeof head !== "string" ||
+        !/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/.test(head))
+        throw new Error("invalid-red-green-input: head must be a full commit ID");
+    return head;
+}
+function redGreenSettings() {
+    try {
+        const value = JSON.parse(process.env["CLOVING_RED_GREEN"] ?? "null");
+        const settings = configuration({ version: 1, checks: { redGreen: value } }, "project").checks?.redGreen;
+        if (settings === undefined)
+            throw new Error("missing settings");
+        return {
+            settings,
+            assertion: new RegExp(settings.assertionPattern ?? "ERR_ASSERTION"),
+            skip: new RegExp(settings.skipPattern ?? "# SKIP\\b"),
+        };
+    }
+    catch (error) {
+        throw new Error("invalid-CLOVING_RED_GREEN: " +
+            (error instanceof Error ? error.message : String(error)), { cause: error });
+    }
+}
+const controller = new AbortController();
+const interrupt = () => {
+    controller.abort();
+};
+process.on("disconnect", interrupt);
+if (!process.connected)
+    interrupt();
+process.on("SIGTERM", interrupt);
+process.on("SIGINT", interrupt);
+try {
+    await redGreenCommand(controller.signal);
+}
+catch (error) {
+    process.stderr.write((error instanceof Error ? error.message : String(error)) + "\n");
+    process.exitCode = 1;
+}
+finally {
+    process.off("disconnect", interrupt);
+    if (process.connected)
+        process.disconnect?.();
+    process.off("SIGTERM", interrupt);
+    process.off("SIGINT", interrupt);
+}

package/dist/tools/red-green-process.d.ts

@@ -0,0 +1,10 @@
+export interface RunResult {
+    readonly status: number | null;
+    readonly output: string;
+    readonly prepareFailed?: boolean;
+}
+export declare function redGreenProcess(argumentsList: readonly string[], options: {
+    readonly directory: string;
+    readonly signal: AbortSignal;
+    readonly milliseconds: number;
+}): Promise<RunResult>;