cloving 1.1.0 → 1.3.0

package/dist/src/steps/decision-gate.js

@@ -6,3 +6,10 @@ export async function decisionGate(request) {
         return { kind: "unavailable", reason: "cloving-host-unavailable" };
     return await bridge.gate(request);
 }
+export async function openDecisionWait(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.waitForDecision === undefined)
+        throw new Error("cloving-host-unavailable");
+    return await bridge.waitForDecision(request);
+}

package/dist/src/steps/handoff.d.ts

@@ -0,0 +1,2 @@
+import { type HandoffRequest } from "../step-bridge.ts";
+export declare function handoff(request: HandoffRequest): Promise<string>;

package/dist/src/steps/handoff.js

@@ -0,0 +1,13 @@
+import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
+export async function handoff(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.handoff === undefined)
+        throw new Error("cloving-host-unavailable");
+    const result = await bridge.handoff(request);
+    if (result.kind !== "completed")
+        throw new Error(result.reason ?? result.kind);
+    if (result.result === null)
+        throw new Error("handoff-result-missing");
+    return result.result;
+}

package/dist/src/steps/merge-by-person.d.ts

@@ -0,0 +1,2 @@
+import { type MergeRequest, type MergeResult } from "../merge-request.ts";
+export declare function mergeByPerson(request: MergeRequest): Promise<MergeResult>;

package/dist/src/steps/merge-by-person.js

@@ -0,0 +1,18 @@
+import { mergeRequest, } from "../merge-request.js";
+import { mergeWhenGreen } from "./merge-when-green.js";
+import { waitForDecision } from "./wait-for-decision.js";
+export async function mergeByPerson(request) {
+    const { pull, check, round } = mergeRequest(request);
+    const decision = await waitForDecision({
+        gateId: `merge:${String(pull.number)}:${pull.commit}`,
+        kind: "approval",
+        prompt: `Merge pull request #${String(pull.number)} (${pull.url}) at commit ${pull.commit} ${check === null ? "with no local check" : `after the local check ${check}`}.`,
+    });
+    if (decision.decision !== "approved")
+        return {
+            merged: false,
+            reason: "not-approved",
+            output: decision.answer ?? "",
+        };
+    return await mergeWhenGreen({ pull, check, round });
+}

package/dist/src/steps/merge-when-green.d.ts

@@ -0,0 +1,2 @@
+import { type MergeRequest, type MergeResult } from "../merge-request.ts";
+export declare function mergeWhenGreen(request: MergeRequest): Promise<MergeResult>;

package/dist/src/steps/merge-when-green.js

@@ -0,0 +1,62 @@
+import { mergeRequest, } from "../merge-request.js";
+import { record } from "../protocol.js";
+import { protectedEffect } from "./protected-effect.js";
+const repairReasons = [
+    "check-failed",
+    "merge-conflict",
+    "ci-failed",
+    "ci-pending",
+];
+export async function mergeWhenGreen(request) {
+    const { pull, check, round } = mergeRequest(request);
+    const effect = await protectedEffect({
+        capability: "github",
+        method: "merge",
+        target: pull.target,
+        payload: JSON.stringify({
+            number: pull.number,
+            commit: pull.commit,
+            check,
+        }),
+        scope: {
+            phase: "merge",
+            operation: "merge",
+            round,
+            key: `${String(pull.number)}:${pull.commit}`,
+        },
+        units: 1,
+    });
+    return mergeOutcome(effect, pull);
+}
+function mergeOutcome(effect, pull) {
+    if (effect.kind !== "completed")
+        return notMerged(effect);
+    const result = parsedResult(effect.result);
+    const reason = repairReasons.find((name) => name === result["reason"]);
+    if (reason !== undefined && typeof result["output"] === "string")
+        return { merged: false, reason, output: result["output"] };
+    if (result["reason"] !== undefined ||
+        result["number"] !== pull.number ||
+        result["commit"] !== pull.commit ||
+        typeof result["merged"] !== "string")
+        throw new Error("invalid-merge-result");
+    return { merged: true, reason: null, output: "" };
+}
+function notMerged(effect) {
+    if (effect.kind === "failed" && effect.reason === "check-not-configured")
+        return { merged: false, reason: "check-not-configured", output: "" };
+    throw new Error(effect.reason ?? effect.kind);
+}
+function parsedResult(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text ?? "null");
+    }
+    catch {
+        throw new Error("invalid-merge-result");
+    }
+    const result = record(parsed);
+    if (result === undefined)
+        throw new Error("invalid-merge-result");
+    return result;
+}

