cloving 1.2.0 → 1.4.0

package/dist/src/chats/destination.js

@@ -1,96 +0,0 @@
-import { constants } from "node:fs";
-import { lstat, mkdir, open, realpath, } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
-function missing(error) {
-    return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-async function canonical(path) {
-    try {
-        await lstat(path);
-    }
-    catch (error) {
-        if (!missing(error))
-            throw error;
-        return join(await canonical(dirname(path)), basename(path));
-    }
-    return realpath(path);
-}
-async function outsideRepository(path) {
-    let ancestor = path;
-    for (;;) {
-        try {
-            await lstat(join(ancestor, ".git"));
-            throw new Error("destination-refused");
-        }
-        catch (error) {
-            if (!missing(error))
-                throw error;
-        }
-        const parent = dirname(ancestor);
-        if (parent === ancestor)
-            return;
-        ancestor = parent;
-    }
-}
-async function privateDirectory(path) {
-    try {
-        const stats = await lstat(path);
-        if (!stats.isDirectory())
-            throw new Error("destination-refused");
-        return;
-    }
-    catch (error) {
-        if (!missing(error))
-            throw error;
-    }
-    await privateDirectory(dirname(path));
-    try {
-        await mkdir(path, { mode: 0o700 });
-    }
-    catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
-            throw error;
-        if (!(await lstat(path)).isDirectory())
-            throw new Error("destination-refused", { cause: error });
-    }
-}
-export async function importDirectory(runtime, importId) {
-    if (process.platform !== "darwin")
-        throw new Error("platform-unsupported");
-    let chats;
-    try {
-        chats = await canonical(join(resolve(runtime), "chats"));
-        await outsideRepository(chats);
-    }
-    catch {
-        throw new Error("destination-refused");
-    }
-    await privateDirectory(chats);
-    await validateDestination(chats);
-    const directory = join(chats, importId);
-    await mkdir(directory, { mode: 0o700 });
-    await validateDestination(directory);
-    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);
-}
-export async function createPrivateFile(path) {
-    await validateDestination(dirname(path));
-    const darwinNoFollowAny = 0x20000000;
-    try {
-        return await open(path, constants.O_WRONLY |
-            constants.O_CREAT |
-            constants.O_EXCL |
-            darwinNoFollowAny, 0o600);
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ELOOP")
-            throw new Error("destination-refused", { cause: error });
-        throw error;
-    }
-}

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

@@ -1,15 +0,0 @@
-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 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 excluded?: number;
-    readonly pending?: number;
-}
-export declare function importChats(request: ImportRequest): Promise<ImportSummary>;

package/dist/src/chats/import.js

