cloving 1.2.0 → 1.4.0

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

@@ -1,180 +0,0 @@
-import { validateCoverage, withinRoot } from "./corpus-input.js";
-import { evidenceReason, revisionReasons, } from "./revision.js";
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function exact(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 absolute(value) {
-    return (typeof value === "string" &&
-        value.startsWith("/") &&
-        !value.includes("\0") &&
-        value.split("/").every((part) => part !== "." && part !== ".."));
-}
-function digest(value) {
-    return (value === null ||
-        (typeof value === "string" && /^sha256:[a-f\d]{64}$/.test(value)));
-}
-function evidenceValue(value) {
-    return (object(value) &&
-        digest(value["digest"]) &&
-        (!Object.hasOwn(value, "byteSize") ||
-            (natural(value["byteSize"]) && value["byteSize"] <= 10_485_760)));
-}
-function source(value, roots) {
-    if (!evidenceValue(value) ||
-        !absolute(value["path"]) ||
-        typeof value["status"] !== "string")
-        throw new Error("invalid-import");
-    return {
-        path: value["path"],
-        root: selectedRoot(value["selection"], roots),
-        status: value["status"],
-        digest: value.digest,
-        ...(value.byteSize === undefined ? {} : { byteSize: value.byteSize }),
-    };
-}
-export function parseEvidenceCoverage(text, importId) {
-    validateCoverage(text, importId);
-    const value = JSON.parse(text);
-    if (!object(value))
-        throw new Error("invalid-import");
-    const entries = value["schemaVersion"] === 1 ? value["files"] : value["entries"];
-    const roots = value["schemaVersion"] === 1 ? [] : value["roots"];
-    if (!Array.isArray(entries) ||
-        !Array.isArray(roots) ||
-        !roots.every((root) => typeof root === "string"))
-        throw new Error("invalid-import");
-    return entries.map((entry) => source(entry, roots));
-}
-function revisionValue(value) {
-    return (value === null ||
-        (evidenceValue(value) &&
-            exact(value, { required: ["digest"], optional: ["byteSize"] })));
-}
-function revisionEntry(value) {
-    if (!object(value) ||
-        !exact(value, {
-            required: ["path", "root", "before", "after", "status", "reason"],
-        }))
-        return false;
-    if (!selectionKey(value))
-        return false;
-    const reason = value["reason"];
-    if (typeof reason !== "string" || !Object.hasOwn(revisionReasons, reason))
-        return false;
-    const expected = Object.entries(revisionReasons).find(([key]) => key === reason)?.[1];
-    return (value["status"] === expected &&
-        revisionPresence(value) &&
-        consistentReason(value));
-}
-function revisionPresence(value) {
-    const reason = value["reason"];
-    if (reason === "no-previous-entry")
-        return value["before"] === null && value["after"] !== null;
-    if (reason === "not-selected")
-        return value["before"] !== null && value["after"] === null;
-    return value["before"] !== null && value["after"] !== null;
-}
-function validCounts(value, entries) {
-    const statuses = [
-        "new",
-        "missing",
-        "unchanged",
-        "changed",
-        "truncated",
-        "extended",
-    ];
-    return (object(value) &&
-        exact(value, { required: statuses }) &&
-        statuses.every((status) => natural(value[status]) &&
-            value[status] ===
-                entries.filter((entry) => entry["status"] === status).length));
-}
-export function nextEvidenceRevision(text, importId) {
-    if (text === undefined)
-        return 1;
-    const value = JSON.parse(text);
-    if (!object(value) ||
-        !exact(value, {
-            required: [
-                "schemaVersion",
-                "importId",
-                "previousImportId",
-                "evidenceRevision",
-                "counts",
-                "entries",
-            ],
-        }))
-        throw new Error("invalid-import");
-    if (!revisionHeader(value, importId))
-        throw new Error("invalid-import");
-    const entries = value["entries"];
-    if (!Array.isArray(entries) ||
-        !entries.every(revisionEntry) ||
-        !validCounts(value["counts"], entries))
-        throw new Error("invalid-import");
-    const revision = value["evidenceRevision"];
-    if (!natural(revision))
-        throw new Error("invalid-import");
-    return revision + 1;
-}
-function selectedRoot(selection, roots) {
-    if (roots.length === 0 || !object(selection) || selection["kind"] !== "root")
-        return null;
-    const index = selection["index"];
-    if (!natural(index) || roots[index] === undefined)
-        throw new Error("invalid-import");
-    return roots[index];
-}
-function selectionKey(value) {
-    return (absolute(value["path"]) &&
-        (value["root"] === null ||
-            (absolute(value["root"]) && withinRoot(value["root"], value["path"]))));
-}
-function revisionHeader(value, importId) {
-    const revision = value["evidenceRevision"];
-    if (value["schemaVersion"] !== 1 ||
-        value["importId"] !== importId ||
-        !natural(revision) ||
-        revision === 0 ||
-        revision === Number.MAX_SAFE_INTEGER)
-        return false;
-    const previous = value["previousImportId"];
-    if (typeof previous !== "string" ||
-        previous === importId ||
-        !/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(previous))
-        return false;
-    return true;
-}
-function consistentReason(value) {
-    const before = value["before"];
-    const after = value["after"];
-    if (!revisionValue(before) || !revisionValue(after))
-        return false;
-    const reason = value["reason"];
-    const unverified = [
-        "no-previous-entry",
-        "not-selected",
-        "not-included",
-    ].includes(String(reason));
-    if (!unverified && after?.digest === null)
-        return false;
-    const prefix = reason === "verified-prefix" ? before?.digest : undefined;
-    return (evidenceReason({
-        before: comparable(before, { status: "included" }),
-        after: comparable(after, {
-            status: reason === "not-included" ? "unsupported" : "included",
-            prefixDigest: prefix ?? undefined,
-        }),
-    }) === reason);
-}
-function comparable(value, state) {
-    return value === null ? null : { ...value, ...state };
-}

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

@@ -1,48 +0,0 @@
-export interface SelectionKey {
-    readonly path: string;
-    readonly root: string | null;
-}
-export interface EvidenceValue {
-    readonly digest: string | null;
-    readonly byteSize?: number | undefined;
-}
-export interface ComparableEvidence extends EvidenceValue {
-    readonly status: string;
-    readonly prefixDigest?: string | undefined;
-}
-export interface EvidenceSource extends SelectionKey, ComparableEvidence {
-}
-export declare const revisionReasons: {
-    readonly "no-previous-entry": "new";
-    readonly "not-selected": "missing";
-    readonly "not-included": "missing";
-    readonly "same-digest": "unchanged";
-    readonly "previous-digest-unknown": "changed";
-    readonly "previous-size-unknown": "changed";
-    readonly "shorter-source": "truncated";
-    readonly "verified-prefix": "extended";
-    readonly "digest-changed": "changed";
-};
-export type RevisionReason = keyof typeof revisionReasons;
-export type RevisionStatus = (typeof revisionReasons)[RevisionReason];
-export interface RevisionEntry extends SelectionKey {
-    readonly before: EvidenceValue | null;
-    readonly after: EvidenceValue | null;
-    readonly status: RevisionStatus;
-    readonly reason: RevisionReason;
-}
-export declare function pairEvidence(data: {
-    readonly previous: readonly SelectionKey[];
-    readonly current: readonly SelectionKey[];
-}): readonly (number | null)[];
-export declare function evidenceReason(data: {
-    readonly before: ComparableEvidence | null;
-    readonly after: ComparableEvidence | null;
-}): RevisionReason;
-export declare function compareEvidence(data: {
-    readonly previous: readonly EvidenceSource[];
-    readonly current: readonly EvidenceSource[];
-}): {
-    counts: Record<RevisionStatus, number>;
-    entries: RevisionEntry[];
-};

package/dist/src/chats/revision.js

@@ -1,94 +0,0 @@
-export const revisionReasons = {
-    "no-previous-entry": "new",
-    "not-selected": "missing",
-    "not-included": "missing",
-    "same-digest": "unchanged",
-    "previous-digest-unknown": "changed",
-    "previous-size-unknown": "changed",
-    "shorter-source": "truncated",
-    "verified-prefix": "extended",
-    "digest-changed": "changed",
-};
-export function pairEvidence(data) {
-    const queues = new Map();
-    const key = (entry) => JSON.stringify([entry.path, entry.root]);
-    data.previous.forEach((entry, index) => {
-        const encoded = key(entry);
-        const queue = queues.get(encoded) ?? [];
-        queue.push(index);
-        queues.set(encoded, queue);
-    });
-    return data.current.map((entry) => queues.get(key(entry))?.shift() ?? null);
-}
-export function evidenceReason(data) {
-    const { before, after } = data;
-    if (before === null)
-        return "no-previous-entry";
-    if (after === null)
-        return "not-selected";
-    if (after.status !== "included")
-        return "not-included";
-    if (before.digest !== null && before.digest === after.digest)
-        return "same-digest";
-    if (before.digest === null)
-        return "previous-digest-unknown";
-    if (before.byteSize === undefined)
-        return "previous-size-unknown";
-    return sizeReason({ ...before, byteSize: before.byteSize }, after);
-}
-function sizeReason(before, after) {
-    if (after.byteSize !== undefined && after.byteSize < before.byteSize)
-        return "shorter-source";
-    if (after.byteSize !== undefined &&
-        after.byteSize > before.byteSize &&
-        after.prefixDigest === before.digest)
-        return "verified-prefix";
-    return "digest-changed";
-}
-function value(source) {
-    if (source === undefined)
-        return null;
-    return {
-        digest: source.digest,
-        ...(source.byteSize === undefined ? {} : { byteSize: source.byteSize }),
-    };
-}
-function entry(before, after) {
-    const key = after ?? before;
-    if (key === undefined)
-        throw new Error("invalid-evidence");
-    const why = evidenceReason({ before: before ?? null, after: after ?? null });
-    return {
-        path: key.path,
-        root: key.root,
-        before: value(before),
-        after: value(after),
-        status: revisionReasons[why],
-        reason: why,
-    };
-}
-export function compareEvidence(data) {
-    const pairs = pairEvidence(data);
-    const used = new Set(pairs);
-    const entries = data.current.map((after, index) => {
-        const matched = pairs[index];
-        return entry(matched === null || matched === undefined
-            ? undefined
-            : data.previous[matched], after);
-    });
-    data.previous.forEach((before, index) => {
-        if (!used.has(index))
-            entries.push(entry(before, undefined));
-    });
-    const counts = {
-        new: 0,
-        missing: 0,
-        unchanged: 0,
-        changed: 0,
-        truncated: 0,
-        extended: 0,
-    };
-    for (const item of entries)
-        counts[item.status]++;
-    return { counts, entries };
-}

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

@@ -1,25 +0,0 @@
-import { type ScanSource } from "./source.ts";
-export interface SelectionRequest {
-    readonly paths: readonly string[];
-    readonly roots?: readonly string[];
-    readonly excludeProjects?: readonly string[];
-    readonly workingDirectory: string;
-}
-export interface SelectionOutcome {
-    readonly status: "unreadable" | "unsupported" | "excluded" | "pending";
-    readonly reason: string;
-}
-export interface SourceSelection {
-    readonly kind: "file" | "subtree";
-    readonly path: string;
-    readonly selection: {
-        readonly kind: "file" | "root";
-        readonly index: number;
-    };
-    readonly outcome?: SelectionOutcome;
-    readonly inspection?: ScanSource;
-}
-export declare function selectChatSources(request: SelectionRequest): Promise<{
-    roots: string[];
-    entries: SourceSelection[];
-}>;

package/dist/src/chats/selection.js

@@ -1,109 +0,0 @@
-import { readdir } from "node:fs/promises";
-import { basename, join, relative, resolve } from "node:path";
-import { inspectScanSource, noFollowPath, refuseRepositoryRoot, sourceFailure, verifyScanSource, verifyScanAncestor, } from "./source.js";
-function outcome(reason) {
-    return {
-        status: reason === "source-unreadable" ? "unreadable" : "unsupported",
-        reason,
-    };
-}
-async function scanEntry(entry, context) {
-    try {
-        const { exclusions, depth } = context;
-        const root = entry.inspection?.root ?? entry.path;
-        const inspection = await inspectScanSource(entry.path, root);
-        if (entry.inspection !== undefined)
-            verifyScanAncestor(entry.inspection, inspection);
-        const inspected = { ...entry, kind: inspection.kind, inspection };
-        const disposition = entryDisposition(inspected, context);
-        if (disposition !== undefined)
-            return [{ ...inspected, outcome: disposition }];
-        if (inspection.kind === "file")
-            return [inspected];
-        const entries = [];
-        const children = await readdir(noFollowPath(entry.path), {
-            withFileTypes: true,
-        });
-        await verifyScanSource(inspection);
-        for (const child of children) {
-            const scanned = await scanEntry({
-                ...inspected,
-                kind: child.isDirectory() ? "subtree" : "file",
-                path: join(entry.path, child.name),
-            }, { exclusions, depth: depth + 1 });
-            for (const selected of scanned)
-                entries.push(selected);
-        }
-        return entries;
-    }
-    catch (error) {
-        return [{ ...entry, outcome: outcome(sourceFailure(error)) }];
-    }
-}
-function entryDisposition(entry, context) {
-    if (entry.kind === "file")
-        return entry.path.endsWith(".jsonl")
-            ? undefined
-            : outcome("unsupported-extension");
-    if (context.depth === 1 && context.exclusions.includes(basename(entry.path)))
-        return { status: "excluded", reason: "project-excluded" };
-    if (context.depth === 4)
-        return { status: "pending", reason: "depth-limit" };
-    return;
-}
-async function prepareRoot(path) {
-    const entry = {
-        path,
-        kind: "subtree",
-        selection: { kind: "root", index: 0 },
-    };
-    try {
-        const inspection = await inspectScanSource(path, path);
-        if (inspection.kind !== "subtree")
-            throw new Error("non-directory-root");
-        await refuseRepositoryRoot(inspection.root);
-        return { ...entry, path: inspection.root, inspection };
-    }
-    catch (error) {
-        return { ...entry, outcome: outcome(sourceFailure(error)) };
-    }
-}
-export async function selectChatSources(request) {
-    const entries = request.paths.map((path, index) => ({
-        path: resolve(request.workingDirectory, path),
-        kind: "file",
-        selection: { kind: "file", index },
-    }));
-    const selectedRoots = [];
-    for (const value of request.roots ?? [])
-        selectedRoots.push(await prepareRoot(resolve(request.workingDirectory, value)));
-    selectedRoots.sort((left, right) => stringOrder(left.path, right.path));
-    const roots = selectedRoots.map((root) => root.path);
-    for (const [index, root] of selectedRoots.entries()) {
-        const selected = { ...root, selection: { kind: "root", index } };
-        const scanned = root.outcome === undefined
-            ? await scanEntry(selected, {
-                exclusions: request.excludeProjects ?? [],
-                depth: 0,
-            })
-            : [selected];
-        scanned.sort((left, right) => stringOrder(relative(root.path, left.path), relative(root.path, right.path)));
-        for (const entry of scanned)
-            entries.push(entry);
-    }
-    let attempts = 0;
-    return {
-        roots,
-        entries: entries.map((entry) => {
-            if (entry.selection.kind === "file" || entry.outcome !== undefined)
-                return entry;
-            attempts++;
-            return attempts <= 100
-                ? entry
-                : { ...entry, outcome: { status: "pending", reason: "file-limit" } };
-        }),
-    };
-}
-function stringOrder(left, right) {
-    return left < right ? -1 : Number(left > right);
-}

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

@@ -1,23 +0,0 @@
-import type { Stats } from "node:fs";
-export interface SourceIdentity {
-    readonly path: string;
-    readonly device: number;
-    readonly inode: number;
-}
-export interface ScanSource {
-    readonly path: string;
-    readonly root: string;
-    readonly identities: readonly SourceIdentity[];
-    readonly size: number;
-    readonly modified: number;
-    readonly changed: number;
-    readonly kind: "file" | "subtree";
-}
-export declare function contained(root: string, path: string): boolean;
-export declare function inspectScanSource(path: string, root: string): Promise<ScanSource>;
-export declare function noFollowPath(path: string): string;
-export declare function refuseRepositoryRoot(path: string): Promise<void>;
-export declare function sourceFailure(error: unknown): string;
-export declare function verifyScanSource(expected: ScanSource): Promise<void>;
-export declare function verifyOpenSource(expected: ScanSource, stats: Stats): void;
-export declare function verifyScanAncestor(expected: ScanSource, current: ScanSource): void;

package/dist/src/chats/source.js

@@ -1,135 +0,0 @@
-import { lstat, realpath } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, sep } from "node:path";
-export function contained(root, path) {
-    const suffix = relative(root, path);
-    return (!isAbsolute(suffix) && suffix !== ".." && !suffix.startsWith(`..${sep}`));
-}
-async function inspectComponents(path) {
-    const identities = [];
-    let ancestor = path;
-    const ancestors = [];
-    for (;;) {
-        ancestors.unshift(ancestor);
-        const parent = dirname(ancestor);
-        if (parent === ancestor)
-            break;
-        ancestor = parent;
-    }
-    let stats;
-    for (const component of ancestors) {
-        const next = await lstat(noFollowPath(component));
-        if (next.isSymbolicLink())
-            throw new Error("symbolic-link");
-        identities.unshift({ path: component, device: next.dev, inode: next.ino });
-        stats = next;
-    }
-    if (stats === undefined)
-        throw new Error("source-unreadable");
-    return { identities, stats };
-}
-export async function inspectScanSource(path, root) {
-    const { identities, stats } = await inspectComponents(path);
-    const canonicalPath = await realpath(path);
-    const canonicalRoot = path === root ? canonicalPath : root;
-    if (!contained(canonicalRoot, canonicalPath))
-        throw new Error("outside-root");
-    const canonicalStats = await lstat(noFollowPath(canonicalPath));
-    if (canonicalStats.dev !== stats.dev || canonicalStats.ino !== stats.ino)
-        throw new Error("source-changed");
-    const confirmation = await inspectComponents(path);
-    if (JSON.stringify(confirmation.identities) !== JSON.stringify(identities))
-        throw new Error("source-changed");
-    if (!stats.isDirectory() && !stats.isFile())
-        throw new Error("nonregular-file");
-    return {
-        path,
-        root: canonicalRoot,
-        identities,
-        size: stats.size,
-        modified: stats.mtimeMs,
-        changed: stats.ctimeMs,
-        kind: stats.isDirectory() ? "subtree" : "file",
-    };
-}
-export function noFollowPath(path) {
-    if (process.platform !== "darwin")
-        throw new Error("platform-unsupported");
-    if (!isAbsolute(path))
-        throw new Error("source-unreadable");
-    return `/.nofollow${path}`;
-}
-async function metadata(path) {
-    try {
-        return await lstat(noFollowPath(path));
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return;
-        throw error;
-    }
-}
-async function repositoryMarker(path) {
-    if (await metadata(join(path, ".git")))
-        return true;
-    const [head, objects, references] = await Promise.all([
-        metadata(join(path, "HEAD")),
-        metadata(join(path, "objects")),
-        metadata(join(path, "refs")),
-    ]);
-    return (head?.isFile() === true &&
-        objects?.isDirectory() === true &&
-        references?.isDirectory() === true);
-}
-export async function refuseRepositoryRoot(path) {
-    let ancestor = path;
-    for (;;) {
-        if (await repositoryMarker(ancestor))
-            throw new Error("repository-root");
-        const parent = dirname(ancestor);
-        if (parent === ancestor)
-            return;
-        ancestor = parent;
-    }
-}
-export function sourceFailure(error) {
-    if (error instanceof Error && "code" in error && error.code === "ELOOP")
-        return "symbolic-link";
-    const reason = error instanceof Error ? error.message : "";
-    return [
-        "symbolic-link",
-        "outside-root",
-        "nonregular-file",
-        "repository-root",
-        "source-changed",
-        "non-directory-root",
-    ].includes(reason)
-        ? reason
-        : "source-unreadable";
-}
-export async function verifyScanSource(expected) {
-    const current = await inspectScanSource(expected.path, expected.root);
-    if (JSON.stringify(current.identities) !== JSON.stringify(expected.identities))
-        throw new Error("source-changed");
-    if (expected.kind === "file" &&
-        (current.size !== expected.size ||
-            current.modified !== expected.modified ||
-            current.changed !== expected.changed))
-        throw new Error("source-changed");
-}
-export function verifyOpenSource(expected, stats) {
-    const identity = expected.identities[0];
-    if (!stats.isFile() ||
-        identity === undefined ||
-        stats.dev !== identity.device ||
-        stats.ino !== identity.inode ||
-        stats.size !== expected.size ||
-        stats.mtimeMs !== expected.modified ||
-        stats.ctimeMs !== expected.changed)
-        throw new Error("source-changed");
-}
-export function verifyScanAncestor(expected, current) {
-    const ancestors = current.identities.slice(-expected.identities.length);
-    if (expected.identities.some((identity, index) => identity.device !== ancestors[index]?.device ||
-        identity.inode !== ancestors[index].inode))
-        throw new Error("source-changed");
-}

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

