cloving 1.2.0 → 1.4.0

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

@@ -1,186 +0,0 @@
-import { boundAnalysisBatch, previousCheckpoint, } from "./chats-batch-binding.js";
-import { createHash } from "node:crypto";
-import { join } from "node:path";
-import { batchAnalysisCheckpoint, } from "../chats/analysis-checkpoint.js";
-import { analysisEvidence, analysisDocumentBytes, } from "../chats/analysis-input.js";
-import { mergeAnalysisBatch } from "../chats/analysis-merge.js";
-import { prepareAnalysisBatch, } from "../chats/analysis-batches.js";
-import { analysisProposal, checkpointProposal, } from "../chats/analysis-proposal.js";
-import { readCapturedAnalysisSnapshot, } from "./chats-capture.js";
-import { boundedAnalysisFile, matchingPrivateFile, inspectAnalysisFiles, saveAnalysisFiles, } from "./chats-files.js";
-export async function finalizeAnalysis(directory, input) {
-    const { capture, batch, snapshot } = await boundAnalysisBatch(directory, input);
-    const inspected = await saveAnalysisCheckpoint(directory, {
-        ...batch,
-        capture,
-        candidate: input.candidate,
-        mode: "reconcile",
-    });
-    if (inspected.kind === "refused")
-        return inspected;
-    if (!("checkpoint" in inspected)) {
-        if (input.mode === "reconcile")
-            return { kind: "absent" };
-        return saveAnalysisCheckpoint(directory, {
-            ...batch,
-            capture,
-            candidate: input.candidate,
-            mode: "deliver",
-        });
-    }
-    return commitAnalysisBatch(directory, {
-        input,
-        batch: { ...batch, capture, candidate: input.candidate, mode: input.mode },
-        snapshot,
-        inspected,
-    });
-}
-async function commitAnalysisBatch(directory, prepared) {
-    const { input, batch, snapshot, inspected } = prepared;
-    const output = {
-        cycleId: input.cycleId,
-        analysis: JSON.stringify(inspected.checkpoint.result) + "\n",
-        proposal: analysisProposal(inspected.checkpoint.result),
-        ...(input.draft === undefined ? {} : { draft: input.draft }),
-    };
-    const complete = inspected.checkpoint.status === "complete";
-    const legacy = complete
-        ? await inspectAnalysisFiles(directory, output)
-        : "present";
-    if (input.mode === "reconcile" &&
-        (inspected.kind === "absent" || legacy === "absent"))
-        return { kind: "absent" };
-    const saved = await saveAnalysisCheckpoint(directory, {
-        ...batch,
-        mode: input.mode,
-    });
-    if (saved.kind !== "committed")
-        return saved;
-    if (complete && input.mode === "deliver")
-        await saveAnalysisFiles(directory, output);
-    const next = complete
-        ? undefined
-        : prepareAnalysisBatch(snapshot, {
-            nextRecordIndex: saved.checkpoint.nextRecordIndex,
-            completedBatchCount: saved.checkpoint.completedBatchCount,
-            previousResult: saved.checkpoint.result,
-        });
-    return { ...saved, next };
-}
-export async function saveAnalysisCheckpoint(directory, input) {
-    const { capture, candidate } = input;
-    const snapshot = await readCapturedAnalysisSnapshot(directory, capture);
-    const folder = join(directory, `capture-${capture.key}`);
-    const previous = await previousCheckpoint(folder, { ...input, snapshot });
-    if (!Number.isSafeInteger(input.nextRecordIndex) ||
-        input.nextRecordIndex <= previous.nextRecordIndex ||
-        input.nextRecordIndex > capture.totalRecords ||
-        previous.status === "complete")
-        throw new Error("analysis-input-refused");
-    const merged = mergeAnalysisBatch({
-        previousResult: previous.result,
-        candidate,
-        evidence: analysisEvidence(snapshot),
-        nextRecordIndex: input.nextRecordIndex,
-    });
-    if (!merged.accepted && !merged.codes.includes("analysis-merge-conflict"))
-        return { kind: "refused", codes: merged.codes };
-    if (!merged.accepted &&
-        (await retainConflict(folder, { ...input, previous })) === "absent")
-        return { kind: "absent" };
-    if (!merged.accepted)
-        return { kind: "refused", codes: merged.codes };
-    const checkpoint = batchAnalysisCheckpoint(capture, {
-        ...input,
-        result: merged.result,
-    });
-    return persistCheckpoint(folder, { ...input, checkpoint });
-}
-async function bindBatch(folder, input) {
-    const { capture, batchIndex, nextRecordIndex, candidate, mode } = input;
-    const text = JSON.stringify({
-        schemaVersion: 1,
-        runId: capture.runId,
-        importId: capture.importId,
-        capturedDigest: capture.digest,
-        batchIndex,
-        nextRecordIndex,
-        candidateDigest: createHash("sha256")
-            .update(JSON.stringify(candidate))
-            .digest("hex"),
-    }) + "\n";
-    const path = join(folder, `batch-claim-${String(batchIndex)}.json`);
-    if (mode === "deliver")
-        await matchingPrivateFile(path, text);
-    else
-        await inspectMatchingPrivateFile(path, text);
-}
-async function persistCheckpoint(folder, input) {
-    const { checkpoint, mode } = input;
-    const output = {
-        cycleId: `checkpoint-${String(checkpoint.completedBatchCount)}`,
-        analysis: JSON.stringify(checkpoint) + "\n",
-        proposal: checkpointProposal(checkpoint),
-    };
-    const state = await inspectAnalysisFiles(folder, output);
-    await bindBatch(folder, input);
-    if (mode === "deliver")
-        await saveAnalysisFiles(folder, output);
-    return {
-        kind: mode === "reconcile" && state === "absent"
-            ? "absent"
-            : "committed",
-        checkpoint,
-        receipt: createHash("sha256").update(output.analysis).digest("hex"),
-    };
-}
-async function retainConflict(folder, input) {
-    const { capture, candidate, mode, batchIndex, nextRecordIndex, previous } = input;
-    const incomingText = JSON.stringify(candidate) + "\n";
-    if (Buffer.byteLength(incomingText) > analysisDocumentBytes)
-        throw new Error("analysis-output-failed");
-    const incomingFile = `conflict-${String(batchIndex)}-incoming.json`;
-    const text = JSON.stringify({
-        schemaVersion: 1,
-        runId: capture.runId,
-        importId: capture.importId,
-        capturedDigest: capture.digest,
-        batchIndex,
-        nextRecordIndex,
-        accepted: {
-            file: `analysis-checkpoint-${String(previous.completedBatchCount)}.json`,
-            digest: createHash("sha256")
-                .update(JSON.stringify(previous) + "\n")
-                .digest("hex"),
-        },
-        incoming: {
-            file: incomingFile,
-            digest: createHash("sha256").update(incomingText).digest("hex"),
-        },
-    }) + "\n";
-    const path = join(folder, `conflict-${String(batchIndex)}.json`);
-    const incomingPath = join(folder, incomingFile);
-    await bindBatch(folder, input);
-    if (mode === "reconcile") {
-        const variant = await inspectMatchingPrivateFile(incomingPath, incomingText);
-        const envelope = await inspectMatchingPrivateFile(path, text);
-        return variant === "absent" || envelope === "absent"
-            ? "absent"
-            : "retained";
-    }
-    await matchingPrivateFile(incomingPath, incomingText);
-    await matchingPrivateFile(path, text);
-    return "retained";
-}
-async function inspectMatchingPrivateFile(path, expected) {
-    const text = await boundedAnalysisFile(path, { permissions: 0o600 }).catch((error) => {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return undefined;
-        throw error;
-    });
-    if (text === undefined)
-        return "absent";
-    if (text !== expected)
-        throw new Error("analysis-output-failed");
-    return "retained";
-}

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

