cloving 1.2.0 → 1.4.0

package/dist/src/chats/analysis-provenance.js

@@ -1,99 +0,0 @@
-function identityMatches(record, occurrence) {
-    if (record.sourceId !== occurrence.sourceId ||
-        record.sessionId !== occurrence.sessionId)
-        return false;
-    if (record.schemaVersion === 1)
-        return (occurrence.uuid === null &&
-            occurrence.isSidechain === null &&
-            !Object.hasOwn(occurrence, "parentUuid"));
-    return (record.uuid === occurrence.uuid &&
-        record.isSidechain === occurrence.isSidechain &&
-        Object.hasOwn(record, "parentUuid") ===
-            Object.hasOwn(occurrence, "parentUuid") &&
-        record.parentUuid === occurrence.parentUuid);
-}
-function validCopy(occurrence, occurrences) {
-    const reference = occurrence.copyOf;
-    if (reference === undefined)
-        return true;
-    if (!Number.isSafeInteger(reference.recordIndex) ||
-        reference.recordIndex < 0 ||
-        reference.recordIndex >= occurrence.recordIndex)
-        return false;
-    const original = occurrences[reference.recordIndex];
-    return (original !== undefined &&
-        original.sourceId === reference.sourceId &&
-        original.copyOf === undefined &&
-        typeof occurrence.uuid === "string" &&
-        occurrence.uuid !== "" &&
-        original.uuid === occurrence.uuid);
-}
-export function matchingAnalysisEvidence(evidence) {
-    const { records, structure } = evidence;
-    const historyCompleteness = structure.historyCompleteness;
-    if (historyCompleteness !== "unknown" ||
-        structure.occurrences.length !== records.length ||
-        structure.counts.records !== records.length)
-        return false;
-    return records.every((record, index) => {
-        const occurrence = structure.occurrences[index];
-        return (occurrence !== undefined &&
-            occurrence.recordIndex === index &&
-            identityMatches(record, occurrence) &&
-            validCopy(occurrence, structure.occurrences));
-    });
-}
-function knownReference(reference, evidence) {
-    return (evidence.records[reference.recordIndex]?.sourceId === reference.sourceId &&
-        evidence.structure.occurrences[reference.recordIndex]?.sourceId ===
-            reference.sourceId);
-}
-function inspectSupport(claim, evidence) {
-    const codes = [];
-    const sources = claim.sourceRefs;
-    if (claim.counterevidenceRefs.some((reference) => !knownReference(reference, evidence)))
-        codes.push("unknown-source");
-    if (!Array.isArray(claim.sourceRefs) || sources.length === 0)
-        return codes;
-    if (sources.some((reference) => !knownReference(reference, evidence)))
-        return [...codes, "unknown-source"];
-    const originals = new Set(sources
-        .filter((reference) => evidence.structure.occurrences[reference.recordIndex]?.copyOf ===
-        undefined)
-        .map((reference) => reference.sourceId));
-    if (originals.size === 0)
-        return [...codes, "copy-only"];
-    if (claim.kind === "observed-repetition" && originals.size < 2)
-        codes.push("insufficient-repetition");
-    return codes;
-}
-export function inspectAnalysisSupport(process, evidence) {
-    return [...process.stages, ...process.gates, ...process.loops].flatMap((claim) => inspectSupport(claim, evidence));
-}
-function referenceKey(reference) {
-    return JSON.stringify([reference.recordIndex, reference.sourceId]);
-}
-export function inspectAnalysisQuestion(candidate, evidence) {
-    const question = candidate.openQuestion;
-    if (question === undefined)
-        return [];
-    const references = question.sourceRefs.map(referenceKey);
-    if (new Set(references).size !== references.length)
-        return ["invalid-question"];
-    if (question.sourceRefs.some((reference) => !knownReference(reference, evidence)))
-        return ["unknown-source"];
-    const process = candidate.process;
-    const claim = [...process.stages, ...process.gates, ...process.loops].find((claim) => claim.id === question.claimId);
-    if (claim === undefined)
-        return ["question-without-conflict"];
-    if (!Array.isArray(claim.sourceRefs))
-        return ["question-without-conflict"];
-    const support = new Set(claim.sourceRefs.map(referenceKey));
-    const counterevidence = new Set(claim.counterevidenceRefs.map(referenceKey));
-    const supports = references.filter((reference) => support.has(reference));
-    const counters = references.filter((reference) => counterevidence.has(reference));
-    if (references.some((reference) => !support.has(reference) && !counterevidence.has(reference)) ||
-        !supports.some((support) => counters.some((counter) => counter !== support)))
-        return ["question-without-conflict"];
-    return [];
-}

