cloving 1.2.0 → 1.3.0

package/dist/workflows/analyze-chats.js

@@ -1,250 +0,0 @@
-import { decisionGate } from "cloving/workflows/steps/decision-gate";
-import { protectedEffect } from "cloving/workflows/steps/protected-effect";
-function request(importId, step) {
-    const { operation, payload } = step;
-    return {
-        scope: { phase: "analysis", operation, round: step.round ?? 1 },
-        capability: operation === "turn-analysis" ? "claude" : "chats",
-        method: operation === "turn-analysis" ? "run-turn:analyze-chats" : operation,
-        target: importId,
-        payload: JSON.stringify(payload),
-        units: 1,
-    };
-}
-function blocked(cycleId, failure) {
-    const { operation, result } = failure;
-    return {
-        kind: "blocked",
-        cycleId,
-        evidenceId: operation,
-        reason: "reason" in result && result.reason !== null
-            ? result.reason
-            : result.kind,
-    };
-}
-function record(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function fields(result) {
-    try {
-        const value = JSON.parse(result ?? "null");
-        return record(value) ? value : {};
-    }
-    catch {
-        return {};
-    }
-}
-function usableDraft(cycleId, draft) {
-    return (draft["cycleId"] === cycleId &&
-        typeof draft["candidateDigest"] === "string" &&
-        /^[a-f0-9]{64}$/.test(draft["candidateDigest"]) &&
-        typeof draft["expiresAt"] === "string" &&
-        record(draft["question"]));
-}
-function draftAnswer(draft, decision) {
-    if (decision.decision === "expired")
-        return "analysis-answer-missing";
-    const question = draft["question"];
-    const choices = record(question) ? question["choices"] : undefined;
-    if (decision.gateId !== "analysis-question" ||
-        decision.decision !== "answered" ||
-        typeof decision.answer !== "string" ||
-        !Array.isArray(choices) ||
-        !choices.some((choice) => record(choice) && choice["id"] === decision.answer))
-        return "analysis-answer-invalid";
-    return null;
-}
-async function askDraft(cycleId, continuation) {
-    const { draft, decision } = continuation;
-    if (!usableDraft(cycleId, draft))
-        return {
-            kind: "blocked",
-            cycleId,
-            reason: "analysis-input-refused",
-            evidenceId: "save-analysis",
-        };
-    if (decision !== undefined) {
-        const reason = draftAnswer(draft, decision);
-        if (reason === null)
-            return { kind: "answered", answer: decision.answer ?? "" };
-        return {
-            kind: "blocked",
-            cycleId,
-            reason,
-            evidenceId: "analysis-question",
-        };
-    }
-    const gate = await decisionGate({
-        gateId: "analysis-question",
-        kind: "question",
-        prompt: JSON.stringify({
-            candidateDigest: draft["candidateDigest"],
-            question: draft["question"],
-        }),
-        expiresAt: draft.expiresAt,
-    });
-    if (gate.kind !== "opened")
-        return {
-            kind: "blocked",
-            cycleId,
-            reason: gate.reason,
-            evidenceId: "analysis-question",
-        };
-    return { kind: "waiting_for_decision", cycleId, decisionId: gate.decisionId };
-}
-async function firstTurn(input) {
-    const { cycleId } = input;
-    const { importId } = input.input;
-    const read = await protectedEffect(request(importId, { operation: "read-analysis", payload: { importId } }));
-    if (read.kind !== "completed")
-        return blocked(cycleId, { operation: "read-analysis", result: read });
-    const captured = fields(read.result);
-    const snapshot = captured["snapshot"];
-    if (!record(snapshot) || snapshot["importId"] !== importId)
-        return {
-            kind: "blocked",
-            cycleId,
-            reason: "analysis-input-refused",
-            evidenceId: "read-analysis",
-        };
-    return runTurn(input, batchData(captured, snapshot));
-}
-function batchData(value, snapshot) {
-    const context = value["context"];
-    const batch = value["batch"];
-    return {
-        snapshot,
-        ...(record(context) ? { context } : {}),
-        ...(record(batch) ? { batch } : {}),
-    };
-}
-async function runTurn(input, data) {
-    const { cycleId } = input;
-    const { snapshot, followUp, context } = data;
-    const turn = await protectedEffect(request(input.input.importId, {
-        operation: "turn-analysis",
-        payload: {
-            snapshot,
-            ...(context === undefined ? {} : { context }),
-            ...(followUp === undefined ? {} : { followUp }),
-        },
-        round: turnRound(data),
-    }));
-    if (turn.kind !== "completed")
-        return blocked(cycleId, { operation: "turn-analysis", result: turn });
-    const reply = fields(turn.result)["reply"];
-    if (typeof reply !== "string")
-        return {
-            kind: "blocked",
-            cycleId,
-            reason: "analysis-turn-failed",
-            evidenceId: "turn-analysis",
-        };
-    return { kind: "analyzed", data, reply };
-}
-function handoff(cycleId, importId) {
-    return {
-        kind: "handoff_requested",
-        cycleId,
-        promotionId: `analysis:${importId}:${cycleId}`,
-    };
-}
-function turnRound(data) {
-    if (data.followUp !== undefined)
-        return data.batch === undefined ? 2 : 5;
-    return Number(data.batch?.["batchIndex"] ?? 0) + 1;
-}
-async function saveTurn(input, turn) {
-    const { batch, followUp } = turn.data;
-    return protectedEffect(request(input.input.importId, {
-        operation: "save-analysis",
-        round: turnRound(turn.data),
-        payload: {
-            importId: input.input.importId,
-            cycleId: input.cycleId,
-            reply: turn.reply,
-            ...(batch === undefined ? {} : { batch }),
-            ...(followUp === undefined ? {} : { followUp }),
-        },
-    }));
-}
-export async function analyzeChats(input, decision) {
-    "use workflow";
-    const { cycleId } = input;
-    const { importId } = input.input;
-    let analyzed = await firstTurn(input);
-    let answered = false;
-    while (analyzed.kind === "analyzed") {
-        const { data, reply } = analyzed;
-        const save = await saveTurn(input, analyzed);
-        if (save.kind !== "completed")
-            return blocked(cycleId, { operation: "save-analysis", result: save });
-        const saved = fields(save.result);
-        if (saved["kind"] === "analysis_draft") {
-            analyzed = await questionTurn(input, {
-                saved,
-                data,
-                reply,
-                decision,
-                answered,
-            });
-            answered = true;
-            continue;
-        }
-        if (saved["kind"] !== "analysis_batch")
-            return finishBatch(input, {
-                saved,
-                decision: answered ? undefined : decision,
-            });
-        const nextSnapshot = saved["snapshot"];
-        if (!record(nextSnapshot) || nextSnapshot["importId"] !== importId)
-            return blocked(cycleId, {
-                operation: "save-analysis",
-                result: { kind: "refused", reason: "analysis-input-refused" },
-            });
-        analyzed = await runTurn(input, batchData(saved, nextSnapshot));
-    }
-    return analyzed;
-}
-async function questionTurn(input, continuation) {
-    const { saved, data, reply, decision, answered } = continuation;
-    if (answered)
-        return blocked(input.cycleId, {
-            operation: "save-analysis",
-            result: { kind: "refused", reason: "analysis-question-limit" },
-        });
-    const answer = await askDraft(input.cycleId, { draft: saved, decision });
-    if (answer.kind !== "answered")
-        return answer;
-    return runTurn(input, {
-        ...data,
-        followUp: { draft: fields(reply), answer: answer.answer },
-    });
-}
-function finishBatch(input, result) {
-    const { cycleId } = input;
-    const { importId } = input.input;
-    const { saved, decision } = result;
-    if (saved["kind"] === "analysis_partial")
-        return {
-            kind: "blocked",
-            cycleId,
-            reason: String(saved["reason"]),
-            evidenceId: "save-analysis",
-        };
-    if (decision !== undefined)
-        return {
-            kind: "blocked",
-            cycleId,
-            reason: "analysis-answer-invalid",
-            evidenceId: "analysis-question",
-        };
-    if (saved["kind"] !== "handoff_requested")
-        return {
-            kind: "blocked",
-            cycleId,
-            reason: "analysis-input-refused",
-            evidenceId: "save-analysis",
-        };
-    return handoff(cycleId, importId);
-}