package/dist/src/steps/review-by-agent.d.ts

@@ -0,0 +1,5 @@
+import type { ReviewResult, ReviewSubject, Reviewer } from "../review-subject.ts";
+export declare function reviewByAgent(request: {
+    readonly subject: ReviewSubject;
+    readonly reviewer: Reviewer;
+}): Promise<ReviewResult>;

package/dist/src/steps/review-by-agent.js

@@ -0,0 +1,124 @@
+import { record } from "../protocol.js";
+import { protectedEffect } from "./protected-effect.js";
+import { snapshotReviewSubject } from "./review-subject.js";
+export async function reviewByAgent(request) {
+    const reviewer = selectedReviewer(request.reviewer);
+    const subject = { ...request.subject };
+    const snapshot = await snapshotReviewSubject(subject);
+    const effect = await protectedEffect({
+        ...reviewEffect({ subject, snapshot, reviewer }),
+        scope: {
+            phase: "review",
+            operation: reviewer.kind === "greptile" ? "greptile" : `turn:${reviewer.profile}`,
+            round: 1,
+            key: snapshot.subjectDigest,
+        },
+        units: 1,
+    });
+    if (effect.kind !== "completed")
+        throw new Error(effect.reason ?? effect.kind);
+    let parsed;
+    try {
+        parsed = JSON.parse(effect.result ?? "null");
+    }
+    catch {
+        throw new Error("invalid-review-result");
+    }
+    return {
+        ...(reviewer.kind === "turn"
+            ? turnResult(parsed)
+            : greptileFeedback(parsed, subject)),
+        commit: snapshot.commit,
+        subjectDigest: snapshot.subjectDigest,
+    };
+}
+function selectedReviewer(value) {
+    const reviewer = record(value);
+    if (reviewer?.["kind"] === "greptile")
+        return { kind: "greptile" };
+    if (reviewer?.["kind"] === "turn" &&
+        typeof reviewer["profile"] === "string" &&
+        /^[A-Za-z0-9_-]{1,119}$/.test(reviewer["profile"]))
+        return { kind: "turn", profile: reviewer["profile"] };
+    throw new Error("invalid-reviewer");
+}
+function reviewEffect(input) {
+    const { subject, snapshot, reviewer } = input;
+    if (reviewer.kind === "turn")
+        return {
+            capability: "claude",
+            method: `run-turn:${reviewer.profile}`,
+            target: "draft" in subject ? snapshot.subjectDigest : subject.target,
+            payload: `Review only this immutable subject. Do not change it. For a commit, inspect that exact commit, not the current branch head.\n${snapshot.prompt}\nEnd your report with exactly one of these lines:\nReview verdict: accept\nReview verdict: change`,
+        };
+    if ("draft" in subject ||
+        !Number.isSafeInteger(subject.number) ||
+        Number(subject.number) < 1)
+        throw new Error("invalid-greptile-subject");
+    return {
+        capability: "github",
+        method: "wait-review",
+        target: subject.target,
+        payload: JSON.stringify({ number: subject.number, commit: subject.commit }),
+    };
+}
+function turnResult(parsed) {
+    const result = record(parsed);
+    if (result &&
+        (result["reviewVerdict"] === null || result["reviewVerdict"] === undefined))
+        return {
+            accepted: false,
+            feedback: "The review turn has no verdict line.",
+        };
+    if (!result ||
+        typeof result["summary"] !== "string" ||
+        (result["reviewVerdict"] !== "accept" &&
+            result["reviewVerdict"] !== "change"))
+        throw new Error("invalid-review-result");
+    return {
+        accepted: result["reviewVerdict"] === "accept",
+        feedback: result["summary"],
+    };
+}
+function greptileFeedback(parsed, subject) {
+    if ("draft" in subject)
+        throw new Error("invalid-greptile-subject");
+    const result = greptileResult(parsed, subject);
+    return {
+        accepted: result.score === 5,
+        feedback: [result.summary, ...result.findings].filter(Boolean).join("\n\n"),
+    };
+}
+function greptileResult(parsed, subject) {
+    const result = record(parsed);
+    if (!result)
+        throw new Error("invalid-review-result");
+    const score = result["score"];
+    const summary = result["summary"];
+    const findings = result["findings"];
+    if (result["number"] !== subject.number ||
+        result["commit"] !== subject.commit ||
+        typeof score !== "number" ||
+        !Number.isInteger(score) ||
+        score < 0 ||
+        score > 5 ||
+        typeof summary !== "string" ||
+        !Array.isArray(findings))
+        throw new Error("invalid-review-result");
+    return {
+        score,
+        summary,
+        findings: findings.map((value) => {
+            const finding = record(value);
+            if (!finding)
+                throw new Error("invalid-review-result");
+            const { path, line, body } = finding;
+            if (typeof path !== "string" ||
+                typeof body !== "string" ||
+                !(line === null ||
+                    (typeof line === "number" && Number.isSafeInteger(line) && line > 0)))
+                throw new Error("invalid-review-result");
+            return `${path}${line === null ? "" : `:${String(line)}`}\n${body}`;
+        }),
+    };
+}