package/dist/src/chats/analysis-shape.d.ts

@@ -1,4 +0,0 @@
-import type { AnalysisCandidate, AnalysisCode } from "./analysis-contract.ts";
-export declare function analysisObject(value: unknown): value is Record<string, unknown>;
-export declare function inspectAnalysisBatchShape(value: unknown, codes: Set<AnalysisCode>): value is AnalysisCandidate;
-export declare function inspectAnalysisShape(value: unknown, codes: Set<AnalysisCode>): value is AnalysisCandidate;

package/dist/src/chats/analysis-shape.js

@@ -1,235 +0,0 @@
-import { forbiddenAnalysisField } from "./analysis-data.js";
-export function analysisObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function text(value) {
-    return typeof value === "string" && value.trim() !== "";
-}
-function label(value, values) {
-    return typeof value === "string" && values.includes(value);
-}
-function fields(value, expected) {
-    return Object.keys(value).every((key) => expected.includes(key) || forbiddenAnalysisField(key));
-}
-const itemFields = ["id", "description"];
-const claimFields = [
-    ...itemFields,
-    "kind",
-    "sourceRefs",
-    "counterevidenceRefs",
-];
-const kinds = [
-    "explicit-human-instruction",
-    "observed-repetition",
-    "assistant-claim",
-    "exception",
-    "rejected-approach",
-    "uncertain-inference",
-];
-const activities = [
-    "work",
-    "routine-repair",
-    "accidental-interruption",
-    "tool-imposed-confirmation",
-];
-const decisions = [
-    "design-decision",
-    "configured-action-approval",
-    "factual-input",
-];
-const collections = [
-    "inputs",
-    "stages",
-    "branches",
-    "loops",
-    "artifacts",
-    "stoppingConditions",
-    "gates",
-    "nonGates",
-];
-function references(value) {
-    if (!Array.isArray(value))
-        return false;
-    return value.every((ref) => analysisObject(ref) &&
-        fields(ref, ["recordIndex", "sourceId"]) &&
-        Number.isSafeInteger(ref["recordIndex"]) &&
-        Number(ref["recordIndex"]) >= 0 &&
-        text(ref["sourceId"]));
-}
-function missingSources(value) {
-    return value === undefined || (Array.isArray(value) && value.length === 0);
-}
-function questionChoices(value) {
-    if (!Array.isArray(value) || value.length < 2 || value.length > 4)
-        return false;
-    const ids = new Set();
-    return value.every((choice) => {
-        if (!analysisObject(choice) ||
-            !fields(choice, itemFields) ||
-            !text(choice["id"]) ||
-            !text(choice["description"]) ||
-            ids.has(choice["id"]))
-            return false;
-        ids.add(choice["id"]);
-        return true;
-    });
-}
-function inspectQuestionShape(candidate, codes) {
-    if (!Object.hasOwn(candidate, "openQuestion"))
-        return true;
-    const question = candidate["openQuestion"];
-    if (!analysisObject(question)) {
-        codes.add("invalid-question");
-        return false;
-    }
-    if (!fields(question, ["claimId", "description", "sourceRefs", "choices"]) ||
-        !text(question["claimId"]) ||
-        !text(question["description"]) ||
-        !questionChoices(question["choices"]))
-        codes.add("invalid-question");
-    const sources = question["sourceRefs"];
-    if (missingSources(sources)) {
-        codes.add("missing-source");
-        return false;
-    }
-    if (!references(sources))
-        codes.add("invalid-question");
-    return !codes.has("invalid-question");
-}
-function inspectClaim(value, codes) {
-    if (!label(value["kind"], kinds))
-        codes.add("unknown-kind");
-    const source = value["sourceRefs"];
-    if (missingSources(source))
-        codes.add("missing-source");
-    else if (!references(source))
-        codes.add("invalid-shape");
-    if (!references(value["counterevidenceRefs"]))
-        codes.add("invalid-shape");
-}
-function inspectLoop(value, codes) {
-    const limit = value["maxIterations"];
-    if (typeof limit !== "number" || !Number.isSafeInteger(limit) || limit <= 0)
-        codes.add("invalid-loop-limit");
-    const stageIds = value["stageIds"];
-    return (fields(value, [
-        ...claimFields,
-        "stageIds",
-        "maxIterations",
-        "exitCondition",
-        "exhaustedStoppingConditionId",
-    ]) &&
-        Array.isArray(stageIds) &&
-        stageIds.length > 0 &&
-        stageIds.every(text) &&
-        new Set(stageIds).size === stageIds.length &&
-        text(value["exitCondition"]) &&
-        text(value["exhaustedStoppingConditionId"]));
-}
-function claimShape(value, context) {
-    const { collection, codes } = context;
-    inspectClaim(value, codes);
-    switch (collection) {
-        case "stages":
-            return (fields(value, [...claimFields, "activity"]) &&
-                label(value["activity"], activities));
-        case "gates":
-            if (!label(value["type"], decisions))
-                codes.add("unknown-decision-type");
-            return (fields(value, [...claimFields, "stageId", "type"]) &&
-                text(value["stageId"]));
-        case "loops":
-            return inspectLoop(value, codes);
-        default:
-            return false;
-    }
-}
-function itemShape(value, context) {
-    const { collection } = context;
-    if (["stages", "gates", "loops"].includes(collection))
-        return claimShape(value, context);
-    switch (collection) {
-        case "branches":
-            return (fields(value, [
-                ...itemFields,
-                "sourceStageId",
-                "condition",
-                "targetStageId",
-            ]) &&
-                ["sourceStageId", "condition", "targetStageId"].every((key) => text(value[key])));
-        case "nonGates":
-            return (fields(value, [...itemFields, "stageId", "reason"]) &&
-                text(value["stageId"]) &&
-                label(value["reason"], activities.slice(1)));
-        default:
-            return fields(value, itemFields);
-    }
-}
-function inspectItem(value, context) {
-    const { ids, collection, codes } = context;
-    if (!analysisObject(value)) {
-        codes.add("invalid-shape");
-        return;
-    }
-    const id = value["id"];
-    if (!text(id)) {
-        codes.add("invalid-shape");
-        return;
-    }
-    if (!text(value["description"]) || ids.has(id))
-        codes.add("invalid-shape");
-    ids.add(id);
-    if (!itemShape(value, { collection, codes }))
-        codes.add("invalid-shape");
-}
-function inspectItems(process, codes) {
-    const id = process["id"];
-    if (!text(id)) {
-        codes.add("invalid-shape");
-        return;
-    }
-    const ids = new Set([id]);
-    for (const collection of collections) {
-        const items = process[collection];
-        if (!Array.isArray(items)) {
-            codes.add("invalid-shape");
-            continue;
-        }
-        for (const item of items) {
-            inspectItem(item, { ids, collection, codes });
-        }
-    }
-}
-export function inspectAnalysisBatchShape(value, codes) {
-    if (!analysisObject(value)) {
-        codes.add("invalid-shape");
-        return false;
-    }
-    if (value["schemaVersion"] !== 1)
-        codes.add("unknown-version");
-    if (!fields(value, ["schemaVersion", "process", "openQuestion"]))
-        codes.add("invalid-shape");
-    const validQuestion = inspectQuestionShape(value, codes);
-    const process = value["process"];
-    if (!analysisObject(process)) {
-        codes.add("invalid-shape");
-        return false;
-    }
-    if (!fields(process, ["id", "name", "scope", ...collections]) ||
-        !["id", "name", "scope"].every((key) => text(process[key])))
-        codes.add("invalid-shape");
-    inspectItems(process, codes);
-    return (validQuestion &&
-        !codes.has("invalid-shape") &&
-        !codes.has("unknown-version"));
-}
-export function inspectAnalysisShape(value, codes) {
-    if (!inspectAnalysisBatchShape(value, codes))
-        return false;
-    if (value.process.stages.length === 0 ||
-        value.process.stoppingConditions.length === 0) {
-        codes.add("invalid-shape");
-        return false;
-    }
-    return true;
-}

