cloving 1.2.0 → 1.3.0

package/dist/src/service/run-metadata.js

@@ -0,0 +1,53 @@
+import { issueIdentity } from "../issue-identity.js";
+import { record } from "../protocol.js";
+export async function outcomeOf(context, view) {
+    if (view.state !== "completed")
+        return null;
+    const event = await context.authority.queries.latestCompletion({
+        runId: view.runId,
+        atOrBefore: view.latestSequence,
+    });
+    const payload = event?.payload ?? {};
+    const kind = payload["outcome"];
+    if (kind === undefined)
+        return null;
+    const { ticketStatus, promotionId, outcomeReason, issueUpdate } = payload;
+    return {
+        kind,
+        reason: outcomeReason ?? null,
+        ...(promotionId === undefined ? {} : { promotionId }),
+        ...(ticketStatus === undefined ? {} : { ticketStatus }),
+        ...(issueUpdate === "failed" ? { issueUpdate } : {}),
+    };
+}
+function titleOf(input, workflowId) {
+    const ticket = input?.["ticket"];
+    if (typeof ticket !== "string")
+        return null;
+    const fallback = `Cloving task ${String(input?.["cycleId"])}`;
+    const lines = ticket.split("\n");
+    if (workflowId === "develop-prompt") {
+        const first = lines.find((line) => /\S/.test(line));
+        return first === undefined
+            ? fallback
+            : first.replace(/^# /, "").trim().slice(0, 200);
+    }
+    const first = lines[0] ?? "";
+    return first.startsWith("# ")
+        ? first.slice(2).trim().slice(0, 200)
+        : fallback;
+}
+export async function metadataOf(context, source) {
+    const document = source.digest
+        ? await context.authority.queries.document(source.digest)
+        : undefined;
+    const input = record(JSON.parse(document ?? "null"));
+    const ticketId = input?.["ticketId"];
+    return {
+        ticketId: typeof ticketId === "string" && ticketId !== "" ? ticketId : null,
+        title: titleOf(input, source.workflowId),
+        ...(source.workflowId === "develop-issue"
+            ? { issueIdentity: issueIdentity(input?.["ticket"]) }
+            : {}),
+    };
+}

package/dist/src/service/run-waits.d.ts

@@ -0,0 +1,3 @@
+import type { Authority } from "../broker/actor/authority.ts";
+import type { RunWaitTarget } from "../run-wait.ts";
+export declare function runWaitTarget(authority: Authority, runId: string): Promise<RunWaitTarget | undefined>;

package/dist/src/service/run-waits.js

@@ -0,0 +1,41 @@
+function outcomeOf(event, status) {
+    if (event === undefined)
+        return null;
+    return {
+        kind: event.payload["outcome"] ?? status,
+        reason: event.payload["outcomeReason"] ?? null,
+        promotionId: event.payload["promotionId"] ?? null,
+    };
+}
+async function settled(authority, run) {
+    if (run.status !== "cancelled")
+        return ["completed", "failed"].includes(run.status);
+    const closure = await authority.effects.closure(run.runId);
+    return (!closure.open &&
+        closure.closure === "cancelled" &&
+        closure.unresolved.length === 0);
+}
+export async function runWaitTarget(authority, runId) {
+    const run = await authority.queries.run(runId);
+    const origin = (await authority.queries.runOrigins())[runId];
+    if (run === undefined || origin === undefined)
+        return undefined;
+    const terminal = await settled(authority, run);
+    const event = terminal
+        ? await authority.queries.latestCompletion({
+            runId,
+            atOrBefore: run.sequence,
+            terminal: true,
+        })
+        : undefined;
+    const endedAt = event === undefined ? null : Date.parse(event.recordedAt);
+    const stoppedAt = run.status === "cancelled" && terminal
+        ? await authority.effects.settledAt(runId)
+        : null;
+    return {
+        parentRunId: origin.parentRunId,
+        status: run.status,
+        endedAt: endedAt === null ? null : Math.max(endedAt, stoppedAt ?? endedAt),
+        outcome: outcomeOf(event, run.status),
+    };
+}

package/dist/src/service/service.d.ts

@@ -1,7 +1,10 @@
 import { type Authority, type AuthorityTiming, type Delivery, type EffectSettings, type Refusal } from "../broker/actor/authority.ts";
 import { type WorkflowRefusal } from "../workflow-refusals.ts";
-import { type WorkflowRegistration } from "./registry.ts";
+import { type Registry, type WorkflowRegistration, type WorkflowBundleStore } from "./registry.ts";
+import { type ServiceContext } from "./replies.ts";
 import { type WorkerPort } from "./worker-port.ts";
+import type { RunWaitTarget } from "../run-wait.ts";
+import type { CommandEffects } from "../command-settings.ts";
 export type { WorkflowRegistration } from "./registry.ts";
 export type { EffectReply, EffectReport, EffectRequest, WorkerPort, } from "./worker-port.ts";
 export interface ServiceTiming {
@@ -24,22 +27,35 @@ export interface ServiceHost {
     readonly reports?: () => readonly unknown[];
 }
 export interface HostPorts {
+    readonly runWait?: {
+        readonly target: (runId: string) => Promise<RunWaitTarget | undefined>;
+        readonly observe: WorkerPort["observe"];
+    };
     readonly state: Authority["state"];
     readonly submit: WorkerPort["submit"];
     readonly input: (runId: string) => Promise<string | undefined>;
     readonly document: (digest: string) => Promise<string | undefined>;
-    readonly workflowId: (runId: string) => Promise<string | undefined>;
+    readonly workflow: {
+        readonly id: (runId: string) => Promise<string | undefined>;
+        readonly manifest: Authority["queries"]["manifest"];
+        readonly available: (runId: string, workflowId?: string) => Promise<boolean>;
+    };
     readonly requestEffect: WorkerPort["requestEffect"];
     readonly operation: Authority["effects"]["operation"];
+    readonly operations: Authority["effects"]["operations"];
     readonly reportEffect: WorkerPort["reportEffect"];
     readonly openGate: WorkerPort["openGate"];
     readonly registerWait: WorkerPort["registerWait"];
 }
 export interface ServiceOptions {
+    readonly workerHarness?: ServiceContext["workerHarness"];
+    readonly commandEffects?: CommandEffects;
     readonly stateDirectory: string;
     readonly runtimeDirectory: string;
     readonly workflows: readonly WorkflowRegistration[];
     readonly retainedWorkflows?: readonly WorkflowRegistration[];
+    readonly workflowBundles?: WorkflowBundleStore;
+    readonly retainedWorkflow?: Registry["available"];
     readonly workflowRefusals?: readonly WorkflowRefusal[];
     readonly delivery: Delivery;
     readonly host?: (ports: HostPorts) => Promise<ServiceHost>;

package/dist/src/service/service.js

@@ -2,18 +2,19 @@ import { lstat, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { authorityTiming, openAuthority, } from "../broker/actor/authority.js";
 import { socketAddress } from "../broker/socket-address.js";
-import { workflowRefusals, } from "../workflow-refusals.js";
+import {} from "../workflow-refusals.js";
 import { changeSignal } from "./changes.js";
 import { decision, questions } from "./decision-handler.js";
 import { events } from "./event-handler.js";
 import { expiryScan } from "./expiry.js";
 import { commandGateway, workerCommandBound } from "./gateway.js";
 import { workflowRegistry, } from "./registry.js";
-import { failed } from "./replies.js";
+import { failed, queryMetadata } from "./replies.js";
 import { runCommand, status } from "./run-handlers.js";
 import { submissionHandler } from "./submission-handler.js";
 import { connectionLimits, listen, reachable } from "./transport.js";
 import { workerPort } from "./worker-port.js";
+import { runWaitTarget } from "./run-waits.js";
 export const serviceTiming = {
     authority: authorityTiming,
     expiryScanMilliseconds: 1_000,
@@ -88,7 +89,7 @@ async function started(authority, setup) {
         handle: dispatcher({
             authority,
             registry,
-            workflowRefusals: workflowRefusals(options.workflowRefusals),
+            ...queryMetadata(options),
             gateway,
             clock,
             changed: changes.next,
@@ -135,7 +136,7 @@ export async function startService(options) {
     if (typeof path !== "string")
         return path;
     const timing = options.timing ?? serviceTiming;
-    const registry = workflowRegistry(options.workflows, options.retainedWorkflows);
+    const registry = workflowRegistry(options.workflows, options);
     const opening = await openAuthority(options.stateDirectory, {
         delivery: options.delivery,
         timing: timing.authority,
@@ -148,7 +149,7 @@ export async function startService(options) {
     const { authority } = opening;
     const gateway = serviceGateway(authority, { options, registry });
     const worker = workerPort({ gateway, authority });
-    const host = await hosted(options, hostPorts(authority, worker));
+    const host = await hosted(options, hostPorts(authority, { worker, registry }));
     if (host.kind === "refused") {
         await authority.close();
         return host;
@@ -182,8 +183,13 @@ function serviceGateway(authority, parts) {
         pendingWorkerCommands: limits.pendingWorkerCommands,
     });
 }
-function hostPorts(authority, worker) {
+function hostPorts(authority, parts) {
+    const { worker, registry } = parts;
     return {
+        runWait: {
+            target: (runId) => runWaitTarget(authority, runId),
+            observe: worker.observe,
+        },
         state: authority.state,
         submit: worker.submit,
         input: async (runId) => {
@@ -198,7 +204,17 @@ function hostPorts(authority, worker) {
         openGate: worker.openGate,
         registerWait: worker.registerWait,
         operation: authority.effects.operation,
-        workflowId: async (runId) => (await authority.queries.workflowIds())[runId],
+        operations: authority.effects.operations,
+        workflow: {
+            id: async (runId) => (await authority.queries.workflowIds())[runId],
+            manifest: authority.queries.manifest,
+            available: async (runId, workflowId) => {
+                const manifest = await authority.queries.manifest(runId);
+                return (manifest !== undefined &&
+                    (workflowId === undefined || manifest.workflowId === workflowId) &&
+                    (await registry.available(manifest)) !== undefined);
+            },
+        },
     };
 }
 function message(error) {

package/dist/src/service/submission-handler.d.ts

@@ -1,5 +1,4 @@
 import { type Fields, type Reply } from "../protocol.ts";
 import { type ServiceContext } from "./replies.ts";
 export declare function runIdentity(commandId: string): string;
-export declare function queueOverview(context: ServiceContext): Promise<Fields>;
 export declare function submissionHandler(context: ServiceContext): (parameters: Fields) => Promise<Reply>;

package/dist/src/service/submission-handler.js

@@ -5,7 +5,8 @@ import { setTimeout as delay } from "node:timers/promises";
 import { isCommandId, isIdentifier as isWorkflowIdentifier, } from "../authority/commands.js";
 import { documentDigest } from "../broker/decision-restore.js";
 import { record } from "../protocol.js";
-import { checkResolution, checkSubmission, normalizedRequest, } from "../submission.js";
+import { checkResolution, checkSubmission, hasTicketField, normalizedRequest, } from "../submission.js";
+import { activeWorkflow } from "./active-tickets.js";
 import { committed, failed, invalidRequest, publicReceipt, rejection, result, } from "./replies.js";
 export function runIdentity(commandId) {
     return `run-${createHash("sha256").update(commandId).digest("hex").slice(0, 32)}`;
@@ -156,14 +157,15 @@ async function admit(context, admission) {
 }
 function admissionRefusal(workflow, request) {
     const { workflowId, commandId, submission, activeTickets } = request;
-    if (workflowId === "develop-issue" &&
+    const tickets = workflowId === "develop-issue" || hasTicketField(workflow.submission);
+    if (tickets &&
         typeof submission["ticket"] === "string" &&
         activeTickets.some((input) => input["ticketId"] === submission["ticket"]))
         return failed("ticket-active", {
             commandId,
             detail: "An active run already works on this ticket.",
         });
-    if (workflowId === "develop-issue" && submission["ticket"] !== "next")
+    if (tickets && submission["ticket"] !== "next")
         return undefined;
     return capacityRefusal(workflow, request);
 }
@@ -228,43 +230,13 @@ async function submitted(context, parameters) {
         activeTickets,
     });
 }
-async function activeWorkflow(context, workflowId) {
-    const workflows = await context.authority.queries.workflowIds();
-    const state = await context.authority.state();
-    const runs = Object.values(state.runs).filter((run) => workflows[run.runId] === workflowId &&
-        !["completed", "failed", "cancelled"].includes(run.status));
-    return Promise.all(runs.map(async (run) => {
-        const digest = state.details[run.runId]?.input;
-        const text = digest
-            ? await context.authority.queries.document(digest)
-            : undefined;
-        return record(JSON.parse(text ?? "null")) ?? {};
-    }));
-}
-export async function queueOverview(context) {
-    const workflow = context.registry.byId("develop-issue");
-    if (workflow?.admission === undefined)
-        return {};
-    const active = await activeWorkflow(context, "develop-issue");
-    return {
-        queue: {
-            lanes: workflow.admission === "when-idle" ? 1 : workflow.admission,
-            busy: active.length,
-            skipped: [
-                ...active.flatMap((input) => typeof input["ticketId"] === "string"
-                    ? [{ ticketId: input["ticketId"], reason: "ticket-active" }]
-                    : []),
-                ...(workflow.resolver.skippedTickets?.() ?? []),
-            ],
-        },
-    };
-}
 export function submissionHandler(context) {
     const pending = new Map();
     return (parameters) => {
         const keys = [`command:${String(parameters["commandId"])}`];
         const workflowId = String(parameters["workflowId"]);
         if (workflowId === "develop-issue" ||
+            hasTicketField(context.registry.byId(workflowId)?.submission) ||
             context.registry.byId(workflowId)?.admission !== undefined)
             keys.push(`workflow:${workflowId}`);
         const next = () => submitted(context, parameters);

package/dist/src/service/worker-port.d.ts

@@ -8,6 +8,7 @@ interface Revised extends Identified {
     readonly expectedRevision: number;
 }
 export interface GateOpening extends Revised {
+    readonly waitMode?: "hook";
     readonly gateId: string;
     readonly kind: "question" | "approval";
     readonly prompt: string;

package/dist/src/service/worker-totals.js

@@ -1,5 +1,5 @@
 import { record } from "../protocol.js";
-import { priceOf, usageOf, tokenCount, workerTotals, } from "../worker-usage.js";
+import { priceOf, usageOf, attemptsOf, workerTotals, } from "../worker-usage.js";
 function reportFields(text) {
     try {
         return record(JSON.parse(text ?? "null")) ?? {};
@@ -8,28 +8,6 @@ function reportFields(text) {
         return {};
     }
 }
-function attemptsOf(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    return value.flatMap((entry) => {
-        const fields = record(entry) ?? {};
-        const attempt = tokenCount(fields["attempt"]);
-        const model = fields["model"];
-        if (attempt === null ||
-            attempt === 0 ||
-            (model !== null && typeof model !== "string"))
-            return [];
-        return [
-            {
-                attempt,
-                model,
-                usage: usageOf(fields["usage"]),
-                costUsd: priceOf(fields["costUsd"]),
-                estimatedCostUsd: priceOf(fields["estimatedCostUsd"]),
-            },
-        ];
-    });
-}
 export async function usageTotals(context, runId) {
     const { effects, queries } = context.authority;
     const operations = (await effects.operations(runId)).filter((operation) => operation.capability === "claude" &&
@@ -40,7 +18,14 @@ export async function usageTotals(context, runId) {
             ? undefined
             : await queries.document(operation.result));
         const attempts = attemptsOf(report["attempts"]);
+        const model = report["model"];
+        const summary = report["summary"];
+        const harness = report["harness"] ??
+            (await context.workerHarness?.(operation.operationId));
         turns.push({
+            ...(typeof model === "string" ? { model } : {}),
+            ...(typeof summary === "string" ? { summary } : {}),
+            ...(typeof harness === "string" ? { harness } : {}),
             ...(attempts === undefined ? {} : { attempts }),
             operationId: operation.operationId,
             usage: usageOf(report["usage"]),

package/dist/src/step-bridge.d.ts

@@ -41,6 +41,13 @@ export interface GateRequest {
     readonly prompt: string;
     readonly expiresAt?: string;
 }
+export interface DecisionResult {
+    readonly decision: "approved" | "denied" | "answered" | "expired";
+    readonly answer: string | null;
+}
+export type DecisionWait = {
+    readonly token: string;
+} | DecisionResult;
 export type HandoffValue = string | number | boolean | null | readonly HandoffValue[] | {
     readonly [key: string]: HandoffValue;
 };
@@ -48,6 +55,20 @@ export interface HandoffRequest {
     readonly workflowId: string;
     readonly input: Readonly<Record<string, HandoffValue>>;
 }
+export interface RunWaitRequest {
+    readonly runId: string;
+    readonly maximumWaitSeconds: number;
+}
+export interface RunWaitOutcome {
+    readonly kind: string;
+    readonly reason: string | null;
+    readonly promotionId: string | null;
+}
+export interface CommandRequest {
+    readonly scope: ProtectedScope;
+    readonly name: string;
+    readonly input: HandoffValue;
+}
 export type GateResult = {
     readonly kind: "opened";
     readonly decisionId: string;
@@ -61,6 +82,8 @@ export type GateResult = {
 export interface StepBridge {
     readonly effect: (request: ProtectedRequest) => Promise<ProtectedResult>;
     readonly gate: (request: GateRequest) => Promise<GateResult>;
+    readonly waitForDecision?: (request: GateRequest) => Promise<DecisionWait>;
     readonly handoff?: (request: HandoffRequest) => Promise<ProtectedResult>;
+    readonly waitForRun?: (request: RunWaitRequest) => Promise<RunWaitOutcome>;
 }
 export declare function isStepBridge(value: unknown): value is StepBridge;

package/dist/src/steps/decision-gate.d.ts

@@ -1,2 +1,3 @@
-import { type GateRequest, type GateResult } from "../step-bridge.ts";
+import { type GateRequest, type GateResult, type DecisionWait } from "../step-bridge.ts";
 export declare function decisionGate(request: GateRequest): Promise<GateResult>;
+export declare function openDecisionWait(request: GateRequest): Promise<DecisionWait>;

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/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>;