cloving 1.0.1 → 1.1.0

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

@@ -0,0 +1,268 @@
+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 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, 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/issue-queue.d.ts

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

package/dist/src/daemon/issue-queue.js

@@ -1,10 +1,27 @@
 import { randomUUID } from "node:crypto";
-import { readFile, rename, writeFile } from "node:fs/promises";
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 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";
+function savedHold(value) {
+    if (value === undefined)
+        return undefined;
+    const held = record(value);
+    if (typeof held?.["mark"] !== "string" ||
+        typeof held["startedAt"] !== "number" ||
+        !Number.isFinite(held["startedAt"]) ||
+        held["startedAt"] <= 0)
+        throw new Error("invalid-queue-commands");
+    return { mark: held["mark"], startedAt: held["startedAt"] };
+}
+function identifiers(value) {
+    if (!Array.isArray(value) ||
+        !value.every((id) => typeof id === "string" && id.length > 0))
+        throw new Error("invalid-queue-commands");
+    return value.map(String);
+}
 async function journal(directory) {
     const file = join(directory, "queue-commands.json");
     const text = await readFile(file, "utf8").catch((error) => {
@@ -13,21 +30,26 @@ async function journal(directory) {
         throw error;
     });
     const value = JSON.parse(text);
-    if (!Array.isArray(value) ||
-        !value.every((id) => typeof id === "string" && id.length > 0))
+    const saved = record(value);
+    const commands = new Set(identifiers(Array.isArray(value) ? value : saved?.["commands"]));
+    const failures = Array.isArray(value) ? [] : identifiers(saved?.["failures"]);
+    if (failures.length > 3)
         throw new Error("invalid-queue-commands");
-    const commands = new Set(value.map(String));
-    return {
+    const pending = {
         commands,
+        failures,
         retryCommandId: undefined,
+        selfUpdateHold: savedHold(saved?.["selfUpdateHold"]),
         save: async () => {
-            await writeFile(`${file}.tmp`, JSON.stringify([...commands]) + "\n", {
-                mode: 0o600,
-                flush: true,
-            });
+            await writeFile(`${file}.tmp`, JSON.stringify({
+                commands: [...commands],
+                failures,
+                selfUpdateHold: pending.selfUpdateHold,
+            }) + "\n", { mode: 0o600, flush: true });
             await rename(`${file}.tmp`, file);
         },
     };
+    return pending;
 }
 function terminal(run) {
     return ["completed", "failed", "cancelled"].includes(String(run["state"]));
@@ -54,8 +76,20 @@ async function recover(settings, pending) {
         await pending.save();
     }
 }
+function handedOff(run) {
+    const outcome = record(run["outcome"]);
+    return (run["state"] === "completed" &&
+        outcome?.["kind"] === "handoff_requested" &&
+        outcome["issueUpdate"] !== "failed");
+}
+class QueueFailureLimit extends Error {
+}
+function checkFailureLimit(pending) {
+    if (pending.failures.length >= 3)
+        throw new QueueFailureLimit(`3 runs in a row ended without handoff: ${pending.failures.join(", ")}`);
+}
 async function completed(settings, pending) {
-    let failure;
+    checkFailureLimit(pending);
     let pendingRun = false;
     const tracked = [...pending.commands].filter((commandId) => commandId !== pending.retryCommandId);
     for (const commandId of tracked) {
@@ -66,19 +100,18 @@ async function completed(settings, pending) {
             pendingRun = true;
             continue;
         }
-        const outcome = record(run["outcome"]);
-        if (run["state"] !== "completed" ||
-            outcome?.["kind"] !== "handoff_requested")
-            failure ??= JSON.stringify({
-                runId: run["runId"],
-                state: run["state"],
-                outcome: run["outcome"] ?? null,
-            });
         pending.commands.delete(commandId);
+        if (handedOff(run))
+            pending.failures.length = 0;
+        else
+            pending.failures.push(runIdentity(commandId));
         await pending.save();
+        checkFailureLimit(pending);
+        if (!handedOff(run)) {
+            const outcome = record(run["outcome"]);
+            process.stderr.write(`Queue run ended ${String(outcome?.["kind"] ?? run["state"])}${outcome?.["issueUpdate"] === "failed" ? "; issueUpdate: failed" : ""}: ${runIdentity(commandId)}; continuing\n`);
+        }
     }
-    if (failure !== undefined)
-        throw new Error(failure);
     return pendingRun;
 }
 async function active(runtimeDirectory) {
@@ -121,9 +154,13 @@ async function submit(settings, pending) {
     pending.retryCommandId = undefined;
     if (reply.kind === "result")
         return;
-    if (reply.error.code === "resolver-timeout") {
+    if ([
+        "resolver-timeout",
+        "next-ticket-not-available",
+        "ticket-not-available",
+    ].includes(reply.error.code)) {
         pending.retryCommandId = commandId;
-        process.stderr.write(`Queue resolver-timeout: command ${commandId}; will retry\n`);
+        process.stderr.write(`Queue ${reply.error.code}: command ${commandId}; will retry\n`);
         return;
     }
     if (!["no-ready-ticket", "workflow-active"].includes(reply.error.code))
@@ -131,8 +168,59 @@ async function submit(settings, pending) {
     pending.commands.delete(commandId);
     await pending.save();
 }
+function updateHold(directory, pending) {
+    let notice;
+    return async () => {
+        const mark = await readFile(join(directory, "pending-self-update"), "utf8").catch((error) => {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                return undefined;
+            throw error;
+        });
+        if (mark === undefined && pending.selfUpdateHold !== undefined) {
+            pending.selfUpdateHold = undefined;
+            await pending.save();
+        }
+        if (mark === undefined) {
+            notice = undefined;
+            return false;
+        }
+        const timestamp = Number(mark);
+        if (!Number.isFinite(timestamp) || timestamp <= 0)
+            throw new Error("invalid-pending-self-update");
+        if (pending.selfUpdateHold?.mark !== mark) {
+            pending.selfUpdateHold = { mark, startedAt: Date.now() };
+            await pending.save();
+        }
+        const holding = Date.now() - pending.selfUpdateHold.startedAt < 30 * 60 * 1000;
+        const line = holding
+            ? "Queue holding for pending self-update\n"
+            : "Queue continuing after pending self-update time limit\n";
+        const key = mark + line;
+        if (notice !== key)
+            process.stderr.write(line);
+        notice = key;
+        return holding;
+    };
+}
+async function admission(settings, attempt) {
+    const file = join(settings.directory, "queue-submission");
+    await writeFile(file, "", { mode: 0o600 });
+    try {
+        if (!(await attempt.holding()) && !attempt.signal.aborted)
+            await submit(settings, attempt.pending);
+    }
+    finally {
+        await rm(file, { force: true });
+    }
+}
 async function cycle(settings, signal) {
     const pending = await journal(settings.directory);
+    if (settings.resetQueue === true) {
+        pending.failures.length = 0;
+        await pending.save();
+    }
+    const holding = updateHold(settings.directory, pending);
+    await rm(join(settings.directory, "queue-submission"), { force: true });
     await recover(settings, pending);
     const stopped = () => signal.aborted;
     while (!stopped()) {
@@ -143,16 +231,19 @@ async function cycle(settings, signal) {
             continue;
         if (await active(settings.runtimeDirectory))
             continue;
+        if (await holding())
+            continue;
         if (stopped())
             return;
-        await submit(settings, pending);
+        await admission(settings, { pending, holding, signal });
     }
 }
 export function issueQueue(settings) {
     const stopping = new AbortController();
     const running = cycle(settings, stopping.signal).catch((error) => {
         const reason = error instanceof Error ? error.message : String(error);
-        process.stderr.write(`Queue stopped: ${JSON.stringify(reason)}\n`);
+        const diagnostic = error instanceof QueueFailureLimit ? reason : JSON.stringify(reason);
+        process.stderr.write(`Queue stopped: ${diagnostic}\n`);
     });
     return {
         stop: async () => {

package/dist/src/daemon/operation-journal.d.ts

@@ -32,6 +32,7 @@ export declare function readRecord(folder: string, name: string): Promise<unknow
 export declare function writeRecord(folder: string, record: {
     readonly name: string;
     readonly value: unknown;
+    readonly permissions?: "private";
 }): Promise<void>;
 export declare function replied(identity: Identity, recorded: unknown): AdapterOutcome;
 export declare function interrupted(reason: string): Recorded;

package/dist/src/daemon/operation-journal.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 export function operationKey(text) {
     return createHash("sha256").update(text).digest("hex").slice(0, 32);
@@ -16,7 +16,9 @@ export async function readRecord(folder, name) {
 export async function writeRecord(folder, record) {
     const path = join(folder, record.name);
     await mkdir(folder, { recursive: true });
-    await writeFile(`${path}.staged`, JSON.stringify(record.value, null, 2));
+    if (record.permissions === "private")
+        await chmod(folder, 0o700);
+    await writeFile(`${path}.staged`, JSON.stringify(record.value, null, 2), record.permissions === "private" ? { mode: 0o600 } : {});
     await rename(`${path}.staged`, path);
 }
 export function replied(identity, recorded) {

package/dist/src/daemon/retrying-turn.d.ts

@@ -0,0 +1,9 @@
+import { type RunningTurn, type TurnStart } from "./claude-turn.ts";
+export interface RetrySettings {
+    readonly retryDelay?: (milliseconds: number, signal: AbortSignal) => Promise<void>;
+}
+interface RetryOptions extends RetrySettings {
+    readonly metadata: Readonly<Record<string, unknown>>;
+}
+export declare function startRetriedTurn(start: TurnStart, options: RetryOptions): Promise<RunningTurn>;
+export {};