cloving 1.0.1 → 1.2.0

package/dist/src/daemon/github-retry.js

@@ -0,0 +1,49 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { field, githubTiming } from "./github-operation.js";
+function transient(error) {
+    if (!(error instanceof Error) || error.message !== "github-call-failed")
+        return false;
+    const detail = field(error, "detail");
+    if (typeof detail !== "string")
+        return false;
+    const status = field(error, "status");
+    if ([500, 502, 503, 504].includes(Number(status)))
+        return true;
+    return ((status === undefined ||
+        (typeof status === "number" && Number.isNaN(status))) &&
+        /TLS handshake timeout|connection reset|i\/o timeout|\bEOF\b/i.test(detail));
+}
+function retryFactor(error, retry) {
+    const network = transient(error);
+    if (!network && !retry.statuses.includes(Number(field(error, "status"))))
+        throw error;
+    if (retry.attempt < 2)
+        return network ? retry.attempt + 1 : 1;
+    if (!network)
+        throw error;
+    throw Object.assign(new Error("github-network-failed", { cause: error }), {
+        detail: field(error, "detail"),
+    });
+}
+export async function retryGithub(operation, retry) {
+    const timing = operation.settings.timing ?? githubTiming;
+    for (let attempt = 0;; attempt += 1) {
+        operation.signal.throwIfAborted();
+        try {
+            return await retry.action(attempt);
+        }
+        catch (error) {
+            operation.signal.throwIfAborted();
+            const factor = retryFactor(error, {
+                attempt,
+                statuses: retry.statuses ?? [],
+            });
+            await delay(timing.pollMilliseconds * factor, undefined, {
+                signal: operation.signal,
+            });
+        }
+    }
+}
+export function githubRead(operation, parts) {
+    return retryGithub(operation, { action: () => operation.calls.gh(parts) });
+}

package/dist/src/daemon/github-ticket-status.d.ts

@@ -0,0 +1,3 @@
+import { type Operation } from "./github-operation.ts";
+export declare function closeIssue(operation: Operation): Promise<unknown>;
+export declare function partialIssue(operation: Operation): Promise<unknown>;

package/dist/src/daemon/github-ticket-status.js