package/dist/src/steps/review-by-person.d.ts

@@ -0,0 +1,4 @@
+import type { ReviewResult, ReviewSubject } from "../review-subject.ts";
+export declare function reviewByPerson(request: {
+    readonly subject: ReviewSubject;
+}): Promise<ReviewResult>;

package/dist/src/steps/review-by-person.js

@@ -0,0 +1,16 @@
+import { snapshotReviewSubject } from "./review-subject.js";
+import { waitForDecision } from "./wait-for-decision.js";
+export async function reviewByPerson(request) {
+    const snapshot = await snapshotReviewSubject(request.subject);
+    const decision = await waitForDecision({
+        gateId: `review:${snapshot.subjectDigest}`,
+        kind: "approval",
+        prompt: `Review this subject:\n${snapshot.prompt}`,
+    });
+    return {
+        accepted: decision.decision === "approved",
+        feedback: decision.answer ?? "",
+        commit: snapshot.commit,
+        subjectDigest: snapshot.subjectDigest,
+    };
+}

package/dist/src/steps/review-subject.d.ts

@@ -0,0 +1,2 @@
+import { type ReviewSubject, type ReviewSnapshot } from "../review-subject.ts";
+export declare function snapshotReviewSubject(subject: ReviewSubject): Promise<ReviewSnapshot>;

package/dist/src/steps/review-subject.js

@@ -0,0 +1,11 @@
+import { operationDigest } from "../broker/operation-digest.js";
+import { reviewSubjectText, } from "../review-subject.js";
+export async function snapshotReviewSubject(subject) {
+    "use step";
+    const prompt = reviewSubjectText(subject);
+    return Promise.resolve({
+        commit: "draft" in subject ? null : subject.commit,
+        subjectDigest: `sha256:${operationDigest(prompt)}`,
+        prompt,
+    });
+}

package/dist/src/steps/run-command.d.ts

@@ -0,0 +1,2 @@
+import { type CommandRequest, type ProtectedResult } from "../step-bridge.ts";
+export declare function runCommand(request: CommandRequest): Promise<ProtectedResult>;

package/dist/src/steps/run-command.js