package/dist/src/chats/analysis.d.ts

@@ -1,3 +0,0 @@
-export * from "./analysis-contract.ts";
-import { type AnalysisEvidence, type AnalysisValidation } from "./analysis-contract.ts";
-export declare function validateAnalysis(candidate: unknown, evidence: AnalysisEvidence): AnalysisValidation;

package/dist/src/chats/analysis.js

@@ -1,42 +0,0 @@
-export * from "./analysis-contract.js";
-import { analysisCodes, } from "./analysis-contract.js";
-import { inspectAnalysisShape } from "./analysis-shape.js";
-import { inspectAnalysisLinks } from "./analysis-links.js";
-import { inspectAnalysisData } from "./analysis-data.js";
-import { matchingAnalysisEvidence, inspectAnalysisSupport, inspectAnalysisQuestion, } from "./analysis-provenance.js";
-export function validateAnalysis(candidate, evidence) {
-    const codes = new Set(inspectAnalysisData(candidate));
-    if (codes.has("not-plain-data"))
-        return { accepted: false, codes: ["not-plain-data"] };
-    if (!inspectAnalysisShape(candidate, codes))
-        return {
-            accepted: false,
-            codes: analysisCodes.filter((code) => codes.has(code)),
-        };
-    for (const code of inspectAnalysisLinks(candidate.process))
-        codes.add(code);
-    if (matchingAnalysisEvidence(evidence)) {
-        for (const code of inspectAnalysisSupport(candidate.process, evidence))
-            codes.add(code);
-        for (const code of inspectAnalysisQuestion(candidate, evidence))
-            codes.add(code);
-    }
-    else
-        codes.add("invalid-shape");
-    if (codes.size > 0)
-        return {
-            accepted: false,
-            codes: analysisCodes.filter((code) => codes.has(code)),
-        };
-    return {
-        accepted: true,
-        result: {
-            ...candidate,
-            limitations: {
-                historyCompleteness: "unknown",
-                independentObservations: "not-established",
-                conflictGroups: evidence.structure.conflictGroups,
-            },
-        },
-    };
-}