@@ -0,0 +1,294 @@
+import { issuePrivacy } from "./github-issue-privacy.js";
+import { field, text } from "./github-operation.js";
+import { ticketLimits } from "./ticket-source.js";
+const privateRemaining = "Remaining work is in the private run report.";
+const issueBodyBytes = ticketLimits.textBytes - 2_048;
+const workflowLabels = [
+    "cloving: ready",
+    "cloving: blocked",
+    "cloving: in progress",
+];
+function positiveInteger(operation, name) {
+    const value = operation.payload[name];
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+        throw new Error("invalid-payload");
+    return value;
+}
+function issuePath(operation) {
+    const repository = `${text(operation, "owner")}/${text(operation, "repository")}`;
+    if (!/^[\w.-]+\/[\w.-]+$/.test(repository))
+        throw new Error("invalid-payload");
+    return `repos/${repository}/issues/${String(positiveInteger(operation, "number"))}`;
+}
+function labelsOf(issue) {
+    const labels = field(issue, "labels");
+    if (!Array.isArray(labels))
+        throw new Error("github-call-failed");
+    return labels.map((item) => {
+        const name = typeof item === "string" ? item : field(item, "name");
+        if (typeof name !== "string")
+            throw new Error("github-call-failed");
+        return name;
+    });
+}
+async function readIssue(operation, path) {
+    const issue = JSON.parse(await operation.calls.gh(["api", path]));
+    const body = field(issue, "body");
+    if ((body !== null && typeof body !== "string") ||
+        field(issue, "number") !== positiveInteger(operation, "number") ||
+        !["open", "closed"].includes(String(field(issue, "state"))) ||
+        field(issue, "pull_request") !== undefined)
+        throw new Error("github-call-failed");
+    return {
+        state: field(issue, "state"),
+        reason: field(issue, "state_reason"),
+        body: typeof body === "string" ? body : "",
+        labels: labelsOf(issue),
+    };
+}
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isRemaining(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((item) => typeof item === "string" && item.trim() !== "" && !/[\r\n]/.test(item)));
+}
+function isPartialRun(value) {
+    return (isPositiveInteger(field(value, "pullRequest")) &&
+        isRemaining(field(value, "remaining")));
+}
+function historyOf(json) {
+    try {
+        const value = JSON.parse(json);
+        const partialRuns = field(value, "partialRuns");
+        const completedPullRequest = field(value, "completedPullRequest");
+        if (field(value, "version") !== 1 ||
+            !Array.isArray(partialRuns) ||
+            !partialRuns.every(isPartialRun) ||
+            new Set(partialRuns.map((run) => run.pullRequest)).size !==
+                partialRuns.length ||
+            (completedPullRequest !== undefined &&
+                !isPositiveInteger(completedPullRequest)))
+            return undefined;
+        return {
+            version: 1,
+            partialRuns,
+            ...(completedPullRequest === undefined ? {} : { completedPullRequest }),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function statusText(history) {
+    const lines = history.partialRuns.map((run) => `- Pull request #${String(run.pullRequest)}: partial. Remaining: ${run.remaining.join("; ")}`);
+    if (history.completedPullRequest !== undefined)
+        lines.push(`Completed in pull request #${String(history.completedPullRequest)}.`);
+    return `## Cloving status\n${lines.join("\n")}\n\n`;
+}
+function legacyFence(line) {
+    const marker = /^( {0,3}(?:[-+*]|\d{1,9}[.)])[ \t]+)? {0,3}(`{3,}|~{3,})/.exec(line);
+    if (marker === null || marker[2] === undefined)
+        return undefined;
+    const delimiter = marker[2];
+    if (delimiter.startsWith("`") && line.slice(marker[0].length).includes("`"))
+        return undefined;
+    const indentation = (marker[1]?.length ?? 0) + 3;
+    return new RegExp(`^ {0,${String(indentation)}}${delimiter.charAt(0)}{${String(delimiter.length)},}[ \\t]*\\r?\\n?$`);
+}
+function legacyStatusStart(body) {
+    let fence;
+    let offset = 0;
+    for (const line of body.split(/(?<=\n)/)) {
+        const start = offset;
+        offset += line.length;
+        if (fence !== undefined) {
+            fence = fence.test(line) ? undefined : fence;
+            continue;
+        }
+        if (line.trimEnd() === "## Cloving status")
+            return start;
+        fence = legacyFence(line);
+    }
+    return body.length;
+}
+function statusSection(body) {
+    const empty = { version: 1, partialRuns: [] };
+    const marker = /^<!-- cloving-status(?=\s|-->|$)/gm;
+    const start = [...body.matchAll(marker)].at(-1)?.index;
+    if (start === undefined)
+        return { outside: body.slice(0, legacyStatusStart(body)), history: empty };
+    const tail = body.slice(start);
+    const end = tail.indexOf("-->");
+    if (end !== -1 && tail.slice(end + 3).trim() !== "")
+        return { outside: body, history: empty };
+    const outside = body.slice(0, start);
+    if (end === -1)
+        return { outside, history: empty };
+    const history = historyOf(tail.slice("<!-- cloving-status".length, end).trim());
+    if (history === undefined)
+        return { outside, history: empty };
+    const section = statusText(history);
+    return {
+        outside: outside.endsWith(section)
+            ? outside.slice(0, -section.length)
+            : outside,
+        history,
+    };
+}
+function withStatus(outside, history) {
+    const separator = "\n".repeat(Math.max(0, 2 - (outside.match(/\n*$/)?.[0].length ?? 0)));
+    const json = JSON.stringify(history)
+        .replace(/--/g, "\\u002d\\u002d")
+        .replace(/>/g, "\\u003e");
+    return `${outside}${outside === "" ? "" : separator}${statusText(history)}<!-- cloving-status\n${json}\n-->\n`;
+}
+async function writeIssue(operation, update) {
+    const { path, body, labels } = update;
+    const latest = await readIssue(operation, path);
+    if (latest.body !== update.originalBody)
+        throw new Error("github-issue-conflict");
+    const fields = update.fields ?? [];
+    if (body !== latest.body || fields.length > 0)
+        await operation.calls.gh([
+            "api",
+            "-X",
+            "PATCH",
+            path,
+            "-f",
+            `body=${body}`,
+            ...fields,
+        ]);
+    const add = workflowLabels.filter((name) => labels.includes(name) && !latest.labels.includes(name));
+    const remove = workflowLabels.filter((name) => !labels.includes(name) && latest.labels.includes(name));
+    if (add.length === 0 && remove.length === 0)
+        return;
+    await operation.calls.gh([
+        "issue",
+        "edit",
+        String(positiveInteger(operation, "number")),
+        "--repo",
+        `${text(operation, "owner")}/${text(operation, "repository")}`,
+        ...add.flatMap((name) => ["--add-label", name]),
+        ...remove.flatMap((name) => ["--remove-label", name]),
+    ]);
+}
+function sameLabels(first, second) {
+    return JSON.stringify(first.toSorted()) === JSON.stringify(second.toSorted());
+}
+export async function closeIssue(operation) {
+    const path = issuePath(operation);
+    const pull = positiveInteger(operation, "pullRequest");
+    const issue = await readIssue(operation, path);
+    const section = statusSection(issue.body);
+    const body = withStatus(section.outside, {
+        ...section.history,
+        completedPullRequest: pull,
+    });
+    const labels = issue.labels.filter((name) => !["cloving: ready", "cloving: blocked", "cloving: in progress"].includes(name));
+    if (body === issue.body &&
+        sameLabels(issue.labels, labels) &&
+        issue.state === "closed" &&
+        issue.reason === "completed")
+        return {
+            number: positiveInteger(operation, "number"),
+            ticketStatus: "complete",
+        };
+    await writeIssue(operation, {
+        path,
+        originalBody: issue.body,
+        body,
+        labels,
+        fields: issue.state === "closed" && issue.reason === "completed"
+            ? []
+            : ["-f", "state=closed", "-f", "state_reason=completed"],
+    });
+    return {
+        number: positiveInteger(operation, "number"),
+        ticketStatus: "complete",
+    };
+}
+function remainingItems(operation) {
+    const items = operation.payload["remaining"];
+    if (!Array.isArray(items) ||
+        items.length === 0 ||
+        items.some((item) => typeof item !== "string" || item.trim() === "" || /[\r\n]/.test(item)))
+        throw new Error("invalid-payload");
+    return items.map(String);
+}
+function publicRemaining(operation) {
+    const remaining = remainingItems(operation);
+    try {
+        issuePrivacy(remaining.join("; "), {
+            settings: operation.settings,
+            repository: `${text(operation, "owner")}/${text(operation, "repository")}`,
+        });
+        return remaining;
+    }
+    catch {
+        return [privateRemaining];
+    }
+}
+function partialHistory(section, status) {
+    const recorded = section.history.partialRuns.some((run) => run.pullRequest === status.pull);
+    for (const remaining of [status.remaining, [privateRemaining]]) {
+        const history = {
+            ...section.history,
+            partialRuns: recorded
+                ? section.history.partialRuns
+                : [
+                    ...section.history.partialRuns,
+                    { pullRequest: status.pull, remaining },
+                ],
+        };
+        if (Buffer.byteLength(withStatus(section.outside, history)) <= issueBodyBytes)
+            return history;
+    }
+    throw new Error("github-issue-too-large");
+}
+export async function partialIssue(operation) {
+    const path = issuePath(operation);
+    const pull = positiveInteger(operation, "pullRequest");
+    const remaining = publicRemaining(operation);
+    const issue = await readIssue(operation, path);
+    const section = statusSection(issue.body);
+    const history = partialHistory(section, { pull, remaining });
+    const count = history.partialRuns.length;
+    const label = count >= 3 ? "cloving: blocked" : "cloving: ready";
+    const body = withStatus(section.outside, history);
+    const labels = [
+        ...issue.labels.filter((name) => ![
+            "cloving: ready",
+            "cloving: blocked",
+            "cloving: in progress",
+        ].includes(name)),
+        label,
+    ];
+    if (body === issue.body && sameLabels(issue.labels, labels))
+        return {
+            number: positiveInteger(operation, "number"),
+            ticketStatus: "partial",
+        };
+    const repository = `${text(operation, "owner")}/${text(operation, "repository")}`;
+    await operation.calls.gh([
+        "label",
+        "create",
+        label,
+        "--repo",
+        repository,
+        "--color",
+        "ededed",
+        "--force",
+    ]);
+    await writeIssue(operation, {
+        path,
+        originalBody: issue.body,
+        body,
+        labels,
+    });
+    return {
+        number: positiveInteger(operation, "number"),
+        ticketStatus: "partial",
+    };
+}

package/dist/src/daemon/github-worker.js

@@ -1,7 +1,7 @@
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { calls } from "./github-calls.js";
-import { methodReasons, methods, } from "./github-methods.js";
+import { methodReasons, methods, ReviewTimeout, } from "./github-methods.js";
 import { interrupted, located, readRecord, replied, reportOf, writeRecord, } from "./operation-journal.js";
 const worker = "github";
 const closing = "github-worker-closed";
@@ -62,6 +62,7 @@ async function outcome(parts, run) {
         return {
             ...interrupted(methodReasons.has(reason) ? reason : "github-call-failed"),
             ...(typeof detail === "string" ? { detail } : {}),
+            ...(error instanceof ReviewTimeout ? { result: error.detail } : {}),
         };
     }
 }

package/dist/src/daemon/handoff-worker.d.ts

@@ -0,0 +1,10 @@
+import type { EffectDelivery } from "./delivery-router.ts";
+interface Settings {
+    readonly runtimeDirectory: string;
+    readonly journal: string;
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly runStatus: (runId: string) => Promise<string | undefined>;
+    readonly retryMilliseconds?: number;
+}
+export declare function handoffWorker(settings: Settings): EffectDelivery;
+export {};

package/dist/src/daemon/handoff-worker.js

@@ -0,0 +1,232 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { send } from "../cli/client.js";
+import { record } from "../protocol.js";
+import { runIdentity } from "../service/submission-handler.js";
+import { located, readRecord, writeRecord } from "./operation-journal.js";
+const attempts = 10;
+const uncertain = [
+    "outcome-unknown",
+    "service-unavailable",
+    "service-busy",
+    "storage-failure",
+    "authority-unavailable",
+    "resolver-timeout",
+    "resolver-failure",
+];
+function own(intent) {
+    return (intent.kind === "protected-effect" &&
+        intent.capability === "handoff" &&
+        intent.method === "run" &&
+        intent.target !== undefined &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+function completed(runId) {
+    return {
+        kind: "completed",
+        worker: "handoff",
+        receipt: runId,
+        result: runId,
+    };
+}
+async function saved(folder) {
+    const stored = record(await readRecord(folder, "result.json"));
+    if (stored === undefined)
+        return undefined;
+    if (stored["kind"] === "completed" && typeof stored["result"] === "string")
+        return completed(stored["result"]);
+    if (stored["kind"] === "failed" && typeof stored["reason"] === "string")
+        return { kind: "failed", reason: stored["reason"] };
+    throw new Error("invalid-handoff-journal");
+}
+async function retained(folder, outcome) {
+    if (["completed", "failed"].includes(outcome.kind))
+        await writeRecord(folder, {
+            name: "result.json",
+            value: outcome,
+            permissions: "private",
+        });
+    return outcome;
+}
+function outcome(reply) {
+    if (reply.kind !== "error") {
+        const runId = reply.result["runId"];
+        return reply.result["kind"] === "run-admitted" && typeof runId === "string"
+            ? completed(runId)
+            : { kind: "unknown" };
+    }
+    if (reply.error.code === "workflow-active")
+        return undefined;
+    if (reply.error.code === "chain-limit")
+        return { kind: "failed", reason: "chain-limit" };
+    return uncertain.includes(reply.error.code)
+        ? { kind: "unknown" }
+        : { kind: "failed", reason: "handoff-input-refused" };
+}
+async function input(settings, intent) {
+    const text = await settings.document(intent.payload);
+    try {
+        return record(JSON.parse(text ?? "null"));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function submit(settings, call) {
+    const { intent, signal } = call;
+    if (!own(intent))
+        return { kind: "failed", reason: "unsupported-effect" };
+    const { folder } = located(settings.journal, intent.operationId);
+    const known = await saved(folder);
+    if (known !== undefined)
+        return known;
+    const submission = await input(settings, intent);
+    if (submission === undefined)
+        return retained(folder, {
+            kind: "failed",
+            reason: "handoff-input-refused",
+        });
+    const previous = await busyAttempts(folder);
+    for (let busy = previous; busy < attempts; busy += 1) {
+        if (!(await allowed(settings, { intent, signal })))
+            return { kind: "unknown" };
+        const reply = await submitted(settings, {
+            intent,
+            submission,
+            signal,
+            folder,
+        });
+        if (reply === undefined)
+            return { kind: "unknown" };
+        const result = outcome(reply);
+        if (result !== undefined)
+            return retained(folder, result);
+        await writeRecord(folder, {
+            name: "attempts.json",
+            value: { busy: busy + 1 },
+            permissions: "private",
+        });
+        if (busy + 1 < attempts)
+            await delay(settings.retryMilliseconds ?? 1000, undefined, {
+                signal,
+            }).catch(() => undefined);
+    }
+    return retained(folder, { kind: "failed", reason: "handoff-start-timeout" });
+}
+async function submitted(settings, call) {
+    const { intent, submission, folder, signal } = call;
+    const marker = (status) => writeRecord(folder, {
+        name: "submission.json",
+        value: { processId: process.pid, pending: status === "pending" },
+        permissions: "private",
+    });
+    await marker("pending");
+    if (!(await allowed(settings, { intent, signal }))) {
+        await marker("settled");
+        return undefined;
+    }
+    const reply = await send(settings.runtimeDirectory, {
+        operation: "run",
+        parameters: {
+            workflowId: intent.target,
+            source: "input",
+            submission,
+            commandId: `handoff:${intent.operationId}`,
+        },
+    });
+    if (reply.kind !== "error" || reply.error.code !== "outcome-unknown")
+        await marker("settled");
+    return reply;
+}
+async function allowed(settings, call) {
+    try {
+        call.signal.throwIfAborted();
+        const status = await settings.runStatus(call.intent.runId);
+        call.signal.throwIfAborted();
+        return status === "running";
+    }
+    catch {
+        return false;
+    }
+}
+async function inFlight(folder) {
+    const marker = record(await readRecord(folder, "submission.json"));
+    if (marker?.["pending"] !== true)
+        return false;
+    const pid = marker["processId"];
+    if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
+        throw new Error("invalid-handoff-journal");
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return !(error instanceof Error &&
+            "code" in error &&
+            error.code === "ESRCH");
+    }
+}
+async function busyAttempts(folder) {
+    const previous = record(await readRecord(folder, "attempts.json"))?.["busy"] ?? 0;
+    if (typeof previous !== "number" ||
+        !Number.isSafeInteger(previous) ||
+        previous < 0 ||
+        previous > attempts)
+        throw new Error("invalid-handoff-journal");
+    return previous;
+}
+async function observed(settings, intent) {
+    if (!own(intent))
+        return { kind: "failed", reason: "unsupported-effect" };
+    const known = await saved(located(settings.journal, intent.operationId).folder);
+    if (known !== undefined)
+        return known;
+    const reply = await send(settings.runtimeDirectory, {
+        operation: "status",
+        parameters: { runId: runIdentity(`handoff:${intent.operationId}`) },
+    });
+    if (reply.kind === "error")
+        return reply.error.code === "unknown-run"
+            ? {
+                kind: (await inFlight(located(settings.journal, intent.operationId).folder))
+                    ? "unknown"
+                    : "absent",
+            }
+            : { kind: "unknown" };
+    const runId = record(reply.result["run"])?.["runId"];
+    return typeof runId === "string" ? completed(runId) : { kind: "unknown" };
+}
+export function handoffWorker(settings) {
+    const pending = new Map();
+    const deliver = (intent, signal) => {
+        const known = pending.get(intent.operationId);
+        if (known !== undefined)
+            return known.result;
+        const stopping = new AbortController();
+        const result = submit(settings, {
+            intent,
+            signal: AbortSignal.any([signal, stopping.signal]),
+        }).finally(() => pending.delete(intent.operationId));
+        pending.set(intent.operationId, { stopping, result });
+        return result;
+    };
+    return {
+        deliver,
+        reconcile: (intent) => observed(settings, intent),
+        retry: async (intent, signal) => {
+            if (!own(intent))
+                return { kind: "failed", reason: "unsupported-effect" };
+            const { folder } = located(settings.journal, intent.operationId);
+            if (!(await inFlight(folder)))
+                return { kind: "unknown" };
+            return deliver(intent, signal);
+        },
+        stop: async (intent) => {
+            const active = pending.get(intent.operationId);
+            active?.stopping.abort();
+            await active?.result;
+            const known = await observed(settings, intent);
+            return known.kind === "absent" ? { kind: "stopped" } : known;
+        },
+    };
+}

package/dist/src/daemon/issue-queue.d.ts

@@ -2,6 +2,8 @@ interface QueueSettings {
     readonly directory: string;
     readonly runtimeDirectory: string;
     readonly intervalMilliseconds: number;
+    readonly lanes?: number;
+    readonly resetQueue?: boolean;
 }
 export declare function issueQueue(settings: QueueSettings): {
     readonly stop: () => Promise<void>;