cloving 1.2.0 → 1.4.0

package/dist/src/daemon/chats-follow-up.js

@@ -1,180 +0,0 @@
-import { createHash } from "node:crypto";
-import { join } from "node:path";
-import { record } from "../protocol.js";
-import { analysisFollowUp } from "../chats/analysis-prompt.js";
-import { analysisEvidence, } from "../chats/analysis-input.js";
-import { validateAnalysis } from "../chats/analysis.js";
-import { analysisProposal } from "../chats/analysis-proposal.js";
-import { analysisBatchData } from "../chats/analysis-batches.js";
-import { finalizeAnalysis } from "./chats-checkpoints.js";
-import { operationKey } from "./operation-journal.js";
-import { analysisDirectory, boundedAnalysisFile, inspectAnalysisDraftRecord, inspectAnalysisFiles, saveAnalysisFiles, } from "./chats-files.js";
-function storedDraftIdentity(stored, call) {
-    return (stored?.["runId"] === call.intent.runId &&
-        stored["cycleId"] === call.input.cycleId &&
-        typeof stored["operationId"] === "string" &&
-        typeof stored["inputDigest"] === "string" &&
-        typeof stored["reply"] === "string" &&
-        stored["snapshotDigest"] ===
-            createHash("sha256")
-                .update(JSON.stringify(call.input.snapshot))
-                .digest("hex"));
-}
-export async function storedAnalysisDraft(directory, call) {
-    const { cycleId } = call.input;
-    const text = await boundedAnalysisFile(join(directory, `draft-${cycleId}.json`), { permissions: 0o600 }).catch((error) => {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return undefined;
-        throw error;
-    });
-    if (text === undefined)
-        return undefined;
-    const stored = record(JSON.parse(text));
-    if (!storedDraftIdentity(stored, call))
-        throw new Error("analysis-follow-up-refused");
-    const draft = {
-        runId: call.intent.runId,
-        cycleId,
-        operationId: stored["operationId"],
-        inputDigest: stored["inputDigest"],
-        snapshotDigest: stored["snapshotDigest"],
-        reply: stored["reply"],
-        ...("batch" in stored ? { batch: stored["batch"] } : {}),
-    };
-    if ((await inspectAnalysisDraftRecord(directory, draft)) === undefined)
-        throw new Error("analysis-follow-up-refused");
-    return draft;
-}
-async function boundDraft(directory, call) {
-    const followUp = analysisFollowUp(call.payload["followUp"]);
-    const draft = await storedAnalysisDraft(directory, call);
-    if (draft === undefined ||
-        JSON.stringify(draft.batch) !== JSON.stringify(call.payload["batch"]) ||
-        JSON.stringify(JSON.parse(draft.reply)) !== JSON.stringify(followUp.draft))
-        throw new Error("analysis-follow-up-refused");
-    return draft;
-}
-function refused(reason, codes = [reason]) {
-    return {
-        kind: "failed",
-        reason,
-        result: JSON.stringify({ kind: "blocked", codes }),
-    };
-}
-export async function saveFollowUp(runtime, call) {
-    const { snapshot, candidate } = call.input;
-    try {
-        if ("batch" in call.payload &&
-            Object.hasOwn(record(candidate) ?? {}, "openQuestion"))
-            return refused("analysis-question-limit");
-        if (!("batch" in call.payload))
-            return await saveSnapshotFollowUp(runtime, call);
-        const directory = await analysisDirectory(runtime, snapshot.importId);
-        const draft = await boundDraft(directory, call);
-        return await saveAcceptedAnalysis(runtime, { ...call, draft });
-    }
-    catch {
-        return refused("analysis-follow-up-refused");
-    }
-}
-async function saveSnapshotFollowUp(runtime, call) {
-    const { snapshot, cycleId, candidate } = call.input;
-    const validation = validateAnalysis(candidate, analysisEvidence(snapshot));
-    if (!validation.accepted)
-        return refused("analysis-follow-up-refused", validation.codes);
-    if (validation.result.openQuestion !== undefined)
-        return refused("analysis-question-limit");
-    const directory = await analysisDirectory(runtime, snapshot.importId);
-    const draft = await boundDraft(directory, call);
-    const output = {
-        cycleId,
-        draft,
-        analysis: JSON.stringify(validation.result) + "\n",
-        proposal: analysisProposal(validation.result),
-    };
-    if (call.mode === "reconcile" &&
-        (await inspectAnalysisFiles(directory, output)) === "absent")
-        return { kind: "absent" };
-    if (call.mode === "deliver")
-        await saveAnalysisFiles(directory, output);
-    return {
-        kind: "completed",
-        worker: "chats",
-        receipt: operationKey(call.intent.operationId),
-        result: JSON.stringify({
-            kind: "handoff_requested",
-            cycleId,
-            promotionId: `analysis:${snapshot.importId}:${cycleId}`,
-        }),
-    };
-}
-async function acceptedDraft(directory, call) {
-    const draft = await storedAnalysisDraft(directory, call);
-    if (draft === undefined)
-        return undefined;
-    const batch = record(call.payload["batch"]);
-    const prior = record(draft.batch);
-    if (prior === undefined ||
-        batch === undefined ||
-        Number(batch["batchIndex"]) === Number(prior["batchIndex"]))
-        throw new Error("analysis-follow-up-refused");
-    if (Number(batch["batchIndex"]) < Number(prior["batchIndex"]))
-        return undefined;
-    return draft;
-}
-export async function saveAcceptedAnalysis(runtime, call) {
-    const { snapshot, cycleId, candidate } = call.input;
-    const { importId } = snapshot;
-    try {
-        const directory = await analysisDirectory(runtime, importId);
-        const draft = call.draft ??
-            ("batch" in call.payload
-                ? await acceptedDraft(directory, call)
-                : undefined);
-        const saved = await finalizeAnalysis(directory, {
-            runId: call.intent.runId,
-            importId,
-            cycleId,
-            snapshot: "snapshot" in call.payload ? snapshot : undefined,
-            candidate,
-            mode: call.mode,
-            batch: call.payload["batch"],
-            ...(draft === undefined ? {} : { draft }),
-        });
-        return savedOutcome(call, saved);
-    }
-    catch {
-        throw new Error("analysis-output-failed");
-    }
-}
-function savedOutcome(call, saved) {
-    const { cycleId, snapshot } = call.input;
-    const { importId } = snapshot;
-    if (saved.kind === "absent")
-        return { kind: "absent" };
-    if (saved.kind === "refused")
-        return refused(call.draft !== undefined &&
-            !saved.codes.includes("analysis-merge-conflict")
-            ? "analysis-follow-up-refused"
-            : (saved.codes[0] ?? "analysis-input-refused"), saved.codes);
-    let result = {
-        kind: "handoff_requested",
-        cycleId,
-        promotionId: `analysis:${importId}:${cycleId}`,
-    };
-    if (saved.next?.kind === "refused")
-        result = { kind: "analysis_partial", reason: saved.next.code };
-    if (saved.next?.kind === "batch")
-        result = {
-            kind: "analysis_batch",
-            ...analysisBatchData(saved.next, {
-                digest: saved.checkpoint.capturedDigest,
-            }),
-        };
-    return {
-        kind: "completed",
-        worker: "chats",
-        receipt: operationKey(call.intent.operationId),
-        result: JSON.stringify(result),
-    };
-}