package/dist/src/chats/corpus-input.d.ts

@@ -1,5 +0,0 @@
-import { type MessageRecord } from "./normalize.ts";
-export declare function parseCorpusRecord(line: string): MessageRecord;
-export declare function parseCorpus(text: string): readonly MessageRecord[];
-export declare function validateCoverage(text: string, importId: string): void;
-export declare function withinRoot(root: string | undefined, path: unknown): boolean;

package/dist/src/chats/corpus-input.js

@@ -1,288 +0,0 @@
-import { parsePreservedJson } from "./normalize.js";
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function keys(value, fields) {
-    const { required, optional = [] } = fields;
-    return (required.every((key) => Object.hasOwn(value, key)) &&
-        Object.keys(value).every((key) => required.includes(key) || optional.includes(key)));
-}
-function natural(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function optionalText(value) {
-    return value === null || typeof value === "string";
-}
-function block(value) {
-    if (!object(value) || !natural(value["position"]))
-        return false;
-    if (value["type"] === "text")
-        return (keys(value, { required: ["type", "position", "text"] }) &&
-            typeof value["text"] === "string");
-    if (value["type"] === "tool_use")
-        return (keys(value, { required: ["type", "position", "id", "name", "input"] }) &&
-            typeof value["id"] === "string" &&
-            typeof value["name"] === "string");
-    if (value["type"] !== "tool_result")
-        return false;
-    return toolResult(value);
-}
-function toolResult(value) {
-    return (keys(value, {
-        required: ["type", "position", "tool_use_id", "content"],
-        optional: ["is_error"],
-    }) &&
-        typeof value["tool_use_id"] === "string" &&
-        (!Object.hasOwn(value, "is_error") ||
-            typeof value["is_error"] === "boolean"));
-}
-function identityFields(value) {
-    return ((value["uuid"] === null ||
-        (typeof value["uuid"] === "string" && value["uuid"] !== "")) &&
-        (value["isSidechain"] === null ||
-            typeof value["isSidechain"] === "boolean") &&
-        (!Object.hasOwn(value, "parentUuid") ||
-            value["parentUuid"] === null ||
-            (typeof value["parentUuid"] === "string" && value["parentUuid"] !== "")));
-}
-function versionFields(value) {
-    const required = [
-        "schemaVersion",
-        "sourceId",
-        "role",
-        "timestamp",
-        "sessionId",
-        "text",
-        "blocks",
-    ];
-    const version = value["schemaVersion"];
-    if (version !== 1 && version !== 2)
-        return false;
-    const fields = version === 1
-        ? { required }
-        : {
-            required: [...required, "uuid", "isSidechain"],
-            optional: ["parentUuid"],
-        };
-    return keys(value, fields) && (version === 1 || identityFields(value));
-}
-function messageFields(value) {
-    return (versionFields(value) &&
-        typeof value["sourceId"] === "string" &&
-        value["sourceId"] !== "" &&
-        ["user", "assistant"].includes(String(value["role"])) &&
-        optionalText(value["timestamp"]) &&
-        optionalText(value["sessionId"]) &&
-        typeof value["text"] === "string");
-}
-function message(value) {
-    if (!object(value) || !messageFields(value))
-        return false;
-    if (!Array.isArray(value["blocks"]) || !value["blocks"].every(block))
-        return false;
-    let position = -1;
-    for (const item of value["blocks"]) {
-        const next = item["position"];
-        if (!natural(next) || next <= position)
-            return false;
-        position = next;
-    }
-    return true;
-}
-export function parseCorpusRecord(line) {
-    const value = parsePreservedJson(line);
-    if (!message(value))
-        throw new Error("invalid-import");
-    return value;
-}
-export function parseCorpus(text) {
-    const lines = text.split("\n");
-    if (lines.at(-1) === "")
-        lines.pop();
-    return lines.map(parseCorpusRecord);
-}
-function coverageFile(value) {
-    if (!object(value) ||
-        typeof value["path"] !== "string" ||
-        typeof value["reason"] !== "string")
-        return false;
-    if (!["included", "unreadable", "unsupported", "too-large"].includes(String(value["status"])))
-        return false;
-    if (!optionalText(value["digest"]) || !natural(value["recordCount"]))
-        return false;
-    if (!coverageSize(value))
-        return false;
-    const omissions = value["omissions"];
-    return (object(omissions) &&
-        natural(omissions["metadataRecords"]) &&
-        natural(omissions["thinkingBlocks"]));
-}
-export function validateCoverage(text, importId) {
-    const value = JSON.parse(text);
-    if (!object(value) || value["importId"] !== importId)
-        throw new Error("invalid-import");
-    if (value["schemaVersion"] === 2 && scanCoverage(value))
-        return;
-    if (value["schemaVersion"] === 1 &&
-        Array.isArray(value["files"]) &&
-        value["files"].every(coverageFile))
-        return;
-    throw new Error("invalid-import");
-}
-function scanCoverage(value) {
-    const roots = value["roots"];
-    const exclusions = value["exclusions"];
-    const limits = value["limits"];
-    const entries = value["entries"];
-    return (keys(value, {
-        required: [
-            "schemaVersion",
-            "importId",
-            "roots",
-            "exclusions",
-            "limits",
-            "entries",
-        ],
-    }) &&
-        Array.isArray(roots) &&
-        roots.length > 0 &&
-        roots.every(absolutePath) &&
-        Array.isArray(exclusions) &&
-        exclusions.every((name) => typeof name === "string" &&
-            name !== "" &&
-            name !== "." &&
-            name !== ".." &&
-            !["/", "\\", "\0", "*", "?", "[", "]"].some((character) => name.includes(character))) &&
-        coverageLimits(limits) &&
-        Array.isArray(entries) &&
-        entries.every((entry) => scanCoverageEntry(entry, roots)));
-}
-function coverageLimits(value) {
-    return (object(value) &&
-        keys(value, {
-            required: ["depth", "files", "sourceBytes", "corpusBytes"],
-        }) &&
-        value["depth"] === 4 &&
-        value["files"] === 100 &&
-        value["sourceBytes"] === 10_485_760 &&
-        value["corpusBytes"] === 52_428_800);
-}
-function scanCoverageEntry(value, roots) {
-    if (!object(value) || !coverageFile({ ...value, status: "included" }))
-        return false;
-    if (!keys(value, {
-        required: [
-            "kind",
-            "path",
-            "selection",
-            "status",
-            "reason",
-            "digest",
-            "recordCount",
-            "omissions",
-        ],
-        optional: ["byteSize"],
-    }))
-        return false;
-    const selection = value["selection"];
-    if (!coverageSelection(selection, roots.length))
-        return false;
-    if (!["file", "subtree"].includes(String(value["kind"])))
-        return false;
-    if (selection["kind"] === "file" && value["kind"] !== "file")
-        return false;
-    if (selection.kind === "root" &&
-        !withinRoot(roots[selection.index], value["path"]))
-        return false;
-    return scanStatus(value, selection["kind"]);
-}
-function coverageSelection(value, rootCount) {
-    if (!object(value) ||
-        !keys(value, { required: ["kind", "index"] }) ||
-        !natural(value["index"]))
-        return false;
-    return (value["kind"] === "file" ||
-        (value["kind"] === "root" && value["index"] < rootCount));
-}
-function scanStatus(value, selection) {
-    const status = value["status"];
-    const reason = value["reason"];
-    if (status === "included")
-        return (value["kind"] === "file" &&
-            reason === "supported" &&
-            typeof value["digest"] === "string");
-    if (status === "unreadable")
-        return reason === "source-unreadable" && emptyCoverageEntry(value);
-    if (["too-large", "excluded", "pending"].includes(String(status)))
-        return scanOmission(value, selection);
-    return scanRefusal(value);
-}
-function scanRefusal(value) {
-    if (value["status"] !== "unsupported" || value["recordCount"] !== 0)
-        return false;
-    const contentReasons = [
-        "invalid-utf8",
-        "empty-file",
-        "invalid-json",
-        "unsupported-record",
-        "unsupported-message",
-        "unsupported-block",
-    ];
-    if (contentReasons.includes(String(value["reason"])))
-        return value["kind"] === "file" && typeof value["digest"] === "string";
-    const reasons = value["kind"] === "subtree"
-        ? [
-            "symbolic-link",
-            "nonregular-file",
-            "outside-root",
-            "repository-root",
-            "source-changed",
-            "non-directory-root",
-        ]
-        : [
-            "symbolic-link",
-            "nonregular-file",
-            "outside-root",
-            "source-changed",
-            "unsupported-extension",
-            "file-too-large",
-        ];
-    return reasons.includes(String(value["reason"])) && emptyCoverageEntry(value);
-}
-function absolutePath(value) {
-    return (typeof value === "string" &&
-        value.startsWith("/") &&
-        !value.includes("\0") &&
-        value.split("/").every((part) => part !== "." && part !== ".."));
-}
-export function withinRoot(root, path) {
-    if (root === undefined || !absolutePath(path))
-        return false;
-    const parent = root.split("/").filter(Boolean);
-    const child = path.split("/").filter(Boolean);
-    return parent.every((part, index) => part === child[index]);
-}
-function scanOmission(value, selection) {
-    if (!emptyCoverageEntry(value))
-        return false;
-    if (value["status"] === "too-large")
-        return selection === "file" && value["reason"] === "file-too-large";
-    if (selection !== "root")
-        return false;
-    if (value["status"] === "excluded")
-        return (value["kind"] === "subtree" && value["reason"] === "project-excluded");
-    return (value["reason"] ===
-        (value["kind"] === "subtree" ? "depth-limit" : "file-limit"));
-}
-function emptyCoverageEntry(value) {
-    const omissions = value["omissions"];
-    return (value["digest"] === null &&
-        value["recordCount"] === 0 &&
-        object(omissions) &&
-        omissions["metadataRecords"] === 0 &&
-        omissions["thinkingBlocks"] === 0);
-}
-function coverageSize(value) {
-    return (!Object.hasOwn(value, "byteSize") ||
-        (natural(value["byteSize"]) && value["byteSize"] <= 10_485_760));
-}

package/dist/src/chats/destination.d.ts

@@ -1,4 +0,0 @@
-import { type FileHandle } from "node:fs/promises";
-export declare function importDirectory(runtime: string, importId: string): Promise<string>;
-export declare function validateDestination(directory: string): Promise<void>;
-export declare function createPrivateFile(path: string): Promise<FileHandle>;