cloving 1.2.0 → 1.3.0

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 {};

package/dist/src/chats/structure.js

@@ -1,216 +0,0 @@
-function reference(occurrence) {
-    return { recordIndex: occurrence.recordIndex, sourceId: occurrence.sourceId };
-}
-function rawJsonApi(value) {
-    return "isRawJSON" in value && typeof value.isRawJSON === "function";
-}
-function canonical(value) {
-    if (rawJsonApi(JSON) && JSON.isRawJSON(value))
-        return JSON.stringify(value);
-    if (Array.isArray(value))
-        return `[${value.map(canonical).join(",")}]`;
-    if (value === null || typeof value !== "object")
-        return JSON.stringify(value);
-    return `{${Object.entries(value)
-        .sort(([left], [right]) => (left < right ? -1 : Number(left > right)))
-        .map(([key, member]) => `${JSON.stringify(key)}:${canonical(member)}`)
-        .join(",")}}`;
-}
-function occurrence(record, context) {
-    const { recordIndex, identities } = context;
-    const metadata = record.schemaVersion === 2
-        ? {
-            uuid: record.uuid,
-            isSidechain: record.isSidechain,
-            ...(Object.hasOwn(record, "parentUuid")
-                ? { parentUuid: record.parentUuid }
-                : {}),
-        }
-        : { uuid: null, isSidechain: null };
-    const current = {
-        ...reference({ recordIndex, sourceId: record.sourceId }),
-        sessionId: record.sessionId,
-        ...metadata,
-    };
-    if (current.uuid === null)
-        return current;
-    const variants = identities.get(current.uuid) ?? new Map();
-    identities.set(current.uuid, variants);
-    const content = canonical([record.role, record.text, record.blocks]);
-    const matches = variants.get(content) ?? [];
-    variants.set(content, matches);
-    const first = matches[0];
-    matches.push(reference(current));
-    return first === undefined ? current : { ...current, copyOf: { ...first } };
-}
-function groupNodes(occurrences) {
-    const groups = new Map();
-    for (const item of occurrences) {
-        const key = item.uuid ?? item.recordIndex;
-        const group = groups.get(key) ?? [];
-        groups.set(key, group);
-        group.push(item);
-    }
-    return [...groups.values()];
-}
-function parentLinks(group, known) {
-    const parents = new Map();
-    for (const item of group) {
-        if (item.parentUuid === undefined)
-            continue;
-        const references = parents.get(item.parentUuid) ?? [];
-        parents.set(item.parentUuid, references);
-        references.push(reference(item));
-    }
-    const childUuid = group[0]?.uuid ?? null;
-    return [...parents].map(([parentUuid, occurrences]) => {
-        let status = "resolved";
-        if (parentUuid === null)
-            status = "root";
-        if (parentUuid !== null && !known.has(parentUuid))
-            status = "missing";
-        if (childUuid === null || parents.size > 1)
-            status = "ambiguous";
-        return { childUuid, parentUuid, occurrences, status };
-    });
-}
-function forkPoints(links) {
-    const children = new Map();
-    for (const link of links) {
-        if (link.status === "ambiguous" ||
-            link.parentUuid === null ||
-            link.childUuid === null)
-            continue;
-        const ids = children.get(link.parentUuid) ?? new Set();
-        children.set(link.parentUuid, ids);
-        ids.add(link.childUuid);
-    }
-    return [...children]
-        .filter(([, ids]) => ids.size > 1)
-        .map(([parentUuid, ids]) => ({ parentUuid, childUuids: [...ids] }));
-}
-function finishFrom(graph, state) {
-    const { visited, order } = state;
-    const stack = [{ id: state.start, expanded: false }];
-    while (stack.length > 0) {
-        const item = stack.pop();
-        if (item === undefined)
-            break;
-        if (item.expanded) {
-            order.push(item.id);
-            continue;
-        }
-        if (visited.has(item.id))
-            continue;
-        visited.add(item.id);
-        stack.push({ id: item.id, expanded: true });
-        for (const id of graph.get(item.id) ?? [])
-            stack.push({ id, expanded: false });
-    }
-}
-function finishOrder(graph) {
-    const visited = new Set();
-    const order = [];
-    for (const start of graph.keys())
-        finishFrom(graph, { start, visited, order });
-    return order;
-}
-function observedGraph(known, links) {
-    const graph = new Map([...known].map((id) => [id, []]));
-    const reverse = new Map([...known].map((id) => [id, []]));
-    for (const link of links) {
-        if (link.childUuid === null ||
-            link.parentUuid === null ||
-            !known.has(link.parentUuid))
-            continue;
-        graph.get(link.childUuid)?.push(link.parentUuid);
-        reverse.get(link.parentUuid)?.push(link.childUuid);
-    }
-    return { graph, reverse };
-}
-function componentFrom(graph, state) {
-    const component = [];
-    const stack = [state.start];
-    while (stack.length > 0) {
-        const id = stack.pop();
-        if (id === undefined || state.visited.has(id))
-            continue;
-        state.visited.add(id);
-        component.push(id);
-        for (const parent of graph.get(id) ?? [])
-            stack.push(parent);
-    }
-    return component;
-}
-function cycleGroups(known, links) {
-    const { graph, reverse } = observedGraph(known, links);
-    const rank = new Map([...known].map((id, index) => [id, index]));
-    const visited = new Set();
-    const cycles = [];
-    for (const start of finishOrder(graph).reverse()) {
-        if (visited.has(start))
-            continue;
-        const component = componentFrom(reverse, { start, visited });
-        if (component.length > 1 || graph.get(start)?.includes(start))
-            cycles.push(component.sort((left, right) => Number(rank.get(left)) - Number(rank.get(right))));
-    }
-    return cycles.sort((left, right) => Number(rank.get(String(left[0]))) - Number(rank.get(String(right[0]))));
-}
-function sessionStructure(sessionId, occurrences) {
-    const groups = groupNodes(occurrences);
-    const known = new Set(occurrences.flatMap((item) => (item.uuid === null ? [] : [item.uuid])));
-    const links = groups.flatMap((group) => parentLinks(group, known));
-    return {
-        sessionId,
-        nodes: groups.map((group) => ({
-            uuid: group[0]?.uuid ?? null,
-            occurrences: group.map(reference),
-        })),
-        links,
-        forkPoints: forkPoints(links),
-        unknownParents: occurrences
-            .filter((item) => !Object.hasOwn(item, "parentUuid"))
-            .map(reference),
-        missingParentTargets: [
-            ...new Set(links.flatMap((link) => link.parentUuid !== null && !known.has(link.parentUuid)
-                ? [link.parentUuid]
-                : [])),
-        ],
-        cycles: cycleGroups(known, links),
-    };
-}
-export function structureImport(records) {
-    const identities = new Map();
-    const occurrences = records.map((record, index) => occurrence(record, { recordIndex: index, identities }));
-    const grouped = new Map();
-    for (const item of occurrences) {
-        if (item.sessionId === null || item.sessionId === "")
-            continue;
-        const group = grouped.get(item.sessionId) ?? [];
-        grouped.set(item.sessionId, group);
-        group.push(item);
-    }
-    const sessions = [...grouped].map(([id, group]) => sessionStructure(id, group));
-    const conflictGroups = [...identities]
-        .filter(([, variants]) => variants.size > 1)
-        .map(([uuid, variants]) => ({ uuid, variants: [...variants.values()] }));
-    return {
-        historyCompleteness: "unknown",
-        counts: {
-            records: records.length,
-            knownSessions: sessions.length,
-            forks: sessions.reduce((sum, session) => sum + session.forkPoints.length, 0),
-            copies: occurrences.filter((item) => item.copyOf !== undefined).length,
-            conflictGroups: conflictGroups.length,
-            unknownIdentities: occurrences.filter((item) => item.uuid === null)
-                .length,
-            missingParentTargets: sessions.reduce((sum, session) => sum + session.missingParentTargets.length, 0),
-        },
-        occurrences,
-        conflictGroups,
-        sessions,
-        unknownSessions: occurrences
-            .filter((item) => item.sessionId === null || item.sessionId === "")
-            .map(reference),
-    };
-}

