cloving 0.3.20 → 1.1.0

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

@@ -0,0 +1,276 @@
+import { join } from "node:path";
+import { ticketStatus } from "../ticket-status.js";
+import { analysisWorker } from "./analysis-worker.js";
+import { analysisMethod } from "./analysis-launch.js";
+import { estimatedCostUsd, priceForModel, } from "../token-prices.js";
+import { profileCommand, } from "../turn-profile.js";
+import {} from "./claude-turn.js";
+import { startRetriedTurn } from "./retrying-turn.js";
+import { interrupted, located, operationKey, readRecord as read, replied, reportOf, writeRecord as written, } from "./operation-journal.js";
+import { changes, treeFailure, workTree } from "./work-tree.js";
+export const claudeLimits = {
+    summaryCharacters: 16_000,
+    resultBytes: 48_000,
+    stopMilliseconds: 2_000,
+};
+const worker = "claude";
+function alive(processId) {
+    if (typeof processId !== "number")
+        return false;
+    try {
+        process.kill(processId, 0);
+        return true;
+    }
+    catch (error) {
+        return Reflect.get(Object(error), "code") === "EPERM";
+    }
+}
+async function reconciled(parts, intent) {
+    const { key, folder } = located(parts.settings.journal, intent.operationId);
+    const result = await read(folder, "result.json");
+    if (result !== undefined)
+        return replied({ receipt: key, worker }, result);
+    if (parts.active.has(key))
+        return { kind: "accepted", receipt: key, worker };
+    const started = await read(folder, "started.json");
+    if (started === undefined)
+        return { kind: "absent" };
+    if (alive(Reflect.get(Object(started), "processId")))
+        return { kind: "unknown", evidence: `claude-turn:${key}` };
+    const ending = interrupted("claude-turn-interrupted");
+    await written(folder, { name: "result.json", value: ending });
+    return replied({ receipt: key, worker }, ending);
+}
+async function resultText(tree, turn) {
+    const { result, settings } = turn;
+    const fields = {
+        ticketStatus: ticketStatus(result.text),
+        summary: result.text.slice(0, claudeLimits.summaryCharacters),
+        ...(await changes(tree)),
+        worktree: tree.path,
+        costUsd: result.costUsd,
+        usage: result.usage,
+        model: result.model,
+        estimatedCostUsd: estimatedCostUsd(result.usage, {
+            worker: settings.worker ?? "claude",
+            price: priceForModel(settings.tokenPrices ?? {}, result.model),
+        }),
+        sessionId: result.sessionId,
+        turns: result.turns,
+    };
+    const text = JSON.stringify(fields);
+    const excess = Buffer.byteLength(text) - claudeLimits.resultBytes;
+    if (excess <= 0)
+        return { text };
+    const kept = Math.max(0, fields.summary.length - excess);
+    const shortened = JSON.stringify({
+        ...fields,
+        summary: fields.summary.slice(0, kept),
+    });
+    if (Buffer.byteLength(shortened) <= claudeLimits.resultBytes)
+        return { text: shortened };
+    const metadata = JSON.stringify({
+        ...fields,
+        ticketStatus: undefined,
+        summary: "",
+    });
+    return {
+        reason: "claude-result-too-large",
+        ...(Buffer.byteLength(metadata) <= claudeLimits.resultBytes
+            ? { text: metadata }
+            : {}),
+    };
+}
+async function outcome(running, end) {
+    const endedAt = new Date().toISOString();
+    const { result } = end;
+    const report = result === undefined
+        ? {}
+        : await resultText(running.tree, { result, settings: running.settings });
+    const { text, reason } = report;
+    if (reason === undefined &&
+        text !== undefined &&
+        end.exitCode === 0 &&
+        result?.failed === false)
+        return { outcome: "completed", result: text, endedAt };
+    if (running.stopping.requested)
+        return { outcome: "stopped", endedAt };
+    return {
+        outcome: "failed",
+        reason: reason ?? "claude-turn-failed",
+        ...(text === undefined ? {} : { result: text }),
+        endedAt,
+    };
+}
+async function concluded(parts, running) {
+    const { intent, key } = running;
+    const recorded = await outcome({ ...running, settings: parts.settings }, await running.turn.ended);
+    await written(running.folder, { name: "result.json", value: recorded });
+    await parts.settings.report(reportOf({ intent, commandId: `claude-turn:${key}`, worker }, recorded));
+}
+async function begun(parts, start) {
+    const { intent, key, folder, tree, prompt } = start;
+    const turn = startRetriedTurn({
+        worker: parts.settings.worker ?? "claude",
+        command: profileCommand(parts.settings.command, start.profile),
+        environment: start.profile.env ?? {},
+        turnId: `${intent.runId}-${key}`,
+        directory: tree.path,
+        folder,
+        prompt,
+    }, {
+        ...parts.settings,
+        metadata: {
+            operationId: intent.operationId,
+            target: intent.target,
+            branch: tree.branch,
+            worktree: tree.path,
+            startCommit: tree.startCommit,
+        },
+    });
+    const stopping = { requested: false };
+    parts.active.set(key, {
+        turn,
+        stopping,
+        concluded: turn
+            .then((running) => concluded(parts, { ...start, turn: running, stopping }))
+            .catch(() => undefined)
+            .finally(() => parts.active.delete(key)),
+    });
+    await turn;
+}
+async function firstTurn(settings, opening) {
+    const { tree, intent } = opening;
+    const { target, runId } = intent;
+    const folder = target.startsWith("branch:")
+        ? join(settings.journal, "runs", operationKey(runId), "targets")
+        : join(settings.journal, "targets");
+    const name = `${operationKey(target)}.json`;
+    const startCommit = Reflect.get(Object(await read(folder, name)), "startCommit");
+    if (typeof startCommit === "string")
+        return { ...tree, startCommit };
+    await written(folder, {
+        name,
+        value: { target, startCommit: tree.startCommit },
+    });
+    return tree;
+}
+function turnIntent(intent) {
+    return (intent.capability === worker &&
+        (intent.method === "run-turn" ||
+            /^run-turn:[A-Za-z0-9_-]{1,119}$/.test(intent.method ?? "")) &&
+        intent.target !== undefined &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+function failure(reason) {
+    return { kind: "failed", reason };
+}
+async function runWorkflow(settings, runId) {
+    try {
+        return await settings.workflowId?.(runId);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function selectedProfile(settings, intent) {
+    if (intent.method === "run-turn")
+        return {};
+    if (settings.worker === "codex")
+        return "profile-needs-claude";
+    const name = intent.method.slice("run-turn:".length);
+    const profiles = settings.profiles ?? {};
+    const profile = Object.hasOwn(profiles, name) ? profiles[name] : undefined;
+    if (profile === undefined)
+        return "unknown-profile";
+    if (profile.workflows === undefined)
+        return profile;
+    const workflowId = await runWorkflow(settings, intent.runId);
+    if (workflowId === undefined || !profile.workflows.includes(workflowId))
+        return "profile-not-allowed";
+    return profile;
+}
+async function delivered(parts, call) {
+    const { intent, signal } = call;
+    const { settings } = parts;
+    const aborted = () => signal.aborted;
+    if (!turnIntent(intent))
+        return failure("unsupported-effect");
+    if (aborted())
+        return failure("claude-start-aborted");
+    const known = await reconciled(parts, intent);
+    if (known.kind !== "absent")
+        return known;
+    const profile = await selectedProfile(settings, intent);
+    if (typeof profile === "string")
+        return failure(profile);
+    const prompt = await settings.document(intent.payload);
+    if (prompt === undefined)
+        return failure("payload-not-available");
+    const tree = await workTree({
+        repository: settings.repository,
+        worktrees: settings.worktrees,
+        target: intent.target,
+        signal,
+    }).catch(treeFailure);
+    if (aborted())
+        return failure("claude-start-aborted");
+    if (typeof tree === "string")
+        return failure(tree);
+    const place = located(settings.journal, intent.operationId);
+    const first = await firstTurn(settings, { tree, intent });
+    if (aborted())
+        return failure("claude-start-aborted");
+    await begun(parts, { ...place, intent, tree: first, prompt, profile });
+    return { receipt: place.key, worker };
+}
+async function halted(parts, active) {
+    active.stopping.requested = true;
+    const turn = await active.turn.catch(() => undefined);
+    turn?.stop(parts.settings.stopMilliseconds ?? claudeLimits.stopMilliseconds);
+    await active.concluded;
+}
+async function stopped(parts, intent) {
+    const { key } = located(parts.settings.journal, intent.operationId);
+    const active = parts.active.get(key);
+    if (active !== undefined)
+        await halted(parts, active);
+    return reconciled(parts, intent);
+}
+export function claudeWorker(settings) {
+    if (settings.command.length === 0)
+        throw new Error("invalid-claude-command");
+    const parts = {
+        settings,
+        active: new Map(),
+        stopping: new AbortController(),
+    };
+    const analysis = analysisWorker(settings);
+    const guarded = async (intent, run) => {
+        if (!turnIntent(intent) ||
+            Object.hasOwn(settings.profiles ?? {}, "analyze-chats") ||
+            (await runWorkflow(settings, intent.runId)) !== "analyze-chats")
+            return failure("analysis-worker-unavailable");
+        return run();
+    };
+    return {
+        deliver: (intent, signal) => intent.method === analysisMethod
+            ? guarded(intent, () => analysis.deliver(intent, signal))
+            : delivered(parts, {
+                intent,
+                signal: AbortSignal.any([signal, parts.stopping.signal]),
+            }),
+        reconcile: (intent, signal) => intent.method === analysisMethod
+            ? guarded(intent, () => analysis.reconcile(intent, signal))
+            : reconciled(parts, intent),
+        stop: (intent, signal) => intent.method === analysisMethod
+            ? guarded(intent, () => analysis.stop(intent, signal))
+            : stopped(parts, intent),
+        close: async () => {
+            parts.stopping.abort();
+            await analysis.close();
+            await Promise.all([...parts.active.values()].map((active) => halted(parts, active)));
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+export declare function codexStream(): {
+    readonly line: (line: string) => readonly string[];
+    readonly result: (exitCode: number | null) => string;
+};

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

@@ -0,0 +1,129 @@
+import { sumUsage, usageOf } from "../worker-usage.js";
+function record(value) {
+    return typeof value === "object" && value !== null ? { ...value } : {};
+}
+function parsed(line) {
+    try {
+        return record(JSON.parse(line));
+    }
+    catch {
+        return {};
+    }
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+function message(content) {
+    return JSON.stringify({ type: "assistant", message: { content: [content] } });
+}
+function commandError(item) {
+    const code = item["exit_code"];
+    if (item["status"] !== "failed" && !(typeof code === "number" && code !== 0))
+        return [];
+    const fallback = typeof code === "number" ? `exit code ${String(code)}` : "command failed";
+    const content = text(item["aggregated_output"]).slice(-2000) || fallback;
+    return [
+        JSON.stringify({
+            type: "user",
+            message: { content: [{ type: "tool_result", is_error: true, content }] },
+        }),
+    ];
+}
+function completed(item) {
+    if (item["type"] === "agent_message")
+        return [message({ type: "text", text: text(item["text"]) })];
+    if (item["type"] === "command_execution")
+        return commandError(item);
+    if (item["type"] !== "file_change" || !Array.isArray(item["changes"]))
+        return [];
+    return item["changes"].map((change) => message({
+        type: "tool_use",
+        name: "Edit",
+        input: { file_path: text(record(change)["path"]) },
+    }));
+}
+function updated(event, state) {
+    const type = event["type"];
+    if (typeof type === "string" &&
+        ["thread.started", "turn.started", "turn.completed"].includes(type))
+        state.model = text(event["model"]) || state.model;
+    if (type === "thread.started")
+        state.sessionId = text(event["thread_id"]) || null;
+    if (type === "turn.completed") {
+        const usage = record(event["usage"]);
+        const current = usageOf({
+            input_tokens: usage["input_tokens"],
+            cache_read_input_tokens: usage["cached_input_tokens"],
+            output_tokens: usage["output_tokens"],
+        });
+        state.usage =
+            state.turns === 0 ? current : sumUsage([state.usage, current]);
+        state.turns += 1;
+        state.error = null;
+    }
+    if (type === "turn.failed")
+        state.failure = text(record(event["error"])["message"]);
+    if (type === "error")
+        state.error = text(event["message"]);
+}
+function translated(event, state) {
+    updated(event, state);
+    const type = event["type"];
+    if (type === "thread.started")
+        return [
+            JSON.stringify({
+                type: "system",
+                subtype: "init",
+                session_id: state.sessionId,
+            }),
+        ];
+    const item = record(event["item"]);
+    if (type === "item.started" && item["type"] === "command_execution")
+        return [
+            message({
+                type: "tool_use",
+                name: "Bash",
+                input: { command: text(item["command"]) },
+            }),
+        ];
+    if (type !== "item.completed")
+        return [];
+    if (item["type"] === "agent_message")
+        state.message = text(item["text"]);
+    return completed(item);
+}
+export function codexStream() {
+    const state = {
+        model: null,
+        sessionId: null,
+        turns: 0,
+        usage: usageOf(null),
+        failure: null,
+        error: null,
+        message: "",
+    };
+    return {
+        line: (line) => translated(parsed(line), state),
+        result: (exitCode) => {
+            const success = exitCode === 0 &&
+                state.turns > 0 &&
+                state.failure === null &&
+                state.error === null;
+            return JSON.stringify({
+                type: "result",
+                subtype: success ? "success" : "error_during_execution",
+                is_error: !success,
+                result: success
+                    ? state.message
+                    : state.failure ||
+                        state.error ||
+                        `codex ended with the code ${String(exitCode)}`,
+                total_cost_usd: null,
+                ...(state.model === null ? {} : { model: state.model }),
+                usage: state.usage,
+                session_id: state.sessionId,
+                num_turns: state.turns,
+            });
+        },
+    };
+}

package/dist/src/daemon/daemon.d.ts

@@ -0,0 +1,49 @@
+import { type WorkflowFunction } from "../host/start-delivery.ts";
+import { type WorkflowHandler } from "../host/world-host.ts";
+import type { TurnProfiles } from "../turn-profile.ts";
+import type { TokenPrices } from "../token-prices.ts";
+import type { DeclaredWorkflow } from "../workflow-declaration.ts";
+import type { Worker } from "./claude-turn.ts";
+export interface DaemonSettings {
+    readonly tokenPrices?: TokenPrices;
+    readonly worker?: Worker;
+    readonly profiles?: TurnProfiles;
+    readonly directory: string;
+    readonly runtimeDirectory: string;
+    readonly repository: string;
+    readonly manifests: Readonly<Record<string, string | undefined>>;
+    readonly declarations?: readonly DeclaredWorkflow[];
+    readonly workflows: Readonly<Record<string, WorkflowFunction | undefined>>;
+    readonly handler: WorkflowHandler;
+    readonly command: readonly string[];
+    readonly ticketCommand?: readonly string[];
+    readonly nextCommand?: readonly string[];
+    readonly notifyCommand?: readonly string[];
+    readonly notifyMilliseconds?: number;
+    readonly queueMilliseconds?: number;
+    readonly resetQueue?: boolean;
+    readonly githubCommand?: readonly string[];
+    readonly checkCommand?: readonly string[];
+    readonly privateTexts?: readonly string[];
+    readonly concurrency: number;
+}
+export interface Daemon {
+    readonly socket: string;
+    readonly close: () => Promise<void>;
+}
+export type DaemonOpening = {
+    readonly kind: "started";
+    readonly daemon: Daemon;
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+    readonly detail: string;
+};
+export declare const turnLeaseMilliseconds: number;
+export declare const loopMilliseconds = 250;
+export declare const bridgeTiming: {
+    lookupTries: number;
+    pollMilliseconds: number;
+    retryMilliseconds: number;
+};
+export declare function startDaemon(settings: DaemonSettings): Promise<DaemonOpening>;

package/dist/src/daemon/daemon.js

@@ -0,0 +1,195 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { startDelivery, } from "../host/start-delivery.js";
+import { registerStepBridge, sdkStepCall, stepBridge, } from "../host/step-bridge-host.js";
+import { startHost } from "../host/world-host.js";
+import { worldLoop } from "../host/world-reconciliation.js";
+import { cancelled, workflowOutcome, taggedRun, taggedRuns, } from "../host/world-runs.js";
+import { startService, } from "../service/service.js";
+import { claudeWorker } from "./claude-worker.js";
+import { deliveryRouter } from "./delivery-router.js";
+import { githubWorker } from "./github-worker.js";
+import { chatsWorker } from "./chats-worker.js";
+import { worldDirectory } from "./host-environment.js";
+import { issueQueue } from "./issue-queue.js";
+import { notifyRuns } from "./notify.js";
+import { ticketRegistrations, ticketRegistrationTable, } from "./ticket-registration.js";
+export const turnLeaseMilliseconds = 4 * 3_600_000;
+export const loopMilliseconds = 250;
+export const bridgeTiming = {
+    lookupTries: 250,
+    pollMilliseconds: 250,
+    retryMilliseconds: 1_000,
+};
+async function hosted(settings, ports) {
+    const opening = await startHost({
+        dataDirectory: worldDirectory(settings.directory),
+        concurrency: settings.concurrency,
+        handler: settings.handler,
+    });
+    if (opening.kind === "refused")
+        throw new Error(`${opening.reason}: ${opening.detail}`);
+    const loop = worldLoop({
+        ...ports,
+        runs: taggedRuns,
+        outcome: workflowOutcome,
+        intervalMilliseconds: loopMilliseconds,
+    });
+    const stopping = new AbortController();
+    const remove = registerStepBridge(stepBridge({
+        ...ports,
+        run: taggedRun,
+        call: sdkStepCall,
+        stopped: stopping.signal,
+        timing: bridgeTiming,
+    }));
+    return {
+        reports: loop.reports,
+        close: async () => {
+            stopping.abort();
+            remove();
+            await loop.stop();
+            await opening.host.close();
+        },
+    };
+}
+function githubOf(settings, given) {
+    const { directory, repository, checkCommand } = settings;
+    return githubWorker({
+        document: async (digest) => (await given).document(digest),
+        report: async (effect) => (await given).reportEffect(effect),
+        operationStatus: async (operationId) => (await (await given).operation(operationId))?.status,
+        runStatus: async (runId) => (await (await given).state()).runs[runId]?.status,
+        repository,
+        gh: settings.githubCommand ?? ["gh"],
+        worktrees: join(directory, "worktrees"),
+        journal: join(directory, "github"),
+        ...(settings.privateTexts === undefined
+            ? {}
+            : { privateTexts: settings.privateTexts }),
+        ...(checkCommand === undefined ? {} : { check: checkCommand }),
+    });
+}
+function adapters(settings, options) {
+    const { directory, repository, command } = settings;
+    const { given, table } = options;
+    const workflows = Object.fromEntries(table.map((row) => [row.workflowId, settings.workflows[row.functionName]]));
+    const document = async (digest) => (await given).document(digest);
+    const report = async (effect) => (await given).reportEffect(effect);
+    const worker = claudeWorker({
+        tokenPrices: settings.tokenPrices ?? {},
+        worker: settings.worker ?? "claude",
+        profiles: settings.profiles ?? {},
+        workflowId: async (runId) => (await given).workflowId(runId),
+        repository,
+        command,
+        document,
+        report,
+        worktrees: join(directory, "worktrees"),
+        journal: join(directory, "journal"),
+    });
+    const github = githubOf(settings, given);
+    const chats = chatsWorker({
+        runtimeDirectory: settings.runtimeDirectory,
+        document,
+        workflowId: async (runId) => (await given).workflowId(runId),
+    });
+    const runs = startDelivery({
+        document,
+        runs: taggedRuns,
+        cancel: cancelled,
+        input: async (runId) => (await given).input(runId),
+        workflow: async (runId) => workflows[String(await (await given).workflowId(runId))],
+    });
+    return { worker, github, runs, chats };
+}
+export async function startDaemon(settings) {
+    const { directory } = settings;
+    const table = ticketRegistrationTable({
+        repository: settings.repository,
+        command: settings.ticketCommand,
+        nextCommand: settings.nextCommand,
+    }, settings.declarations);
+    const admitted = await ticketRegistrations(settings.manifests, { table });
+    if (admitted.kind === "rejected")
+        return {
+            kind: "refused",
+            reason: "workflow-rejected",
+            detail: admitted.detail,
+        };
+    const given = Promise.withResolvers();
+    const { worker, github, runs, chats } = adapters(settings, {
+        given: given.promise,
+        table,
+    });
+    await mkdir(join(directory, "state"), { recursive: true });
+    await mkdir(settings.runtimeDirectory, { recursive: true, mode: 0o700 });
+    const opening = await startService({
+        stateDirectory: join(directory, "state"),
+        runtimeDirectory: settings.runtimeDirectory,
+        workflows: admitted.registrations.map((registration) => ({
+            ...registration,
+            ...(settings.queueMilliseconds !== undefined &&
+                registration.workflowId === "develop-issue"
+                ? { admission: "when-idle" }
+                : {}),
+        })),
+        delivery: deliveryRouter({
+            runs,
+            effects: { claude: worker, github, chats },
+        }),
+        effects: { leaseMilliseconds: turnLeaseMilliseconds },
+        host: (ports) => {
+            given.resolve(ports);
+            return hosted(settings, ports);
+        },
+    });
+    if (opening.kind === "refused") {
+        await Promise.all([worker.close(), github.close(), chats.close()]);
+        return opening;
+    }
+    return {
+        kind: "started",
+        daemon: await runningDaemon(settings, {
+            service: opening.service,
+            worker,
+            github,
+            chats,
+        }),
+    };
+}
+async function runningDaemon(settings, resources) {
+    const { service, worker, github, chats } = resources;
+    await github.scan();
+    const notifier = settings.notifyCommand === undefined
+        ? undefined
+        : await notifyRuns({
+            directory: settings.directory,
+            runtimeDirectory: settings.runtimeDirectory,
+            command: settings.notifyCommand,
+            ...(settings.notifyMilliseconds === undefined
+                ? {}
+                : { intervalMilliseconds: settings.notifyMilliseconds }),
+        }).catch(async (error) => {
+            await Promise.all([worker.close(), github.close(), chats.close()]);
+            await service.close();
+            throw error;
+        });
+    const queue = settings.queueMilliseconds === undefined
+        ? undefined
+        : issueQueue({
+            directory: settings.directory,
+            runtimeDirectory: settings.runtimeDirectory,
+            intervalMilliseconds: settings.queueMilliseconds,
+            resetQueue: settings.resetQueue ?? false,
+        });
+    return {
+        socket: service.socket,
+        close: async () => {
+            await notifier?.stop();
+            await queue?.stop();
+            await Promise.all([worker.close(), github.close(), chats.close()]);
+            await service.close();
+        },
+    };
+}

package/dist/src/daemon/delivery-router.d.ts

@@ -0,0 +1,10 @@
+import type { Delivery } from "../broker/actor/delivery-intents.ts";
+import type { StartDelivery } from "../host/start-delivery.ts";
+export type EffectDelivery = Delivery & {
+    readonly stop: NonNullable<Delivery["stop"]>;
+};
+export interface DeliveryRoutes {
+    readonly runs: StartDelivery;
+    readonly effects: Readonly<Record<string, EffectDelivery>>;
+}
+export declare function deliveryRouter(routes: DeliveryRoutes): Delivery;