cloving 1.1.0 → 1.3.0

package/dist/src/daemon/analysis-token.js

@@ -1,88 +0,0 @@
-import { spawn } from "node:child_process";
-function failed(category) {
-    return { error: "analysis-token-command-" + category };
-}
-function commandOf(setting) {
-    try {
-        const parsed = JSON.parse(setting);
-        if (!Array.isArray(parsed) || parsed.length === 0)
-            return undefined;
-        const entries = parsed;
-        if (entries.every((entry) => typeof entry === "string" && entry.length > 0))
-            return entries;
-        return undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function tokenOf(chunks) {
-    const token = Buffer.concat(chunks)
-        .toString("utf8")
-        .replace(/(?:\r\n|[\r\n])$/, "");
-    return /^[!-~]{1,512}$/.test(token) ? { token } : failed("output-invalid");
-}
-function captured(command, request) {
-    return new Promise((settle) => {
-        const [program = "", ...arguments_] = command;
-        const child = spawn(program, arguments_, {
-            cwd: request.folder,
-            shell: false,
-            stdio: ["ignore", "pipe", "pipe"],
-            signal: request.signal,
-            killSignal: "SIGKILL",
-        });
-        const chunks = [];
-        let bytes = 0;
-        let stopped = false;
-        const stop = (category) => {
-            stopped = true;
-            clearTimeout(timer);
-            child.kill("SIGKILL");
-            child.stdout.destroy();
-            child.stderr.destroy();
-            settle(failed(category));
-        };
-        const timer = setTimeout(() => {
-            stop("timeout");
-        }, 10_000);
-        const received = (chunk, output) => {
-            if (stopped)
-                return;
-            bytes += chunk.length;
-            if (bytes > 4_096) {
-                stop("output-too-large");
-                return;
-            }
-            output?.push(chunk);
-        };
-        child.stdout.on("data", (chunk) => {
-            received(chunk, chunks);
-        });
-        child.stderr.on("data", (chunk) => {
-            received(chunk);
-        });
-        child.once("error", () => {
-            stop("failed");
-        });
-        child.once("close", (code) => {
-            clearTimeout(timer);
-            if (!stopped)
-                settle(code === 0 ? tokenOf(chunks) : failed("failed"));
-        });
-    });
-}
-export async function analysisToken(folder, signal) {
-    const setting = process.env["CLOVING_ANALYSIS_TOKEN_COMMAND"];
-    if (setting === undefined)
-        return failed("unset");
-    const command = commandOf(setting);
-    if (command === undefined)
-        return failed("invalid");
-    try {
-        return await captured(command, { folder, signal });
-    }
-    catch {
-        return failed("failed");
-    }
-}

package/dist/src/daemon/analysis-worker.d.ts

@@ -1,22 +0,0 @@
-import type { AdapterOutcome, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
-import { type TokenPrices } from "../token-prices.ts";
-import { type RetrySettings } from "./retrying-turn.ts";
-import { type WorkerReport } from "./operation-journal.ts";
-interface Settings extends RetrySettings {
-    readonly tokenPrices?: TokenPrices;
-    readonly journal: string;
-    readonly document: (digest: string) => Promise<string | undefined>;
-    readonly report: (report: WorkerReport) => Promise<unknown>;
-    readonly stopMilliseconds?: number;
-}
-interface AnalysisWorker {
-    readonly deliver: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome | {
-        readonly receipt: string;
-        readonly worker: string;
-    }>;
-    readonly reconcile: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
-    readonly stop: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
-    readonly close: () => Promise<void>;
-}
-export declare function analysisWorker(settings: Settings): AnalysisWorker;
-export {};

package/dist/src/daemon/analysis-worker.js

@@ -1,219 +0,0 @@
-import { mkdir, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { analysisPrompt } from "../chats/analysis-prompt.js";
-import { isAnalysisSnapshot } from "../chats/analysis-input.js";
-import { record } from "../protocol.js";
-import { estimatedCostUsd, priceForModel, } from "../token-prices.js";
-import { startRetriedTurn } from "./retrying-turn.js";
-import { analysisAvailable, analysisMethod } from "./analysis-launch.js";
-import { analysisToken } from "./analysis-token.js";
-import { located, readRecord, writeRecord, replied, reportOf, interrupted, } from "./operation-journal.js";
-function own(intent) {
-    return (intent.kind === "protected-effect" &&
-        intent.capability === "claude" &&
-        intent.method === analysisMethod &&
-        intent.target !== undefined &&
-        intent.payload !== undefined &&
-        intent.leaseGeneration !== undefined);
-}
-function failed(reason) {
-    return { kind: "failed", reason };
-}
-function snapshotOf(text) {
-    try {
-        return record(JSON.parse(text ?? "null"))?.["snapshot"];
-    }
-    catch {
-        return undefined;
-    }
-}
-async function cleaned(folder) {
-    await Promise.all(["configuration", "working"].map((name) => rm(join(folder, name), { recursive: true, force: true })));
-}
-async function privateRecord(folder, entry) {
-    await writeRecord(folder, { ...entry, permissions: "private" });
-}
-function outcome(end, prices) {
-    const endedAt = new Date().toISOString();
-    if (end.stopped)
-        return { outcome: "stopped", endedAt };
-    const result = end.result;
-    if (result === undefined)
-        return { ...interrupted("analysis-turn-failed"), endedAt };
-    const fields = {
-        costUsd: result.costUsd,
-        usage: result.usage,
-        model: result.model,
-        sessionId: result.sessionId,
-        turns: result.turns,
-        estimatedCostUsd: estimatedCostUsd(result.usage, {
-            worker: "claude",
-            price: priceForModel(prices, result.model),
-        }),
-    };
-    if (end.exitCode !== 0 || result.failed)
-        return {
-            outcome: "failed",
-            reason: "analysis-turn-failed",
-            endedAt,
-            result: JSON.stringify(fields),
-        };
-    if (Buffer.byteLength(result.text, "utf8") > 16_000)
-        return {
-            outcome: "failed",
-            reason: "analysis-reply-too-large",
-            endedAt,
-            result: JSON.stringify(fields),
-        };
-    return {
-        outcome: "completed",
-        endedAt,
-        result: JSON.stringify({ ...fields, reply: result.text }),
-    };
-}
-function running(processId) {
-    if (typeof processId !== "number")
-        return false;
-    try {
-        process.kill(processId, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function reconcile(parts, intent) {
-    if (!own(intent))
-        return failed("unsupported-effect");
-    const { key, folder } = located(parts.settings.journal, intent.operationId);
-    const result = await readRecord(folder, "result.json");
-    if (result !== undefined) {
-        await cleaned(folder);
-        return replied({ receipt: key, worker: "claude" }, result);
-    }
-    if (parts.active.has(key))
-        return { kind: "accepted", receipt: key, worker: "claude" };
-    const started = await readRecord(folder, "started.json");
-    if (started === undefined)
-        return { kind: "absent" };
-    if (running(record(started)?.["processId"]))
-        return { kind: "unknown", evidence: key };
-    const ending = interrupted("analysis-turn-failed");
-    await privateRecord(folder, { name: "result.json", value: ending });
-    await cleaned(folder);
-    return replied({ receipt: key, worker: "claude" }, ending);
-}
-async function begun(parts, opening) {
-    const { intent, folder, key, directory, prompt } = opening;
-    const started = {
-        operationId: intent.operationId,
-        target: intent.target,
-        mode: "analysis",
-        startedAt: new Date().toISOString(),
-    };
-    const turn = await startRetriedTurn({
-        mode: "analysis",
-        analysisToken: opening.token,
-        command: [],
-        folder,
-        directory,
-        prompt,
-    }, { ...parts.settings, metadata: started });
-    const done = turn.ended
-        .then(async (end) => {
-        const result = outcome(end, parts.settings.tokenPrices ?? {});
-        await privateRecord(folder, { name: "result.json", value: result });
-        await cleaned(folder);
-        await parts.settings.report(reportOf({ intent, worker: "claude", commandId: `analysis-turn:${key}` }, result));
-    })
-        .catch(() => undefined)
-        .finally(() => parts.active.delete(key));
-    parts.active.set(key, { turn, done });
-}
-function cancelled(parts, signal) {
-    return signal.aborted || parts.stopping.signal.aborted;
-}
-async function deliver(parts, call) {
-    const { intent, signal } = call;
-    if (!own(intent))
-        return failed("unsupported-effect");
-    const known = await reconcile(parts, intent);
-    if (known.kind !== "absent")
-        return known;
-    const { key, folder } = located(parts.settings.journal, intent.operationId);
-    const text = await parts.settings.document(intent.payload);
-    const snapshot = snapshotOf(text);
-    if (!isAnalysisSnapshot(snapshot) || snapshot.importId !== intent.target)
-        return failed("analysis-input-refused");
-    await mkdir(join(folder, "configuration"), { recursive: true, mode: 0o700 });
-    if (!(await analysisAvailable(folder))) {
-        await cleaned(folder);
-        return failed("analysis-worker-unavailable");
-    }
-    if (cancelled(parts, signal)) {
-        await cleaned(folder);
-        return failed("analysis-turn-failed");
-    }
-    const credential = await analysisToken(folder, signal);
-    if (cancelled(parts, signal)) {
-        await cleaned(folder);
-        return failed("analysis-turn-failed");
-    }
-    if ("error" in credential) {
-        await cleaned(folder);
-        return {
-            ...failed("analysis-worker-unavailable"),
-            result: JSON.stringify({ error: credential.error }),
-        };
-    }
-    const directory = join(folder, "working");
-    await mkdir(directory, { mode: 0o700 });
-    await begun(parts, {
-        intent,
-        key,
-        folder,
-        directory,
-        prompt: analysisPrompt(snapshot),
-        token: credential.token,
-    });
-    return { receipt: key, worker: "claude" };
-}
-async function halted(parts, active) {
-    active.turn.stop(parts.settings.stopMilliseconds ?? 2_000);
-    await active.done;
-}
-function delivered(parts, call) {
-    if (cancelled(parts, call.signal))
-        return Promise.resolve(failed("analysis-turn-failed"));
-    const key = call.intent.operationId;
-    const known = parts.preparing.get(key);
-    if (known !== undefined)
-        return known;
-    const signal = AbortSignal.any([call.signal, parts.stopping.signal]);
-    const pending = deliver(parts, { ...call, signal }).finally(() => parts.preparing.delete(key));
-    parts.preparing.set(key, pending);
-    return pending;
-}
-export function analysisWorker(settings) {
-    const parts = {
-        settings,
-        active: new Map(),
-        preparing: new Map(),
-        stopping: new AbortController(),
-    };
-    return {
-        deliver: (intent, signal) => delivered(parts, { intent, signal }),
-        reconcile: (intent) => reconcile(parts, intent),
-        stop: async (intent) => {
-            const active = parts.active.get(located(settings.journal, intent.operationId).key);
-            if (active !== undefined)
-                await halted(parts, active);
-            return reconcile(parts, intent);
-        },
-        close: async () => {
-            parts.stopping.abort();
-            await Promise.all(parts.preparing.values());
-            await Promise.all([...parts.active.values()].map((active) => halted(parts, active)));
-        },
-    };
-}

package/dist/src/daemon/chats-files.d.ts

@@ -1,15 +0,0 @@
-import { type AnalysisSnapshot } from "../chats/analysis-input.ts";
-export declare function analysisDirectory(runtime: string, importId: string): Promise<string>;
-export declare function boundedAnalysisFile(path: string, options?: {
-    readonly permissions?: number;
-}): Promise<string>;
-export declare function readAnalysisSnapshot(directory: string, importId: string): Promise<AnalysisSnapshot>;
-export declare function matchingPrivateFile(path: string, text: string): Promise<void>;
-interface AnalysisOutput {
-    readonly cycleId: string;
-    readonly analysis: string;
-    readonly proposal: string;
-}
-export declare function inspectAnalysisFiles(directory: string, output: AnalysisOutput): Promise<"complete" | "absent">;
-export declare function saveAnalysisFiles(directory: string, output: AnalysisOutput): Promise<void>;
-export {};

package/dist/src/daemon/chats-files.js

@@ -1,113 +0,0 @@
-import { lstat } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { openInput } from "../chats/input-file.js";
-import { createPrivateFile, validateDestination, } from "../chats/destination.js";
-import { analysisDocumentBytes, } from "../chats/analysis-input.js";
-export async function analysisDirectory(runtime, importId) {
-    if (process.platform !== "darwin")
-        throw new Error("platform-unsupported");
-    const directory = resolve(runtime, "chats", importId);
-    await checkedDirectory(directory);
-    return directory;
-}
-async function checkedDirectory(directory) {
-    try {
-        if (!(await lstat(directory)).isDirectory())
-            throw new Error("analysis-input-refused");
-    }
-    catch (error) {
-        if (Reflect.get(Object(error), "code") !== "ENOENT")
-            throw error;
-        const parent = dirname(directory);
-        if (parent === directory)
-            throw error;
-        await checkedDirectory(parent);
-        throw error;
-    }
-    await validateDestination(directory);
-}
-export async function boundedAnalysisFile(path, options = {}) {
-    const handle = await openInput(path);
-    try {
-        if (options.permissions !== undefined &&
-            ((await handle.stat()).mode & 0o777) !== options.permissions)
-            throw new Error("analysis-output-failed");
-        const buffer = Buffer.alloc(analysisDocumentBytes + 1);
-        let size = 0;
-        while (size < buffer.length) {
-            const { bytesRead } = await handle.read(buffer, size, buffer.length - size, null);
-            if (bytesRead === 0)
-                break;
-            size += bytesRead;
-        }
-        if (size > analysisDocumentBytes)
-            throw new Error("analysis-too-large");
-        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(buffer.subarray(0, size));
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function readAnalysisSnapshot(directory, importId) {
-    const required = async (name) => {
-        try {
-            return await boundedAnalysisFile(join(directory, name));
-        }
-        catch (error) {
-            if (Reflect.get(Object(error), "code") === "ENOENT")
-                throw new Error("redaction-required", { cause: error });
-            throw error;
-        }
-    };
-    return {
-        importId,
-        redaction: await required("redaction.json"),
-        corpus: await required("redacted.jsonl"),
-        structure: await boundedAnalysisFile(join(directory, "structure.json")),
-    };
-}
-export async function matchingPrivateFile(path, text) {
-    try {
-        const existing = await boundedAnalysisFile(path, { permissions: 0o600 });
-        if (existing !== text)
-            throw new Error("analysis-output-failed");
-        return;
-    }
-    catch (error) {
-        if (Reflect.get(Object(error), "code") !== "ENOENT")
-            throw error;
-    }
-    const handle = await createPrivateFile(path);
-    try {
-        await handle.writeFile(text);
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function inspectAnalysisFiles(directory, output) {
-    const proposal = join(directory, `proposal-${output.cycleId}.txt`);
-    const analysis = join(directory, `analysis-${output.cycleId}.json`);
-    const marker = await boundedAnalysisFile(analysis, {
-        permissions: 0o600,
-    }).catch((error) => {
-        if (Reflect.get(Object(error), "code") === "ENOENT")
-            return undefined;
-        throw error;
-    });
-    if (marker === undefined)
-        return "absent";
-    if (marker !== output.analysis ||
-        (await boundedAnalysisFile(proposal, { permissions: 0o600 })) !==
-            output.proposal)
-        throw new Error("analysis-output-failed");
-    return "complete";
-}
-export async function saveAnalysisFiles(directory, output) {
-    if ((await inspectAnalysisFiles(directory, output)) === "complete")
-        return;
-    const proposal = join(directory, `proposal-${output.cycleId}.txt`);
-    const analysis = join(directory, `analysis-${output.cycleId}.json`);
-    await matchingPrivateFile(proposal, output.proposal);
-    await matchingPrivateFile(analysis, output.analysis);
-}

package/dist/src/daemon/chats-worker.d.ts

@@ -1,12 +0,0 @@
-import type { AdapterOutcome, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
-import type { EffectDelivery } from "./delivery-router.ts";
-export interface ChatsWorkerSettings {
-    readonly runtimeDirectory: string;
-    readonly document: (digest: string) => Promise<string | undefined>;
-    readonly workflowId: (runId: string) => Promise<string | undefined>;
-}
-export interface ChatsWorker extends EffectDelivery {
-    readonly deliver: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
-    readonly close: () => Promise<void>;
-}
-export declare function chatsWorker(settings: ChatsWorkerSettings): ChatsWorker;

package/dist/src/daemon/chats-worker.js

@@ -1,200 +0,0 @@
-import { record } from "../protocol.js";
-import { validateAnalysis } from "../chats/analysis.js";
-import { analysisDocumentBytes, analysisEvidence, analysisModelInput, isAnalysisSnapshot, validAnalysisImportId, } from "../chats/analysis-input.js";
-import { analysisProposal } from "../chats/analysis-proposal.js";
-import { operationKey } from "./operation-journal.js";
-import { analysisDirectory, readAnalysisSnapshot, saveAnalysisFiles, inspectAnalysisFiles, } from "./chats-files.js";
-function completed(intent, result) {
-    return {
-        kind: "completed",
-        worker: "chats",
-        receipt: operationKey(intent.operationId),
-        result: JSON.stringify(result),
-    };
-}
-function refused(code, codes = [code]) {
-    return {
-        kind: "failed",
-        reason: code,
-        result: JSON.stringify({ kind: "blocked", codes }),
-    };
-}
-function bounded(text) {
-    if (Buffer.byteLength(text) > analysisDocumentBytes)
-        throw new Error("analysis-too-large");
-}
-function ownIntent(intent) {
-    return (intent.kind === "protected-effect" &&
-        intent.capability === "chats" &&
-        ["read-analysis", "save-analysis"].includes(intent.method ?? "") &&
-        intent.payload !== undefined &&
-        intent.leaseGeneration !== undefined);
-}
-async function payloadOf(settings, intent) {
-    if (!ownIntent(intent) || intent.payload === undefined)
-        throw new Error("unsupported-effect");
-    if ((await settings.workflowId(intent.runId)) !== "analyze-chats")
-        throw new Error("workflow-not-allowed");
-    const text = await settings.document(intent.payload);
-    if (text === undefined)
-        throw new Error("payload-not-available");
-    bounded(text);
-    const payload = record(JSON.parse(text));
-    if (payload === undefined)
-        throw new Error("analysis-input-refused");
-    const importId = payload["importId"];
-    if (typeof importId !== "string" || importId === "")
-        throw new Error("analysis-input-refused");
-    if (!validAnalysisImportId(importId))
-        throw new Error("invalid-import-id");
-    if (intent.target !== importId)
-        throw new Error("analysis-input-refused");
-    return payload;
-}
-async function read(settings, call) {
-    let directory;
-    try {
-        directory = await analysisDirectory(settings.runtimeDirectory, call.importId);
-    }
-    catch (error) {
-        if (Reflect.get(Object(error), "code") === "ENOENT")
-            throw new Error("redaction-required", { cause: error });
-        throw error;
-    }
-    const snapshot = await readAnalysisSnapshot(directory, call.importId);
-    bounded(JSON.stringify(snapshot));
-    bounded(JSON.stringify({ prompt: analysisModelInput(snapshot) }));
-    analysisEvidence(snapshot);
-    const result = { snapshot };
-    bounded(JSON.stringify(result));
-    return completed(call.intent, result);
-}
-function saveInput(payload) {
-    const snapshot = payload["snapshot"];
-    const cycleId = payload["cycleId"];
-    if (!isAnalysisSnapshot(snapshot) ||
-        snapshot.importId !== payload["importId"] ||
-        typeof cycleId !== "string" ||
-        !/^[A-Za-z0-9_-]{1,128}$/.test(cycleId) ||
-        typeof payload["reply"] !== "string")
-        throw new Error("analysis-input-refused");
-    let candidate;
-    try {
-        candidate = JSON.parse(payload["reply"]);
-    }
-    catch {
-        throw new Error("analysis-invalid-json");
-    }
-    return { snapshot, cycleId, candidate };
-}
-async function save(settings, call) {
-    const { snapshot, cycleId, candidate } = saveInput(call.payload);
-    const validation = validateAnalysis(candidate, analysisEvidence(snapshot));
-    if (!validation.accepted)
-        return refused(validation.codes[0] ?? "analysis-input-refused", validation.codes);
-    if (validation.result.openQuestion !== undefined)
-        return refused("analysis-input-refused");
-    try {
-        const directory = await analysisDirectory(settings.runtimeDirectory, snapshot.importId);
-        const output = {
-            cycleId,
-            analysis: JSON.stringify(validation.result) + "\n",
-            proposal: analysisProposal(validation.result),
-        };
-        if (call.mode === "reconcile" &&
-            (await inspectAnalysisFiles(directory, output)) === "absent")
-            return { kind: "absent" };
-        if (call.mode === "deliver")
-            await saveAnalysisFiles(directory, output);
-    }
-    catch {
-        throw new Error("analysis-output-failed");
-    }
-    return completed(call.intent, {
-        kind: "handoff_requested",
-        cycleId,
-        promotionId: `analysis:${snapshot.importId}:${cycleId}`,
-    });
-}
-const reasons = new Set([
-    "analysis-too-large",
-    "redaction-required",
-    "invalid-import-id",
-    "analysis-invalid-json",
-    "analysis-input-refused",
-    "analysis-output-failed",
-    "unsupported-effect",
-    "workflow-not-allowed",
-    "payload-not-available",
-]);
-async function delivered(settings, call) {
-    const { intent, mode } = call;
-    try {
-        if (call.signal?.aborted)
-            return { kind: "stopped" };
-        const payload = await payloadOf(settings, intent);
-        if (call.signal?.aborted)
-            return { kind: "stopped" };
-        if (intent.method === "read-analysis" && mode === "reconcile")
-            return { kind: "absent" };
-        if (intent.method === "read-analysis")
-            return await read(settings, {
-                intent,
-                importId: String(payload["importId"]),
-            });
-        return await save(settings, { intent, payload, mode });
-    }
-    catch (error) {
-        const message = String(Reflect.get(Object(error), "message"));
-        return refused(reasons.has(message) ? message : "analysis-input-refused");
-    }
-}
-export function chatsWorker(settings) {
-    if (process.platform !== "darwin") {
-        const unsupported = () => Promise.resolve(refused("platform-unsupported"));
-        return {
-            deliver: unsupported,
-            reconcile: unsupported,
-            stop: unsupported,
-            close: () => Promise.resolve(),
-        };
-    }
-    const active = new Map();
-    const lifecycle = { closed: false };
-    const deliver = (intent, signal) => {
-        if (lifecycle.closed || signal.aborted)
-            return Promise.resolve({ kind: "stopped" });
-        const key = operationKey(JSON.stringify([intent.runId, intent.operationId, intent.inputDigest]));
-        const known = active.get(key);
-        if (known !== undefined)
-            return known;
-        const pending = delivered(settings, {
-            intent,
-            mode: "deliver",
-            signal,
-        }).finally(() => active.delete(key));
-        active.set(key, pending);
-        return pending;
-    };
-    const stop = async (intent) => {
-        if (!ownIntent(intent))
-            return refused("unsupported-effect");
-        if ((await settings.workflowId(intent.runId)) !== "analyze-chats")
-            return refused("workflow-not-allowed");
-        const key = operationKey(JSON.stringify([intent.runId, intent.operationId, intent.inputDigest]));
-        const pending = active.get(key);
-        if (pending !== undefined)
-            return await pending;
-        const result = await delivered(settings, { intent, mode: "reconcile" });
-        return result.kind === "absent" ? { kind: "stopped" } : result;
-    };
-    return {
-        deliver,
-        reconcile: (intent) => delivered(settings, { intent, mode: "reconcile" }),
-        stop,
-        close: async () => {
-            lifecycle.closed = true;
-            await Promise.all(active.values());
-        },
-    };
-}

package/dist/workflows/analyze-chats.d.ts

@@ -1,10 +0,0 @@
-import type { CycleOutcome } from "cloving/workflows";
-interface AnalysisInput {
-    readonly cycleId: string;
-    readonly repository: string;
-    readonly input: {
-        readonly importId: string;
-    };
-}
-export declare function analyzeChats(input: AnalysisInput): Promise<CycleOutcome>;
-export {};