package/dist/src/chats/workflow-generation-projection.d.ts

@@ -1,8 +0,0 @@
-import type { AnalysisProcess, AnalysisResult, AnalysisStage } from "./analysis-contract.ts";
-import type { InstalledWorkflowExports } from "../workflow-candidate.ts";
-export interface WorkflowGenerationAvailability {
-    readonly exports: InstalledWorkflowExports;
-    readonly methods: Readonly<Record<string, readonly string[]>>;
-}
-export declare function executionStages(process: AnalysisProcess): readonly AnalysisStage[];
-export declare function generationGaps(analysis: AnalysisResult, availability: WorkflowGenerationAvailability): readonly string[];

package/dist/src/chats/workflow-generation-projection.js

@@ -1,75 +0,0 @@
-const generationExports = {
-    "cloving/workflows": ["CycleOutcome", "ProtectedResult"],
-    "cloving/workflows/steps/protected-effect": ["protectedEffect"],
-    "cloving/workflows/steps/decision-gate": ["decisionGate"],
-};
-export function executionStages(process) {
-    return process.stages.filter((stage) => ["explicit-human-instruction", "observed-repetition"].includes(stage.kind) && ["work", "routine-repair"].includes(stage.activity));
-}
-function supportedBranch(process) {
-    const [review, repair] = executionStages(process);
-    const branch = process.branches[0];
-    return (process.branches.length === 1 &&
-        branch !== undefined &&
-        branch.sourceStageId === review?.id &&
-        branch.targetStageId === repair?.id &&
-        branch.condition === "Defect found.");
-}
-function supportedLoop(process) {
-    const loop = process.loops[0];
-    if (process.loops.length !== 1 || loop === undefined)
-        return false;
-    return (JSON.stringify(loop.stageIds) ===
-        JSON.stringify(executionStages(process).map((stage) => stage.id)) &&
-        loop.exitCondition === "Checks and review pass." &&
-        loop.kind === "explicit-human-instruction" &&
-        process.stoppingConditions.some((stop) => stop.id === loop.exhaustedStoppingConditionId));
-}
-function supportedGates(process) {
-    const review = executionStages(process)[0];
-    return (process.gates.every((gate) => gate.stageId === review?.id &&
-        !["exception", "rejected-approach", "assistant-claim"].includes(gate.kind)) &&
-        process.gates.filter((gate) => gate.type !== "factual-input").length <= 1);
-}
-function controlGaps(process) {
-    const stages = executionStages(process);
-    const [review, repair] = stages;
-    const loop = process.loops[0];
-    const limit = (loop?.maxIterations ?? 0) * 2;
-    return [
-        {
-            code: "ambiguous-stages",
-            supported: stages.length === 2 &&
-                review?.activity === "work" &&
-                repair?.activity === "routine-repair",
-        },
-        { code: "unsupported-branch", supported: supportedBranch(process) },
-        { code: "unsupported-loops", supported: supportedLoop(process) },
-        { code: "unsupported-gates", supported: supportedGates(process) },
-        {
-            code: "effect-limit",
-            supported: Number.isSafeInteger(limit) && limit >= 1 && limit <= 100,
-        },
-    ]
-        .filter((item) => !item.supported)
-        .map((item) => item.code);
-}
-export function generationGaps(analysis, availability) {
-    const gaps = [];
-    if (analysis.openQuestion)
-        gaps.push("unresolved-analysis-question");
-    gaps.push(...controlGaps(analysis.process));
-    for (const [module, names] of Object.entries(generationExports)) {
-        const installed = Object.hasOwn(availability.exports, module)
-            ? availability.exports[module]
-            : undefined;
-        for (const name of names)
-            if (!installed?.includes(name))
-                gaps.push(`missing-export:${module}#${name}`);
-    }
-    if (!Object.hasOwn(availability.methods, "claude"))
-        gaps.push("missing-capability:claude");
-    else if (!availability.methods["claude"]?.includes("run-turn"))
-        gaps.push("missing-method:claude#run-turn");
-    return gaps;
-}

package/dist/src/chats/workflow-generation-source.d.ts

@@ -1,25 +0,0 @@
-export declare const workflowGenerationInputBytes = 16384;
-export interface WorkflowPromptAsset {
-    readonly schemaVersion: 1;
-    readonly name: string;
-    readonly instructions: string;
-    readonly stage: {
-        readonly name: string;
-        readonly description: string;
-    };
-    readonly parameters: readonly {
-        readonly name: string;
-        readonly description: string;
-    }[];
-}
-export interface WorkflowSourceProjection {
-    readonly maximumIterations: number;
-    readonly fields: readonly string[];
-    readonly assets: readonly WorkflowPromptAsset[];
-    readonly gate: {
-        readonly name: string;
-        readonly kind: "question" | "approval";
-        readonly prompt: string;
-    } | null;
-}
-export declare function renderWorkflowSource(projection: WorkflowSourceProjection): string;