@@ -0,0 +1,15 @@
+import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
+export async function runCommand(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge))
+        return { kind: "unavailable", reason: "cloving-host-unavailable" };
+    return await bridge.effect({
+        scope: request.scope,
+        capability: "command",
+        method: `run:${request.name}`,
+        target: request.name,
+        payload: JSON.stringify(request.input),
+        units: 1,
+    });
+}

package/dist/src/steps/sleep.d.ts

@@ -0,0 +1,3 @@
+export declare function sleep(request: {
+    readonly seconds: number;
+}): Promise<void>;

package/dist/src/steps/sleep.js

@@ -0,0 +1,19 @@
+import { sleep as sdkSleep } from "workflow";
+export async function sleep(request) {
+    await sdkSleep(sleepSeconds(request) * 1000);
+}
+function sleepSeconds(request) {
+    if (typeof request !== "object" ||
+        request === null ||
+        Reflect.ownKeys(request).length !== 1)
+        throw new Error("invalid-sleep-seconds");
+    const field = Object.getOwnPropertyDescriptor(request, "seconds") ?? {};
+    const seconds = field.value;
+    if (field.enumerable !== true ||
+        typeof seconds !== "number" ||
+        !Number.isInteger(seconds) ||
+        seconds < 1 ||
+        seconds > 86400)
+        throw new Error("invalid-sleep-seconds");
+    return seconds;
+}

package/dist/src/steps/wait-for-decision.d.ts

@@ -0,0 +1,2 @@
+import type { DecisionResult, GateRequest } from "../step-bridge.ts";
+export declare function waitForDecision(request: GateRequest): Promise<DecisionResult>;

package/dist/src/steps/wait-for-decision.js

@@ -0,0 +1,71 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { createHook } from "workflow";
+import { openDecisionWait } from "./decision-gate.js";
+export async function waitForDecision(request) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const wait = await openDecisionWait(request);
+        if ("decision" in wait)
+            return wait;
+        const hook = __addDisposableResource(env_1, createHook({ token: wait.token }), false);
+        return await hook;
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}

package/dist/src/steps/wait-for-run.d.ts

@@ -0,0 +1,5 @@
+import { type RunWaitOutcome, type RunWaitRequest } from "../step-bridge.ts";
+export declare function waitForRun(request: RunWaitRequest): Promise<RunWaitOutcome>;
+export declare namespace waitForRun {
+    var maxRetries: number;
+}

package/dist/src/steps/wait-for-run.js

@@ -0,0 +1,9 @@
+import { isStepBridge, stepBridgeKey, } from "../step-bridge.js";
+export async function waitForRun(request) {
+    "use step";
+    const bridge = Reflect.get(globalThis, Symbol.for(stepBridgeKey));
+    if (!isStepBridge(bridge) || bridge.waitForRun === undefined)
+        throw new Error("cloving-host-unavailable");
+    return await bridge.waitForRun(request);
+}
+waitForRun.maxRetries = 86401;

package/dist/src/storage/decision-snapshots.d.ts