package/dist/src/daemon/chats-question.d.ts

@@ -1,15 +0,0 @@
-import type { AdapterOutcome, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
-import type { Fields } from "../protocol.ts";
-import { type analysisSaveInput } from "../chats/analysis-input.ts";
-interface QuestionSettings {
-    readonly runtimeDirectory: string;
-    readonly now?: () => string;
-}
-interface QuestionSave {
-    readonly intent: DeliveryIntent;
-    readonly mode: "deliver" | "reconcile";
-    readonly input: ReturnType<typeof analysisSaveInput>;
-    readonly payload: Fields;
-}
-export declare function saveQuestion(settings: QuestionSettings, call: QuestionSave): Promise<AdapterOutcome>;
-export {};

package/dist/src/daemon/chats-question.js

@@ -1,93 +0,0 @@
-import { createHash } from "node:crypto";
-import { validateAnalysis } from "../chats/analysis.js";
-import { analysisEvidence, } from "../chats/analysis-input.js";
-import { mergeAnalysisBatch } from "../chats/analysis-merge.js";
-import { boundAnalysisBatch } from "./chats-batch-binding.js";
-import { analysisDirectory, inspectAnalysisDraft, saveAnalysisDraft, } from "./chats-files.js";
-import { operationKey } from "./operation-journal.js";
-import { storedAnalysisDraft } from "./chats-follow-up.js";
-async function validateQuestion(directory, call) {
-    const { input, payload, intent } = call;
-    if (!("batch" in payload))
-        return validateAnalysis(input.candidate, analysisEvidence(input.snapshot));
-    const bound = await boundAnalysisBatch(directory, {
-        runId: intent.runId,
-        importId: input.snapshot.importId,
-        snapshot: "snapshot" in payload ? input.snapshot : undefined,
-        batch: payload["batch"],
-    });
-    return mergeAnalysisBatch({
-        previousResult: bound.previous.result,
-        candidate: input.candidate,
-        evidence: analysisEvidence(bound.snapshot),
-        nextRecordIndex: bound.batch.nextRecordIndex,
-    });
-}
-function questionDraft(call) {
-    const { cycleId, snapshot, reply } = call.input;
-    return {
-        runId: call.intent.runId,
-        cycleId,
-        operationId: call.intent.operationId,
-        inputDigest: call.intent.inputDigest,
-        snapshotDigest: createHash("sha256")
-            .update(JSON.stringify(snapshot))
-            .digest("hex"),
-        reply,
-        ...("batch" in call.payload ? { batch: call.payload["batch"] } : {}),
-    };
-}
-async function additionalBatchQuestion(directory, call) {
-    const earlier = await storedAnalysisDraft(directory, call);
-    return (earlier !== undefined &&
-        "batch" in call.payload &&
-        earlier.operationId !== call.intent.operationId);
-}
-export async function saveQuestion(settings, call) {
-    try {
-        const { cycleId, snapshot } = call.input;
-        const directory = await analysisDirectory(settings.runtimeDirectory, snapshot.importId);
-        if (await additionalBatchQuestion(directory, call))
-            return {
-                kind: "failed",
-                reason: "analysis-question-limit",
-                result: JSON.stringify({
-                    kind: "blocked",
-                    codes: ["analysis-question-limit"],
-                }),
-            };
-        const validation = await validateQuestion(directory, call);
-        if (!validation.accepted)
-            return {
-                kind: "failed",
-                reason: validation.codes[0] ?? "analysis-input-refused",
-                result: JSON.stringify({ kind: "blocked", codes: validation.codes }),
-            };
-        const question = validation.result.openQuestion;
-        if (question === undefined)
-            throw new Error("analysis-input-refused");
-        const draft = questionDraft(call);
-        const metadata = call.mode === "reconcile"
-            ? await inspectAnalysisDraft(directory, draft)
-            : await saveAnalysisDraft(directory, {
-                input: draft,
-                now: settings.now ?? (() => new Date().toISOString()),
-            });
-        if (metadata === undefined)
-            return { kind: "absent" };
-        return {
-            kind: "completed",
-            worker: "chats",
-            receipt: operationKey(call.intent.operationId),
-            result: JSON.stringify({
-                kind: "analysis_draft",
-                cycleId,
-                ...metadata,
-                question,
-            }),
-        };
-    }
-    catch {
-        throw new Error("analysis-output-failed");
-    }
-}

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

@@ -1,13 +0,0 @@
-import type { AdapterOutcome, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
-import type { EffectDelivery } from "./delivery-router.ts";
-export interface ChatsWorkerSettings {
-    readonly runtimeDirectory: string;
-    readonly document: (digest: string) => Promise<string | undefined>;
-    readonly workflowId: (runId: string) => Promise<string | undefined>;
-    readonly now?: () => string;
-}
-export interface ChatsWorker extends EffectDelivery {
-    readonly deliver: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
-    readonly close: () => Promise<void>;
-}
-export declare function chatsWorker(settings: ChatsWorkerSettings): ChatsWorker;

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

@@ -1,201 +0,0 @@
-import { saveQuestion } from "./chats-question.js";
-import { saveAcceptedAnalysis, saveFollowUp, } from "./chats-follow-up.js";
-import { record } from "../protocol.js";
-import { validateAnalysis } from "../chats/analysis.js";
-import { analysisDocumentBytes, analysisEvidence, analysisSaveInput, validAnalysisImportId, } from "../chats/analysis-input.js";
-import { analysisBatchData, prepareAnalysisBatch, } from "../chats/analysis-batches.js";
-import { captureAnalysisSnapshot, readCapturedAnalysisSnapshot, findAnalysisCapture, } from "./chats-capture.js";
-import { operationKey } from "./operation-journal.js";
-import { analysisDirectory } from "./chats-files.js";
-function completed(intent, result) {
-    return {
-        kind: "completed",
-        worker: "chats",
-        receipt: operationKey(intent.operationId),
-        result: JSON.stringify(result),
-    };
-}
-function refused(code, codes = [code]) {
-    return {
-        kind: "failed",
-        reason: code,
-        result: JSON.stringify({ kind: "blocked", codes }),
-    };
-}
-function bounded(text) {
-    if (Buffer.byteLength(text) > analysisDocumentBytes)
-        throw new Error("analysis-too-large");
-}
-function ownIntent(intent) {
-    return (intent.kind === "protected-effect" &&
-        intent.capability === "chats" &&
-        ["read-analysis", "save-analysis"].includes(intent.method ?? "") &&
-        intent.payload !== undefined &&
-        intent.leaseGeneration !== undefined);
-}
-async function payloadOf(settings, intent) {
-    if (!ownIntent(intent) || intent.payload === undefined)
-        throw new Error("unsupported-effect");
-    if ((await settings.workflowId(intent.runId)) !== "analyze-chats")
-        throw new Error("workflow-not-allowed");
-    const text = await settings.document(intent.payload);
-    if (text === undefined)
-        throw new Error("payload-not-available");
-    bounded(text);
-    const payload = record(JSON.parse(text));
-    if (payload === undefined)
-        throw new Error("analysis-input-refused");
-    const importId = payload["importId"];
-    if (typeof importId !== "string" || importId === "")
-        throw new Error("analysis-input-refused");
-    if (!validAnalysisImportId(importId))
-        throw new Error("invalid-import-id");
-    if (intent.target !== importId)
-        throw new Error("analysis-input-refused");
-    return payload;
-}
-async function read(settings, call) {
-    const { importId } = call;
-    let directory;
-    try {
-        directory = await analysisDirectory(settings.runtimeDirectory, importId);
-    }
-    catch (error) {
-        if (Reflect.get(Object(error), "code") === "ENOENT")
-            throw new Error("redaction-required", { cause: error });
-        throw error;
-    }
-    const capture = await captureAnalysisSnapshot(directory, {
-        importId,
-        runId: call.intent.runId,
-    });
-    const snapshot = await readCapturedAnalysisSnapshot(directory, capture);
-    const batch = prepareAnalysisBatch(snapshot, {
-        nextRecordIndex: 0,
-        completedBatchCount: 0,
-        previousResult: null,
-    });
-    if (batch.kind === "refused")
-        throw new Error(batch.code);
-    const result = analysisBatchData(batch, { digest: capture.digest, snapshot });
-    bounded(JSON.stringify(result));
-    return completed(call.intent, result);
-}
-async function saveInput(settings, call) {
-    if ("snapshot" in call.payload)
-        return analysisSaveInput(call.payload);
-    const importId = String(call.payload["importId"]);
-    const directory = await analysisDirectory(settings.runtimeDirectory, importId);
-    const capture = await findAnalysisCapture(directory, {
-        runId: call.intent.runId,
-        importId,
-    });
-    if (capture === undefined)
-        throw new Error("analysis-output-failed");
-    const snapshot = await readCapturedAnalysisSnapshot(directory, capture);
-    return analysisSaveInput({ ...call.payload, snapshot });
-}
-async function save(settings, call) {
-    const input = await saveInput(settings, call);
-    const { snapshot, candidate } = input;
-    if ("followUp" in call.payload)
-        return saveFollowUp(settings.runtimeDirectory, { ...call, input });
-    if ("batch" in call.payload &&
-        Object.hasOwn(record(candidate) ?? {}, "openQuestion"))
-        return saveQuestion(settings, { ...call, input });
-    const validation = "batch" in call.payload
-        ? undefined
-        : validateAnalysis(candidate, analysisEvidence(snapshot));
-    if (validation === undefined)
-        return saveAcceptedAnalysis(settings.runtimeDirectory, { ...call, input });
-    if (!validation.accepted)
-        return refused(validation.codes[0] ?? "analysis-input-refused", validation.codes);
-    const question = validation.result.openQuestion;
-    if (question !== undefined)
-        return saveQuestion(settings, { ...call, input });
-    return saveAcceptedAnalysis(settings.runtimeDirectory, { ...call, input });
-}
-const reasons = new Set([
-    "analysis-too-large",
-    "redaction-required",
-    "invalid-import-id",
-    "analysis-invalid-json",
-    "analysis-follow-up-refused",
-    "analysis-input-refused",
-    "analysis-output-failed",
-    "analysis-batch-limit",
-    "unsupported-effect",
-    "workflow-not-allowed",
-    "payload-not-available",
-]);
-async function delivered(settings, call) {
-    const { intent, mode } = call;
-    try {
-        if (call.signal?.aborted)
-            return { kind: "stopped" };
-        const payload = await payloadOf(settings, intent);
-        if (call.signal?.aborted)
-            return { kind: "stopped" };
-        if (intent.method === "read-analysis" && mode === "reconcile")
-            return { kind: "absent" };
-        if (intent.method === "read-analysis")
-            return await read(settings, {
-                intent,
-                importId: String(payload["importId"]),
-            });
-        return await save(settings, { intent, payload, mode });
-    }
-    catch (error) {
-        const message = String(Reflect.get(Object(error), "message"));
-        return refused(reasons.has(message) ? message : "analysis-input-refused");
-    }
-}
-export function chatsWorker(settings) {
-    if (process.platform !== "darwin") {
-        const unsupported = () => Promise.resolve(refused("platform-unsupported"));
-        return {
-            deliver: unsupported,
-            reconcile: unsupported,
-            stop: unsupported,
-            close: () => Promise.resolve(),
-        };
-    }
-    const active = new Map();
-    const lifecycle = { closed: false };
-    const deliver = (intent, signal) => {
-        if (lifecycle.closed || signal.aborted)
-            return Promise.resolve({ kind: "stopped" });
-        const key = operationKey(JSON.stringify([intent.runId, intent.operationId, intent.inputDigest]));
-        const known = active.get(key);
-        if (known !== undefined)
-            return known;
-        const pending = delivered(settings, {
-            intent,
-            mode: "deliver",
-            signal,
-        }).finally(() => active.delete(key));
-        active.set(key, pending);
-        return pending;
-    };
-    const stop = async (intent) => {
-        if (!ownIntent(intent))
-            return refused("unsupported-effect");
-        if ((await settings.workflowId(intent.runId)) !== "analyze-chats")
-            return refused("workflow-not-allowed");
-        const key = operationKey(JSON.stringify([intent.runId, intent.operationId, intent.inputDigest]));
-        const pending = active.get(key);
-        if (pending !== undefined)
-            return await pending;
-        const result = await delivered(settings, { intent, mode: "reconcile" });
-        return result.kind === "absent" ? { kind: "stopped" } : result;
-    };
-    return {
-        deliver,
-        reconcile: (intent) => delivered(settings, { intent, mode: "reconcile" }),
-        stop,
-        close: async () => {
-            lifecycle.closed = true;
-            await Promise.all(active.values());
-        },
-    };
-}

package/dist/src/steps/decision-gate.d.ts

@@ -1,2 +0,0 @@
-import { type GateRequest, type GateResult } from "../step-bridge.ts";
-export declare function decisionGate(request: GateRequest): Promise<GateResult>;

package/dist/src/steps/decision-gate.js

@@ -1,8 +0,0 @@
-import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
-export async function decisionGate(request) {
-    "use step";
-    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
-    if (!isStepBridge(bridge))
-        return { kind: "unavailable", reason: "cloving-host-unavailable" };
-    return await bridge.gate(request);
-}

package/dist/workflows/analyze-chats.d.ts

@@ -1,15 +0,0 @@
-import type { CycleOutcome } from "cloving/workflows";
-interface Decision {
-    readonly gateId: string;
-    readonly decision: string;
-    readonly answer: string | null;
-}
-interface AnalysisInput {
-    readonly cycleId: string;
-    readonly repository: string;
-    readonly input: {
-        readonly importId: string;
-    };
-}
-export declare function analyzeChats(input: AnalysisInput, decision?: Decision): Promise<CycleOutcome>;
-export {};

package/dist/workflows/analyze-chats.declaration.json

@@ -1,22 +0,0 @@
-{
-  "workflowId": "analyze-chats",
-  "effectLimit": 11,
-  "capabilities": ["chats", "claude"],
-  "stages": [
-    {
-      "name": "read-input",
-      "label": "Read input",
-      "operations": ["read-analysis"]
-    },
-    { "name": "analyze", "label": "Analyze", "operations": ["turn-analysis"] },
-    {
-      "name": "save-result",
-      "label": "Save result",
-      "operations": ["save-analysis"]
-    }
-  ],
-  "input": {
-    "maximumBytes": 4096,
-    "fields": { "importId": { "type": "string" } }
-  }
-}