cloving 1.2.0 → 1.4.0

package/dist/src/daemon/claude-recovery.js

@@ -0,0 +1,204 @@
+import { usageOf, priceOf } from "../worker-usage.js";
+import { located, readRecord, writeRecord, interrupted, replied, reportOf, } from "./operation-journal.js";
+import { turnHarness } from "../harness-defaults.js";
+import { selectedProfile } from "./worker-profile.js";
+import { recordedProcessDirectory } from "./worktree-processes.js";
+import { resumeWorktree } from "./resume-worktree.js";
+export const resumePrompt = "This turn stopped because the Cloving daemon restarted. Continue the task from the point where it stopped. Run again each command or subagent that did not end. End with the result line that the task asks for.";
+export function turnIntent(intent) {
+    return (intent.capability === "claude" &&
+        intent.method !== "run-turn:analyze-chats" &&
+        (intent.method === "run-turn" ||
+            /^run-turn:[A-Za-z0-9_-]{1,119}$/.test(intent.method ?? "")) &&
+        intent.target !== undefined &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+export function resumableHarness(harness) {
+    return harness === "claude" || harness === "codex";
+}
+export function resumedCommand(request) {
+    const { worker = "claude", command, sessionId } = request;
+    if (worker === "codex")
+        return codexResume(command, sessionId);
+    if (worker !== "claude")
+        return undefined;
+    const separator = command.indexOf("--");
+    const boundary = separator < 0 ? command.length : separator;
+    return [
+        ...command.slice(0, boundary),
+        "--resume",
+        sessionId,
+        ...command.slice(boundary),
+    ];
+}
+function codexResume(command, sessionId) {
+    const exec = command.indexOf("exec");
+    if (exec < 0)
+        return undefined;
+    return [
+        ...command.slice(0, exec + 1),
+        "resume",
+        sessionId,
+        ...command.slice(exec + 1),
+    ];
+}
+export function recordedField(value, name) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    return Reflect.get(value, name);
+}
+export function processAlive(processId) {
+    if (typeof processId !== "number")
+        return false;
+    try {
+        process.kill(processId, 0);
+        return true;
+    }
+    catch (error) {
+        return recordedField(error, "code") === "EPERM";
+    }
+}
+export async function uncertainProcess(started) {
+    const processId = recordedField(started, "processId");
+    if (typeof processId !== "number" || !processAlive(processId))
+        return false;
+    return (!resumableHarness(recordedField(started, "harness")) ||
+        (await recordedProcessDirectory(processId)) === undefined);
+}
+export function recordedTree(started) {
+    const path = recordedField(started, "worktree");
+    const branch = recordedField(started, "branch");
+    const startCommit = recordedField(started, "startCommit");
+    return typeof path === "string" &&
+        typeof branch === "string" &&
+        typeof startCommit === "string"
+        ? { path, branch, startCommit }
+        : undefined;
+}
+export async function resumePlan(settings, request) {
+    const { folder, started, intent, signal } = request;
+    const resume = await readResume(folder, started);
+    const tree = recordedTree(started);
+    if (resume === undefined || tree === undefined)
+        return "claude-turn-interrupted";
+    const profile = await selectedProfile(settings, intent);
+    if (typeof profile === "string")
+        return "claude-turn-interrupted";
+    const harness = turnHarness(settings, profile);
+    if (recordedField(started, "harness") !== harness.worker ||
+        resumedCommand({
+            worker: harness.worker,
+            command: harness.command,
+            sessionId: resume.sessionId,
+        }) === undefined)
+        return "claude-turn-interrupted";
+    const locked = await resumeWorktree({
+        ...settings,
+        directory: tree.path,
+        folder,
+        signal,
+    });
+    return locked === null ? { resume, tree, profile, harness } : locked.reason;
+}
+function priorEnd(record) {
+    const field = (name) => recordedField(record, name);
+    const sessionId = field("sessionId");
+    const model = field("model");
+    const retryKind = field("retryKind");
+    return {
+        ...(retryKind === "capacity" ||
+            retryKind === "network" ||
+            retryKind === null
+            ? { retryKind }
+            : {}),
+        ...(field("resumedAfter") === "daemon-restart"
+            ? { resumedAfter: "daemon-restart" }
+            : {}),
+        exitCode: null,
+        result: {
+            sessionId: typeof sessionId === "string" ? sessionId : null,
+            model: typeof model === "string" ? model : null,
+            text: "",
+            failed: true,
+            costUsd: recordedSessionCost(record),
+            turns: typeof field("turns") === "number" ? Number(field("turns")) : null,
+            usage: usageOf(field("usage")),
+        },
+    };
+}
+function recordedSessionCost(record) {
+    const fields = typeof record === "object" && record !== null ? record : {};
+    const name = Object.hasOwn(fields, "sessionCostUsd")
+        ? "sessionCostUsd"
+        : "costUsd";
+    return priceOf(Reflect.get(fields, name));
+}
+function resumeHeader(started) {
+    if (recordedField(started, "phase") === "waiting")
+        return undefined;
+    const attempt = recordedField(started, "attempt");
+    const startedAt = recordedField(started, "startedAt");
+    const head = recordedField(started, "turnStartCommit");
+    if (typeof attempt !== "number" ||
+        !Number.isSafeInteger(attempt) ||
+        attempt < 1 ||
+        attempt > 5 ||
+        typeof startedAt !== "string")
+        return undefined;
+    return {
+        attempt,
+        startedAt,
+        turnStartCommit: typeof head === "string" ? head : null,
+    };
+}
+export async function readResume(folder, started) {
+    const header = resumeHeader(started);
+    if (header === undefined)
+        return undefined;
+    const records = [];
+    for (let number = 1; number <= header.attempt; number += 1)
+        records.push(await readRecord(folder, `attempt-${String(number)}.json`));
+    const sessionId = recordedField(records.at(-1), "sessionId");
+    if (typeof sessionId !== "string" ||
+        sessionId === "" ||
+        records.filter((record) => recordedField(record, "resumedAfter") === "daemon-restart").length >= 2)
+        return undefined;
+    return {
+        sessionId,
+        ends: records.map(priorEnd),
+        startedAt: header.startedAt,
+        turnStartCommit: header.turnStartCommit,
+    };
+}
+export async function recordedHarness(journal, operationId) {
+    const { folder } = located(journal, operationId);
+    const started = await readRecord(folder, "started.json").catch(() => undefined);
+    const harness = recordedField(started, "harness");
+    return typeof harness === "string" ? harness : undefined;
+}
+export async function interruptedReply(place, reason) {
+    const ending = interrupted(reason);
+    await writeRecord(place.folder, { name: "result.json", value: ending });
+    return replied({ receipt: place.key, worker: "claude" }, ending);
+}
+export async function recoverTurn(operation, reconcile) {
+    const { intent, journal, report } = operation;
+    if (!resumableHarness(await recordedHarness(journal, intent.operationId)))
+        return;
+    const result = await reconcile();
+    if (operation.signal.aborted)
+        return;
+    if (result.kind === "completed" ||
+        result.kind === "failed" ||
+        result.kind === "stopped")
+        await report(reportOf({
+            intent,
+            worker: "claude",
+            commandId: `claude-turn:${located(journal, intent.operationId).key}`,
+        }, {
+            ...result,
+            outcome: result.kind,
+            endedAt: new Date().toISOString(),
+        }));
+}

package/dist/src/daemon/claude-stream.d.ts

@@ -0,0 +1,27 @@
+import type { ReviewVerdict } from "../review-subject.ts";
+import type { TicketStatus } from "../ticket-status.ts";
+import { type WorkerUsage, type WorkerAttemptUsage, type WorkerModelUsage, type RetryKind } from "../worker-usage.ts";
+export type Worker = string;
+export interface StreamResult {
+    readonly reviewFeedback?: string;
+    readonly reviewVerdict?: ReviewVerdict | null;
+    readonly models?: readonly WorkerModelUsage[];
+    readonly ticketStatusTooLarge?: true;
+    readonly ticketStatus?: TicketStatus;
+    readonly attempts?: readonly WorkerAttemptUsage[];
+    readonly pricingModel?: string | null;
+    readonly subtype?: string;
+    readonly errorType?: string;
+    readonly model: string | null;
+    readonly text: string;
+    readonly failed: boolean;
+    readonly costUsd: number | null;
+    readonly usage: WorkerUsage;
+    readonly sessionId: string | null;
+    readonly turns: number | null;
+}
+export declare function parsed(line: string): unknown;
+export declare function textOf(value: unknown): string | null;
+export declare function capacityRefusal(result: StreamResult | undefined): boolean;
+export declare function retryKind(result: StreamResult | undefined): RetryKind | null;
+export declare function streamResult(line: string, worker?: Worker): StreamResult | undefined;

package/dist/src/daemon/claude-stream.js

@@ -0,0 +1,63 @@
+import { grokResultFields } from "../grok-result.js";
+import { priceOf, modelUsageOf, usageOf, } from "../worker-usage.js";
+export function parsed(line) {
+    try {
+        const value = JSON.parse(line);
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function numberOf(value) {
+    return typeof value === "number" ? value : null;
+}
+export function textOf(value) {
+    return typeof value === "string" ? value : null;
+}
+function networkFailure(result) {
+    return (result?.failed === true &&
+        result.text.startsWith("API Error: Can't reach the API server"));
+}
+export function capacityRefusal(result) {
+    if (networkFailure(result))
+        return false;
+    return (result?.failed === true &&
+        ["success", "error_during_execution"].includes(result.subtype ?? "error_during_execution") &&
+        (result.text ===
+            "Selected model is at capacity. Please try a different model." ||
+            result.errorType === "overloaded"));
+}
+export function retryKind(result) {
+    if (networkFailure(result))
+        return "network";
+    return capacityRefusal(result) ? "capacity" : null;
+}
+export function streamResult(line, worker) {
+    if (!line.includes('"result"'))
+        return undefined;
+    const record = parsed(line);
+    if (typeof record !== "object" || record === null)
+        return undefined;
+    const field = (name) => Reflect.get(record, name);
+    if (field("type") !== "result")
+        return undefined;
+    const models = modelUsageOf(field("models"));
+    return {
+        ...(models === undefined ? {} : { models }),
+        ...(typeof field("subtype") === "string"
+            ? { subtype: String(field("subtype")) }
+            : {}),
+        ...(typeof field("error") === "string"
+            ? { errorType: String(field("error")) }
+            : {}),
+        text: textOf(field("result")) ?? "",
+        failed: field("is_error") === true,
+        costUsd: priceOf(field("total_cost_usd")),
+        usage: usageOf(field("usage")),
+        model: textOf(field("model")),
+        sessionId: textOf(field("session_id")),
+        turns: numberOf(field("num_turns")),
+        ...(worker === "grok" ? grokResultFields(record) : {}),
+    };
+}

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

@@ -1,25 +1,21 @@
-import { type WorkerUsage, type WorkerAttemptUsage } from "../worker-usage.ts";
-export type Worker = "claude" | "codex";
-export interface StreamResult {
-    readonly attempts?: readonly WorkerAttemptUsage[];
-    readonly subtype?: string;
-    readonly errorType?: string;
-    readonly model: string | null;
-    readonly text: string;
-    readonly failed: boolean;
-    readonly costUsd: number | null;
-    readonly usage: WorkerUsage;
-    readonly sessionId: string | null;
-    readonly turns: number | null;
-}
+import { type Worker, type StreamResult } from "./claude-stream.ts";
+import { type RetryKind } from "../worker-usage.ts";
+export { streamResult, capacityRefusal, retryKind } from "./claude-stream.ts";
+export type { Worker, StreamResult } from "./claude-stream.ts";
 export interface TurnEnd {
+    readonly retryKind?: RetryKind | null;
+    readonly resumedAfter?: "daemon-restart";
+    readonly reason?: string;
+    readonly detail?: string;
     readonly stopped?: boolean;
     readonly exitCode: number | null;
     readonly result: StreamResult | undefined;
 }
 export interface TurnStart {
-    readonly mode?: "analysis";
-    readonly analysisToken?: string;
+    readonly progress?: (progress: TurnProgress) => Promise<void>;
+    readonly resultBytes?: number;
+    readonly output?: "text";
+    readonly shell?: string;
     readonly worker?: Worker;
     readonly turnId?: string;
     readonly environment?: Readonly<Record<string, string>>;
@@ -29,11 +25,15 @@ export interface TurnStart {
     readonly activityFolder?: string;
     readonly prompt: string;
 }
+export interface TurnProgress {
+    readonly sessionId: string | null;
+    readonly result: StreamResult | undefined;
+}
 export interface RunningTurn {
     readonly processId: number | null;
     readonly ended: Promise<TurnEnd>;
     readonly stop: (graceMilliseconds: number) => void;
 }
-export declare function capacityRefusal(result: StreamResult | undefined): boolean;
-export declare function streamResult(line: string): StreamResult | undefined;
+export declare function succeeded(end: TurnEnd): boolean;
+export declare function turnEnvironment(configuration: string, start: TurnStart): NodeJS.ProcessEnv;
 export declare function startTurn(start: TurnStart): RunningTurn;