cloving 1.0.1 → 1.2.0

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

@@ -0,0 +1,235 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,288 @@
+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.js

@@ -56,7 +56,7 @@ async function privateDirectory(path) {
 }
 export async function importDirectory(runtime, importId) {
     if (process.platform !== "darwin")
-        throw new Error("destination-refused");
+        throw new Error("platform-unsupported");
     let chats;
     try {
         chats = await canonical(join(resolve(runtime), "chats"));
@@ -73,6 +73,8 @@ export async function importDirectory(runtime, importId) {
     return directory;
 }
 export async function validateDestination(directory) {
+    if (process.platform !== "darwin")
+        throw new Error("platform-unsupported");
     if ((await realpath(directory)) !== directory)
         throw new Error("destination-refused");
     await outsideRepository(directory);

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

@@ -1,13 +1,15 @@
-export interface ImportRequest {
-    readonly paths: readonly string[];
-    readonly workingDirectory: string;
+import { type StructureCounts } from "./structure.ts";
+import { type SelectionRequest } from "./selection.ts";
+export interface ImportRequest extends SelectionRequest {
     readonly runtimeDirectory: string | undefined;
+    readonly previousImportId?: string;
 }
-export interface ImportSummary {
-    readonly code: "import-complete" | "import-partial" | "runtime-directory-unknown" | "destination-refused" | "output-failed";
+export interface ImportSummary extends StructureCounts {
+    readonly code: "import-complete" | "import-partial" | "runtime-directory-unknown" | "platform-unsupported" | "destination-refused" | "output-failed" | "previous-import-refused";
     readonly importId: string | null;
     readonly included: number;
     readonly refused: number;
-    readonly records: number;
+    readonly excluded?: number;
+    readonly pending?: number;
 }
 export declare function importChats(request: ImportRequest): Promise<ImportSummary>;