@@ -1,57 +0,0 @@
-import type { MessageRecord } from "./normalize.ts";
-export interface OccurrenceReference {
-    readonly recordIndex: number;
-    readonly sourceId: string;
-}
-export interface Occurrence extends OccurrenceReference {
-    readonly uuid: string | null;
-    readonly sessionId: string | null;
-    readonly isSidechain: boolean | null;
-    readonly parentUuid?: string | null;
-    readonly copyOf?: OccurrenceReference;
-}
-interface ConflictGroup {
-    readonly uuid: string;
-    readonly variants: readonly (readonly OccurrenceReference[])[];
-}
-interface ParentLink {
-    readonly childUuid: string | null;
-    readonly parentUuid: string | null;
-    readonly occurrences: readonly OccurrenceReference[];
-    readonly status: "root" | "resolved" | "missing" | "ambiguous";
-}
-interface SessionNode {
-    readonly uuid: string | null;
-    readonly occurrences: readonly OccurrenceReference[];
-}
-interface SessionStructure {
-    readonly sessionId: string;
-    readonly nodes: readonly SessionNode[];
-    readonly links: readonly ParentLink[];
-    readonly forkPoints: readonly {
-        parentUuid: string;
-        childUuids: readonly string[];
-    }[];
-    readonly unknownParents: readonly OccurrenceReference[];
-    readonly missingParentTargets: readonly string[];
-    readonly cycles: readonly (readonly string[])[];
-}
-export interface StructureCounts {
-    readonly records: number;
-    readonly knownSessions: number;
-    readonly forks: number;
-    readonly copies: number;
-    readonly conflictGroups: number;
-    readonly unknownIdentities: number;
-    readonly missingParentTargets: number;
-}
-export interface ImportStructure {
-    readonly historyCompleteness: "unknown";
-    readonly counts: StructureCounts;
-    readonly occurrences: readonly Occurrence[];
-    readonly conflictGroups: readonly ConflictGroup[];
-    readonly sessions: readonly SessionStructure[];
-    readonly unknownSessions: readonly OccurrenceReference[];
-}
-export declare function structureImport(records: readonly MessageRecord[]): ImportStructure;
-export {};