@@ -12,6 +12,7 @@ export interface DecidedSnapshot extends DomainSnapshot, DecisionRows {
 export interface CurrentSnapshot extends DecidedSnapshot {
     readonly effects: EffectRows;
 }
+export declare function loadOperationSnapshot(connection: SqlConnection): Promise<Pick<ProjectionSnapshot, "outbox" | "deliveries">>;
 export declare function loadProjections(connection: SqlConnection): Promise<ProjectionSnapshot>;
 export declare function loadDecided(connection: SqlConnection): Promise<DecidedSnapshot>;
 export declare function loadCurrent(connection: SqlConnection): Promise<CurrentSnapshot>;

package/dist/src/storage/decision-snapshots.js

@@ -1,6 +1,12 @@
 import { loadDecisions, loadDocuments, } from "./decision-rows.js";
-import { latestSequence, loadAttempts, loadSnapshot, projectionRows, text, } from "./domain-rows.js";
+import { latestSequence, loadAttempts, loadSnapshot, outboxRow, projectionRows, text, } from "./domain-rows.js";
 import { loadEffects } from "./effect-rows.js";
+export async function loadOperationSnapshot(connection) {
+    return {
+        outbox: (await connection.all("SELECT operation_id, kind, run_id, created_sequence, released_sequence FROM outbox ORDER BY created_sequence, rowid")).map(outboxRow),
+        deliveries: await loadAttempts(connection),
+    };
+}
 export async function loadProjections(connection) {
     return {
         ...(await projectionRows(connection)),

package/dist/src/submission.d.ts

@@ -5,6 +5,9 @@ export type SubmissionField = {
 } | {
     readonly type: "boolean";
     readonly optional?: boolean;
+} | {
+    readonly type: "ticket";
+    readonly optional?: boolean;
 } | {
     readonly type: "integer";
     readonly optional?: boolean;
@@ -15,6 +18,7 @@ export interface SubmissionContract {
     readonly maximumBytes: number;
     readonly fields: Readonly<Record<string, "string" | SubmissionField>>;
 }
+export declare function hasTicketField(contract: SubmissionContract | undefined): boolean;
 export type SubmissionCheck = {
     readonly kind: "valid";
     readonly normalized: string;

package/dist/src/submission.js

@@ -1,4 +1,8 @@
 import { record } from "./protocol.js";
+export function hasTicketField(contract) {
+    const rule = contract?.fields["ticket"];
+    return rule !== undefined && rule !== "string" && rule.type === "ticket";
+}
 function rejected(code, detail) {
     return { kind: "rejected", code, detail };
 }
@@ -14,11 +18,11 @@ function invalidField(contract, submission) {
     return Object.entries(contract.fields).find(([key, rule]) => {
         if (rule !== "string" && rule.optional && !Object.hasOwn(submission, key))
             return false;
-        return !validValue(rule, submission[key]);
+        return !validValue(rule === "string" ? { type: "string" } : rule, submission[key]);
     })?.[0];
 }
 function validValue(rule, value) {
-    if (rule === "string" || rule.type === "string")
+    if (rule.type === "string" || rule.type === "ticket")
         return typeof value === "string" && value.trim().length > 0;
     if (rule.type === "boolean")
         return typeof value === "boolean";

package/dist/src/testing.d.ts

@@ -0,0 +1,29 @@
+import { type HandoffValue, type ProtectedResult, type GateResult, type DecisionResult, type RunWaitOutcome, type ProtectedRequest, type GateRequest, type HandoffRequest, type RunWaitRequest } from "./step-bridge.ts";
+export interface StepScenario {
+    readonly turn?: ProtectedResult;
+    readonly effects?: Readonly<Record<string, readonly ProtectedResult[]>>;
+    readonly gate?: GateResult;
+    readonly waits?: readonly RunWaitOutcome[];
+    readonly decisions?: readonly DecisionResult[];
+    readonly effectLimit?: number;
+}
+export interface WorkflowScenario extends StepScenario {
+    readonly workflow: string;
+    readonly exportName: string;
+    readonly input: HandoffValue;
+    readonly decision?: HandoffValue;
+}
+export type ScenarioRequest = readonly ["effect", ProtectedRequest] | readonly ["gate", GateRequest] | readonly ["waitForDecision", GateRequest] | readonly ["handoff", HandoffRequest] | readonly ["waitForRun", RunWaitRequest] | readonly ["sleep", {
+    readonly seconds: number;
+}];
+export interface ScenarioResult {
+    readonly spent?: number;
+    readonly outcome: unknown;
+    readonly requests: readonly ScenarioRequest[];
+}
+export declare function fakeStepBridge(scenario: StepScenario): {
+    requests: ScenarioRequest[];
+    readonly spent: number;
+    [Symbol.dispose](): void;
+};
+export declare function runScenario(scenario: WorkflowScenario): Promise<ScenarioResult>;