@@ -1,42 +0,0 @@
-import { type AnalysisSnapshot } from "../chats/analysis-input.ts";
-export declare function readAnalysisCorpus(path: string, options?: {
-    readonly output?: string;
-    readonly permissions?: number;
-}): Promise<string>;
-export declare function analysisDirectory(runtime: string, importId: string): Promise<string>;
-export declare function boundedAnalysisFile(path: string, options?: {
-    readonly permissions?: number;
-}): Promise<string>;
-export declare function readAnalysisSnapshot(directory: string, input: {
-    readonly importId: string;
-    readonly permissions?: number;
-}): Promise<AnalysisSnapshot>;
-export declare function matchingPrivateFile(path: string, text: string): Promise<void>;
-export interface AnalysisOutput {
-    readonly cycleId: string;
-    readonly analysis: string;
-    readonly proposal: string;
-    readonly draft?: AnalysisDraftInput;
-}
-export declare function inspectAnalysisFiles(directory: string, output: AnalysisOutput): Promise<"complete" | "absent">;
-export declare function saveAnalysisFiles(directory: string, output: AnalysisOutput): Promise<void>;
-export interface AnalysisDraftInput {
-    readonly runId: string;
-    readonly cycleId: string;
-    readonly operationId: string;
-    readonly inputDigest: string;
-    readonly snapshotDigest: string;
-    readonly reply: string;
-    readonly batch?: unknown;
-}
-interface AnalysisDraftMetadata {
-    readonly candidateDigest: string;
-    readonly expiresAt: string;
-}
-export declare function inspectAnalysisDraft(directory: string, input: AnalysisDraftInput): Promise<AnalysisDraftMetadata | undefined>;
-export declare function inspectAnalysisDraftRecord(directory: string, input: AnalysisDraftInput): Promise<AnalysisDraftMetadata | undefined>;
-export declare function saveAnalysisDraft(directory: string, saving: {
-    readonly input: AnalysisDraftInput;
-    readonly now: () => string;
-}): Promise<AnalysisDraftMetadata>;
-export {};

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