@@ -1,243 +0,0 @@
-import { readPreviousImport } from "./previous-import.js";
-import { pairEvidence, compareEvidence, } from "./revision.js";
-import { structureImport } from "./structure.js";
-import { randomUUID } from "node:crypto";
-import { rm } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { createPrivateFile, importDirectory, validateDestination, } from "./destination.js";
-import { readTranscript } from "./reader.js";
-import { selectChatSources, } from "./selection.js";
-const corpusLimit = 52_428_800;
-function boundedCorpusLine(record, previousBytes) {
-    const line = `${JSON.stringify(record)}\n`;
-    const bytes = previousBytes + Buffer.byteLength(line);
-    if (bytes > corpusLimit)
-        throw new Error("corpus-too-large");
-    return { line, bytes };
-}
-async function writeImport(directory, data) {
-    const { request, previous } = data;
-    const selection = await selectChatSources(request);
-    const keys = selection.entries.map((selected) => selectionKey(selected, selection.roots));
-    const pairs = pairEvidence({ previous, current: keys });
-    const evidence = [];
-    const files = [];
-    const records = [];
-    let corpusBytes = 0;
-    const corpus = await createPrivateFile(join(directory, "corpus.jsonl"));
-    try {
-        for (const [index, selected] of selection.entries.entries()) {
-            const matched = pairs[index];
-            const before = matched === null || matched === undefined
-                ? undefined
-                : previous[matched];
-            const result = await readSelected(selected, before?.byteSize);
-            evidence.push({
-                ...selectionKey(selected, selection.roots),
-                ...result.coverage,
-                ...(result.prefixDigest === undefined
-                    ? {}
-                    : { prefixDigest: result.prefixDigest }),
-            });
-            files.push({
-                ...result.coverage,
-                kind: selected.kind,
-                selection: selected.selection,
-            });
-            for (const record of result.records) {
-                const next = boundedCorpusLine(record, corpusBytes);
-                await corpus.writeFile(next.line);
-                corpusBytes = next.bytes;
-                records.push(record);
-            }
-        }
-    }
-    finally {
-        await corpus.close();
-    }
-    return { roots: selection.roots, files, records, evidence };
-}
-function selectionKey(selected, roots) {
-    return {
-        path: selected.path,
-        root: selected.selection.kind === "root"
-            ? (roots[selected.selection.index] ?? null)
-            : null,
-    };
-}
-async function readSelected(selected, prefixBytes) {
-    if (selected.outcome !== undefined)
-        return {
-            coverage: {
-                path: selected.path,
-                ...selected.outcome,
-                digest: null,
-                recordCount: 0,
-                omissions: { metadataRecords: 0, thinkingBlocks: 0 },
-            },
-            records: [],
-        };
-    return readTranscript(selected.path, {
-        ...(selected.inspection === undefined
-            ? {}
-            : { inspection: selected.inspection }),
-        ...(prefixBytes === undefined ? {} : { prefixBytes }),
-    });
-}
-async function writeMetadata(path, data) {
-    const handle = await createPrivateFile(path);
-    try {
-        await handle.writeFile(`${JSON.stringify({ schemaVersion: 1, ...data }, null, 2)}\n`);
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function writeCoverage(directory, coverage) {
-    const manifest = join(directory, "coverage.json");
-    let created = false;
-    try {
-        const handle = await createPrivateFile(manifest);
-        created = true;
-        try {
-            await handle.writeFile(`${JSON.stringify(coverage, null, 2)}\n`);
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    catch (error) {
-        if (created) {
-            await validateDestination(directory);
-            await rm(manifest, { force: true });
-        }
-        throw error;
-    }
-}
-export async function importChats(request) {
-    const empty = emptyImport(request);
-    if (process.platform !== "darwin")
-        return { ...empty, code: "platform-unsupported" };
-    if (request.runtimeDirectory === undefined)
-        return { ...empty, code: "runtime-directory-unknown" };
-    try {
-        const runtime = resolve(request.workingDirectory, request.runtimeDirectory);
-        const previous = request.previousImportId === undefined
-            ? undefined
-            : await readPreviousImport(runtime, request.previousImportId);
-        const importId = randomUUID();
-        const directory = await importDirectory(runtime, importId);
-        return await completeImport(directory, { request, previous, importId });
-    }
-    catch (error) {
-        return {
-            ...empty,
-            code: error instanceof Error &&
-                (error.message === "destination-refused" ||
-                    error.message === "previous-import-refused")
-                ? error.message
-                : "output-failed",
-        };
-    }
-}
-function importTotals(files) {
-    return {
-        included: files.filter((file) => file.status === "included").length,
-        refused: files.filter((file) => ["unreadable", "unsupported", "too-large"].includes(file.status)).length,
-        excluded: files.filter((file) => file.status === "excluded").length,
-        pending: files.filter((file) => file.status === "pending").length,
-    };
-}
-function coverageManifest(data) {
-    const { importId, roots, files, exclusions } = data;
-    if (roots.length > 0)
-        return {
-            schemaVersion: 2,
-            importId,
-            roots,
-            exclusions,
-            limits: {
-                depth: 4,
-                files: 100,
-                sourceBytes: 10_485_760,
-                corpusBytes: corpusLimit,
-            },
-            entries: files,
-        };
-    return {
-        schemaVersion: 1,
-        importId,
-        files: files.map((entry) => ({
-            path: entry.path,
-            status: entry.status,
-            reason: entry.reason,
-            digest: entry.digest,
-            ...(entry.byteSize === undefined ? {} : { byteSize: entry.byteSize }),
-            recordCount: entry.recordCount,
-            omissions: entry.omissions,
-        })),
-    };
-}
-function emptyImport(request) {
-    return {
-        importId: null,
-        included: 0,
-        refused: 0,
-        ...((request.roots?.length ?? 0) === 0 ? {} : { excluded: 0, pending: 0 }),
-        ...structureImport([]).counts,
-    };
-}
-async function completeImport(directory, data) {
-    const { request, previous, importId } = data;
-    const { roots, files, records, evidence } = await writeImport(directory, {
-        request,
-        previous: previous?.entries ?? [],
-    });
-    const structure = structureImport(records);
-    await writeMetadata(join(directory, "structure.json"), {
-        importId,
-        ...structure,
-    });
-    const partial = await writeRevision(directory, {
-        previous,
-        evidence,
-        importId,
-    });
-    const totals = importTotals(files);
-    const { refused, pending } = totals;
-    await writeCoverage(directory, coverageManifest({
-        importId,
-        roots,
-        files,
-        exclusions: request.excludeProjects ?? [],
-    }));
-    return {
-        code: refused + pending + partial === 0 ? "import-complete" : "import-partial",
-        importId,
-        included: totals.included,
-        refused,
-        ...(roots.length === 0 ? {} : { excluded: totals.excluded, pending }),
-        ...structure.counts,
-    };
-}
-async function writeRevision(directory, data) {
-    const { previous, evidence, importId } = data;
-    if (previous === undefined)
-        return 0;
-    const comparison = compareEvidence({
-        previous: previous.entries,
-        current: evidence,
-    });
-    try {
-        await writeMetadata(join(directory, "revision.json"), {
-            importId,
-            previousImportId: previous.importId,
-            evidenceRevision: previous.evidenceRevision,
-            ...comparison,
-        });
-    }
-    catch {
-        throw new Error("output-failed");
-    }
-    return comparison.counts.missing + comparison.counts.truncated;
-}

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

@@ -1,3 +0,0 @@
-import { type FileHandle } from "node:fs/promises";
-export declare function openInput(path: string): Promise<FileHandle>;
-export declare function readInput(path: string): Promise<string>;

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

@@ -1,32 +0,0 @@
-import { constants } from "node:fs";
-import { lstat, open } from "node:fs/promises";
-export async function openInput(path) {
-    if (process.platform !== "darwin")
-        throw new Error("platform-unsupported");
-    const before = await lstat(path);
-    if (!before.isFile() || before.nlink !== 1)
-        throw new Error("invalid-import");
-    const handle = await open(path, constants.O_RDONLY | constants.O_NONBLOCK | 0x20000000);
-    try {
-        const opened = await handle.stat();
-        if (!opened.isFile() ||
-            opened.nlink !== 1 ||
-            opened.dev !== before.dev ||
-            opened.ino !== before.ino)
-            throw new Error("invalid-import");
-        return handle;
-    }
-    catch (error) {
-        await handle.close();
-        throw error;
-    }
-}
-export async function readInput(path) {
-    const handle = await openInput(path);
-    try {
-        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(await handle.readFile());
-    }
-    finally {
-        await handle.close();
-    }
-}

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

@@ -1,29 +0,0 @@
-export interface Omissions {
-    metadataRecords: number;
-    thinkingBlocks: number;
-}
-interface MessageFields {
-    readonly sourceId: string;
-    readonly role: "user" | "assistant";
-    readonly timestamp: string | null;
-    readonly sessionId: string | null;
-    readonly text: string;
-    readonly blocks: readonly Record<string, unknown>[];
-}
-export type MessageRecord = MessageFields & ({
-    readonly schemaVersion: 1;
-} | {
-    readonly schemaVersion: 2;
-    readonly uuid: string | null;
-    readonly isSidechain: boolean | null;
-    readonly parentUuid?: string | null;
-});
-export interface NormalizedTranscript {
-    readonly status: "included" | "unsupported";
-    readonly reason: string;
-    readonly records: readonly MessageRecord[];
-    readonly omissions: Omissions;
-}
-export declare function parsePreservedJson(text: string): unknown;
-export declare function normalizeTranscript(text: string, digest: string): NormalizedTranscript;
-export {};

package/dist/src/chats/normalize.js

@@ -1,155 +0,0 @@
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function supportedBlock(block) {
-    const type = block["type"];
-    if (type === "text" && typeof block["text"] === "string")
-        return { type, text: block["text"] };
-    if (type === "tool_use" &&
-        typeof block["id"] === "string" &&
-        typeof block["name"] === "string" &&
-        Object.hasOwn(block, "input")) {
-        return {
-            type,
-            id: block["id"],
-            name: block["name"],
-            input: block["input"],
-        };
-    }
-    if (type === "tool_result")
-        return toolResult(block);
-    throw new Error("unsupported-block");
-}
-function toolResult(block) {
-    if (typeof block["tool_use_id"] !== "string" ||
-        !Object.hasOwn(block, "content"))
-        throw new Error("unsupported-block");
-    if (Object.hasOwn(block, "is_error") &&
-        typeof block["is_error"] !== "boolean")
-        throw new Error("unsupported-block");
-    return {
-        type: "tool_result",
-        tool_use_id: block["tool_use_id"],
-        content: block["content"],
-        ...(Object.hasOwn(block, "is_error")
-            ? { is_error: block["is_error"] }
-            : {}),
-    };
-}
-function optionalText(value) {
-    if (value === undefined || value === null)
-        return null;
-    if (typeof value !== "string")
-        throw new Error("unsupported-message");
-    return value;
-}
-function rawJsonApi(value) {
-    return "rawJSON" in value && typeof value.rawJSON === "function";
-}
-function preserveJson(...argumentsList) {
-    const [, value, context] = argumentsList;
-    if (typeof value !== "number")
-        return value;
-    if (!object(context) || typeof context["source"] !== "string")
-        throw new Error("unsupported-record");
-    if (JSON.stringify(value) === context["source"])
-        return value;
-    if (!rawJsonApi(JSON))
-        throw new Error("unsupported-record");
-    return JSON.rawJSON(context["source"]);
-}
-export function parsePreservedJson(text) {
-    return JSON.parse(text, preserveJson);
-}
-function blocks(content, omissions) {
-    if (typeof content === "string")
-        return [{ position: 0, type: "text", text: content }];
-    if (!Array.isArray(content))
-        throw new Error("unsupported-message");
-    return content.flatMap((block, position) => {
-        if (!object(block))
-            throw new Error("unsupported-block");
-        if (block["type"] === "thinking") {
-            omissions.thinkingBlocks++;
-            return [];
-        }
-        return [{ ...supportedBlock(block), position }];
-    });
-}
-function identity(value) {
-    const uuid = value["uuid"];
-    const parent = value["parentUuid"];
-    const sidechain = value["isSidechain"];
-    return {
-        uuid: typeof uuid === "string" && uuid !== "" ? uuid : null,
-        isSidechain: typeof sidechain === "boolean" ? sidechain : null,
-        ...(parent === null || (typeof parent === "string" && parent !== "")
-            ? { parentUuid: parent }
-            : {}),
-    };
-}
-function message(value, context) {
-    if (!object(value) || typeof value["type"] !== "string")
-        throw new Error("unsupported-record");
-    if (value["type"] !== "user" &&
-        value["type"] !== "assistant" &&
-        Object.hasOwn(value, "message"))
-        throw new Error("unsupported-message");
-    if (value["type"] !== "user" && value["type"] !== "assistant") {
-        context.omissions.metadataRecords++;
-        return null;
-    }
-    const envelope = value["message"];
-    if (!object(envelope) || envelope["role"] !== value["type"])
-        throw new Error("unsupported-message");
-    const normalized = blocks(envelope["content"], context.omissions);
-    return {
-        schemaVersion: 2,
-        ...identity(value),
-        sourceId: context.sourceId,
-        role: value["type"],
-        timestamp: optionalText(value["timestamp"]),
-        sessionId: optionalText(value["sessionId"]),
-        text: normalized
-            .filter((block) => block["type"] === "text")
-            .map((block) => block["text"])
-            .join("\n"),
-        blocks: normalized,
-    };
-}
-export function normalizeTranscript(text, digest) {
-    const omissions = { metadataRecords: 0, thinkingBlocks: 0 };
-    const records = [];
-    if (text === "")
-        return { status: "unsupported", reason: "empty-file", records, omissions };
-    let offset = 0;
-    const lines = text.split("\n");
-    if (lines.at(-1) === "")
-        lines.pop();
-    try {
-        for (const line of lines) {
-            const parsed = parsePreservedJson(line);
-            const record = message(parsed, {
-                sourceId: `${digest}:${String(offset)}`,
-                omissions,
-            });
-            if (record !== null)
-                records.push(record);
-            offset += new TextEncoder().encode(line).length + 1;
-        }
-    }
-    catch (error) {
-        let reason = "unsupported-record";
-        if (error instanceof Error)
-            reason = error.message;
-        if (error instanceof SyntaxError)
-            reason = "invalid-json";
-        return {
-            status: "unsupported",
-            reason,
-            records: [],
-            omissions,
-        };
-    }
-    return { status: "included", reason: "supported", records, omissions };
-}

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

@@ -1,5 +0,0 @@
-export declare function readPreviousImport(runtime: string, importId: string): Promise<{
-    importId: string;
-    entries: readonly import("./revision.ts").EvidenceSource[];
-    evidenceRevision: number;
-}>;

package/dist/src/chats/previous-import.js

@@ -1,34 +0,0 @@
-import { lstat } from "node:fs/promises";
-import { join } from "node:path";
-import { validateDestination } from "./destination.js";
-import { readInput } from "./input-file.js";
-import { parseEvidenceCoverage, nextEvidenceRevision, } from "./revision-input.js";
-async function optionalRevision(path) {
-    try {
-        await lstat(path);
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return;
-        throw error;
-    }
-    return readInput(path);
-}
-export async function readPreviousImport(runtime, importId) {
-    if (process.platform !== "darwin")
-        throw new Error("platform-unsupported");
-    try {
-        if (!/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(importId))
-            throw new Error("invalid-import");
-        const directory = join(runtime, "chats", importId);
-        await validateDestination(directory);
-        if (!(await lstat(directory)).isDirectory())
-            throw new Error("invalid-import");
-        const entries = parseEvidenceCoverage(await readInput(join(directory, "coverage.json")), importId);
-        const evidenceRevision = nextEvidenceRevision(await optionalRevision(join(directory, "revision.json")), importId);
-        return { importId, entries, evidenceRevision };
-    }
-    catch {
-        throw new Error("previous-import-refused");
-    }
-}

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

@@ -1,21 +0,0 @@
-import { type ScanSource } from "./source.ts";
-import { type MessageRecord, type Omissions } from "./normalize.ts";
-export declare const transcriptLimit = 10485760;
-export interface SelectedTranscript {
-    readonly path: string;
-    readonly status: "included" | "unreadable" | "unsupported" | "too-large";
-    readonly reason: string;
-    readonly digest: string | null;
-    readonly byteSize?: number;
-    readonly recordCount: number;
-    readonly omissions: Omissions;
-}
-export interface ReadTranscript {
-    readonly coverage: SelectedTranscript;
-    readonly records: readonly MessageRecord[];
-    readonly prefixDigest?: string;
-}
-export declare function readTranscript(path: string, options?: {
-    readonly inspection?: ScanSource;
-    readonly prefixBytes?: number;
-}): Promise<ReadTranscript>;