@@ -1,252 +0,0 @@
-import { lstat } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { dirname, join, resolve } from "node:path";
-import { record } from "../protocol.js";
-import { openInput } from "../chats/input-file.js";
-import { createPrivateFile, validateDestination, } from "../chats/destination.js";
-import { analysisDocumentBytes, } from "../chats/analysis-input.js";
-import { analysisCaptureBytes } from "../chats/analysis-batches.js";
-export async function readAnalysisCorpus(path, options = {}) {
-    const handle = await openInput(path);
-    let output;
-    try {
-        if (options.permissions !== undefined &&
-            ((await handle.stat()).mode & 0o777) !== options.permissions)
-            throw new Error("analysis-output-failed");
-        if (options.output !== undefined)
-            output = await createPrivateFile(options.output);
-        const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-        const buffer = Buffer.alloc(65_536);
-        const chunks = [];
-        let size = 0;
-        for (;;) {
-            const { bytesRead } = await handle.read({
-                buffer,
-                length: Math.min(buffer.length, analysisCaptureBytes + 1 - size),
-            });
-            if (bytesRead === 0)
-                break;
-            size += bytesRead;
-            if (size > analysisCaptureBytes)
-                throw new Error("analysis-too-large");
-            if (output !== undefined)
-                await output.writeFile(buffer.subarray(0, bytesRead));
-            chunks.push(decoder.decode(buffer.subarray(0, bytesRead), { stream: true }));
-        }
-        chunks.push(decoder.decode());
-        return chunks.join("");
-    }
-    finally {
-        try {
-            await handle.close();
-        }
-        finally {
-            await output?.close();
-        }
-    }
-}
-export async function analysisDirectory(runtime, importId) {
-    if (process.platform !== "darwin")
-        throw new Error("platform-unsupported");
-    const directory = resolve(runtime, "chats", importId);
-    await checkedDirectory(directory);
-    return directory;
-}
-async function checkedDirectory(directory) {
-    try {
-        if (!(await lstat(directory)).isDirectory())
-            throw new Error("analysis-input-refused");
-    }
-    catch (error) {
-        if (Reflect.get(Object(error), "code") !== "ENOENT")
-            throw error;
-        const parent = dirname(directory);
-        if (parent === directory)
-            throw error;
-        await checkedDirectory(parent);
-        throw error;
-    }
-    await validateDestination(directory);
-}
-export async function boundedAnalysisFile(path, options = {}) {
-    const handle = await openInput(path);
-    try {
-        if (options.permissions !== undefined &&
-            ((await handle.stat()).mode & 0o777) !== options.permissions)
-            throw new Error("analysis-output-failed");
-        const buffer = Buffer.alloc(analysisDocumentBytes + 1);
-        let size = 0;
-        while (size < buffer.length) {
-            const { bytesRead } = await handle.read(buffer, size, buffer.length - size, null);
-            if (bytesRead === 0)
-                break;
-            size += bytesRead;
-        }
-        if (size > analysisDocumentBytes)
-            throw new Error("analysis-too-large");
-        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(buffer.subarray(0, size));
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function readAnalysisSnapshot(directory, input) {
-    const { importId, ...options } = input;
-    const required = async (name) => {
-        try {
-            return name === "redacted.jsonl"
-                ? await readAnalysisCorpus(join(directory, name), options)
-                : await boundedAnalysisFile(join(directory, name), options);
-        }
-        catch (error) {
-            if (Reflect.get(Object(error), "code") === "ENOENT")
-                throw new Error("redaction-required", { cause: error });
-            throw error;
-        }
-    };
-    return {
-        importId,
-        redaction: await required("redaction.json"),
-        corpus: await required("redacted.jsonl"),
-        structure: await boundedAnalysisFile(join(directory, "structure.json"), options),
-    };
-}
-export async function matchingPrivateFile(path, text) {
-    try {
-        const existing = await boundedAnalysisFile(path, { permissions: 0o600 });
-        if (existing !== text)
-            throw new Error("analysis-output-failed");
-        return;
-    }
-    catch (error) {
-        if (Reflect.get(Object(error), "code") !== "ENOENT")
-            throw error;
-    }
-    const handle = await createPrivateFile(path);
-    try {
-        await handle.writeFile(text);
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function requireAbsent(directory, names) {
-    for (const name of names) {
-        const exists = await lstat(join(directory, name)).catch((error) => {
-            if (error instanceof Error &&
-                "code" in error &&
-                error.code === "ENOENT")
-                return undefined;
-            throw error;
-        });
-        if (exists !== undefined)
-            throw new Error("analysis-output-failed");
-    }
-}
-function outputClaim(directory, output) {
-    return {
-        path: join(directory, `${"draft" in output ? "final-claim" : "claim"}-${output.cycleId}.json`),
-        text: JSON.stringify({
-            schemaVersion: 1,
-            kind: "reply" in output ? "draft" : "final",
-            digest: createHash("sha256")
-                .update(JSON.stringify(output))
-                .digest("hex"),
-        }) + "\n",
-    };
-}
-async function inspectOutputClaim(claim) {
-    const text = await boundedAnalysisFile(claim.path, {
-        permissions: 0o600,
-    }).catch((error) => {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return undefined;
-        throw error;
-    });
-    if (text !== undefined && text !== claim.text)
-        throw new Error("analysis-output-failed");
-}
-export async function inspectAnalysisFiles(directory, output) {
-    if (Buffer.byteLength(JSON.stringify(output)) > analysisDocumentBytes)
-        throw new Error("analysis-too-large");
-    await inspectOutputClaim(outputClaim(directory, output));
-    if (output.draft === undefined)
-        await requireAbsent(directory, [`draft-${output.cycleId}.json`]);
-    else if ((await inspectAnalysisDraftRecord(directory, output.draft)) === undefined)
-        throw new Error("analysis-output-failed");
-    const proposal = join(directory, `proposal-${output.cycleId}.txt`);
-    const analysis = join(directory, `analysis-${output.cycleId}.json`);
-    const marker = await boundedAnalysisFile(analysis, {
-        permissions: 0o600,
-    }).catch((error) => {
-        if (Reflect.get(Object(error), "code") === "ENOENT")
-            return undefined;
-        throw error;
-    });
-    if (marker === undefined)
-        return "absent";
-    if (marker !== output.analysis ||
-        (await boundedAnalysisFile(proposal, { permissions: 0o600 })) !==
-            output.proposal)
-        throw new Error("analysis-output-failed");
-    return "complete";
-}
-export async function saveAnalysisFiles(directory, output) {
-    if ((await inspectAnalysisFiles(directory, output)) === "complete")
-        return;
-    const claim = outputClaim(directory, output);
-    await matchingPrivateFile(claim.path, claim.text);
-    const proposal = join(directory, `proposal-${output.cycleId}.txt`);
-    const analysis = join(directory, `analysis-${output.cycleId}.json`);
-    await matchingPrivateFile(proposal, output.proposal);
-    await matchingPrivateFile(analysis, output.analysis);
-}
-function draftRecord(input, expiresAt) {
-    return {
-        schemaVersion: 1,
-        ...input,
-        candidateDigest: createHash("sha256").update(input.reply).digest("hex"),
-        expiresAt,
-    };
-}
-export async function inspectAnalysisDraft(directory, input) {
-    await requireAbsent(directory, [
-        `analysis-${input.cycleId}.json`,
-        `proposal-${input.cycleId}.txt`,
-    ]);
-    return inspectAnalysisDraftRecord(directory, input);
-}
-export async function inspectAnalysisDraftRecord(directory, input) {
-    await inspectOutputClaim(outputClaim(directory, input));
-    const text = await boundedAnalysisFile(join(directory, `draft-${input.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 expiresAt = record(JSON.parse(text))?.["expiresAt"];
-    if (typeof expiresAt !== "string" ||
-        !Number.isFinite(Date.parse(expiresAt)) ||
-        new Date(expiresAt).toISOString() !== expiresAt)
-        throw new Error("analysis-output-failed");
-    const expected = draftRecord(input, expiresAt);
-    if (text !== JSON.stringify(expected) + "\n")
-        throw new Error("analysis-output-failed");
-    return { candidateDigest: expected.candidateDigest, expiresAt };
-}
-export async function saveAnalysisDraft(directory, saving) {
-    const { input, now } = saving;
-    const existing = await inspectAnalysisDraft(directory, input);
-    if (existing !== undefined)
-        return existing;
-    const claim = outputClaim(directory, input);
-    await matchingPrivateFile(claim.path, claim.text);
-    const expiresAt = new Date(Date.parse(now()) + 86_400_000).toISOString();
-    const draft = draftRecord(input, expiresAt);
-    const text = JSON.stringify(draft) + "\n";
-    if (Buffer.byteLength(text) > analysisDocumentBytes)
-        throw new Error("analysis-output-failed");
-    await matchingPrivateFile(join(directory, `draft-${input.cycleId}.json`), text);
-    return { candidateDigest: draft.candidateDigest, expiresAt };
-}

package/dist/src/daemon/chats-follow-up.d.ts

@@ -1,38 +0,0 @@
-import type { AdapterOutcome, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
-import { type Fields } from "../protocol.ts";
-import { type AnalysisSnapshot } from "../chats/analysis-input.ts";
-import type { AnalysisQuestion } from "../chats/analysis-contract.ts";
-import { analysisBatchData } from "../chats/analysis-batches.ts";
-import { type AnalysisDraftInput } from "./chats-files.ts";
-export type ChatsResult = ReturnType<typeof analysisBatchData> | ({
-    readonly kind: "analysis_batch";
-} & ReturnType<typeof analysisBatchData>) | {
-    readonly kind: "analysis_partial";
-    readonly reason: string;
-} | {
-    readonly kind: "analysis_draft";
-    readonly cycleId: string;
-    readonly candidateDigest: string;
-    readonly expiresAt: string;
-    readonly question: AnalysisQuestion;
-} | {
-    readonly kind: "handoff_requested";
-    readonly cycleId: string;
-    readonly promotionId: string;
-};
-interface FollowUpSave {
-    readonly intent: DeliveryIntent;
-    readonly payload: Fields;
-    readonly mode: "deliver" | "reconcile";
-    readonly input: {
-        readonly cycleId: string;
-        readonly snapshot: AnalysisSnapshot;
-        readonly candidate: unknown;
-    };
-}
-export declare function storedAnalysisDraft(directory: string, call: FollowUpSave): Promise<AnalysisDraftInput | undefined>;
-export declare function saveFollowUp(runtime: string, call: FollowUpSave): Promise<AdapterOutcome>;
-export declare function saveAcceptedAnalysis(runtime: string, call: FollowUpSave & {
-    readonly draft?: AnalysisDraftInput;
-}): Promise<AdapterOutcome>;
-export {};