cloving 1.2.0 → 1.4.0

package/dist/src/report.js

@@ -0,0 +1,234 @@
+import { reportQualityMetrics, } from "./report-quality.js";
+import { reportMetric, outsideReportBand, } from "./report-statistics.js";
+import { reportOperatorMetrics } from "./report-operator.js";
+import { reportCiMetrics } from "./report-ci.js";
+import { reportEffectData } from "./report-effects.js";
+import { reportFlowMetrics } from "./report-flow.js";
+import { reportOutcomes } from "./report-flow-types.js";
+export { reportOutcomes, } from "./report-flow-types.js";
+function outcomeMetrics(input, window) {
+    return Object.fromEntries(reportOutcomes.map((outcome) => {
+        const data = input.completions === null
+            ? null
+            : input.completions
+                .filter((event) => event.outcome === outcome)
+                .map((event) => ({
+                at: event.at,
+                value: 1,
+                evidence: { runId: event.runId, sequence: event.sequence },
+            }));
+        return [
+            `runs.${outcome}`,
+            reportMetric({ data, window, aggregation: "count" }),
+        ];
+    }));
+}
+function effectMetrics(input, window) {
+    const data = reportEffectData(input.effects ?? null);
+    const metrics = {
+        "fixRounds.medianPerMergedPullRequest": reportMetric({
+            data: data.fixRounds,
+            window,
+            aggregation: "median",
+        }),
+    };
+    for (const phase of ["workerTurn", "codeReview", "merge"])
+        metrics[`phases.${phase}.medianMinutes`] = reportMetric({
+            data: data[phase],
+            window,
+            aggregation: "median",
+        });
+    return metrics;
+}
+function githubMetrics(input, window) {
+    const observed = githubWindow(input, window);
+    return {
+        "leadTime.medianHours": reportMetric({
+            data: input.github?.leadTimes ?? null,
+            window: observed,
+            aggregation: "median",
+        }),
+        "tickets.completed": reportMetric({
+            data: input.github?.issues ?? null,
+            window: observed,
+            aggregation: "count",
+        }),
+        "pullRequests.merged": reportMetric({
+            data: input.github?.pulls ?? null,
+            window: observed,
+            aggregation: "count",
+        }),
+    };
+}
+function githubWindow(input, window) {
+    return { ...window, observedSince: input.github?.observedSince ?? null };
+}
+function ticketCostMetric(input, window) {
+    const costs = reportRunCosts((input.completions ?? []).filter((event) => event.at < window.end), input.costs ?? []);
+    const tickets = completedCosts((input.github?.issues ?? []).filter((issue) => issue.at < window.end), costs);
+    const metric = reportMetric({
+        data: input.completions === null || input.github?.issues == null
+            ? null
+            : tickets.map((ticket) => ({
+                at: ticket.closedAt,
+                value: ticket.costUsd,
+                evidence: ticket.evidence,
+            })),
+        window: {
+            ...window,
+            observedSince: commonHistory(window.observedSince, input.github?.observedSince ?? null),
+        },
+        aggregation: "median",
+    });
+    const completedTicketCosts = tickets
+        .filter((ticket) => ticket.closedAt >= window.start && ticket.closedAt < window.end)
+        .map((ticket) => ({
+        ...ticket,
+        ...costHistory(ticket.costUsd, metric.baseline),
+    }));
+    return { metric, completedTicketCosts };
+}
+function costHistory(cost, baseline) {
+    return {
+        baseline,
+        ...(outsideReportBand(cost, baseline.band) ? { mark: "outside" } : {}),
+    };
+}
+function metricCollection(input, window) {
+    const costs = reportRunCosts(input.completions ?? [], input.costs ?? []);
+    const tickets = ticketCostMetric(input, window);
+    const costMetric = reportMetric({
+        data: input.completions === null
+            ? null
+            : costs.map((cost) => ({
+                at: cost.completedAt,
+                value: cost.costUsd,
+                evidence: cost.evidence,
+            })),
+        window,
+        aggregation: "median",
+    });
+    const metrics = {
+        ...outcomeMetrics(input, window),
+        ...reportFlowMetrics({
+            flow: input.flow,
+            completions: input.completions,
+            ready: {
+                tickets: input.github?.ready ?? null,
+                observedSince: input.github?.observedSince ?? null,
+            },
+        }, window),
+        ...effectMetrics(input, window),
+        ...githubMetrics(input, window),
+        "cost.medianRunUsd": costMetric,
+        "cost.medianCompletedTicketUsd": tickets.metric,
+    };
+    const runCosts = costs
+        .filter((cost) => cost.completedAt >= window.start && cost.completedAt < window.end)
+        .map((cost) => ({
+        ...cost,
+        ...costHistory(cost.costUsd, costMetric.baseline),
+    }));
+    return {
+        metrics,
+        runCosts,
+        completedTicketCosts: tickets.completedTicketCosts,
+    };
+}
+function operatorMetrics(input, window) {
+    return reportOperatorMetrics({
+        effects: input.effects ?? null,
+        pulls: input.github?.pulls ?? null,
+        labels: input.github?.labels ?? null,
+    }, {
+        ...window,
+        observedSince: commonHistory(window.observedSince, input.github?.observedSince ?? null),
+    });
+}
+export function loopReport(input) {
+    const end = input.now;
+    const start = end - input.since * 3_600_000;
+    const window = { start, end, observedSince: input.observedSince ?? null };
+    return {
+        schemaVersion: 1,
+        kind: "loop-report",
+        window: { start, end, hours: input.since },
+        semantics: {
+            tickets: "closed-completed-in-window",
+            flowLanes: "current-queue-workflow-and-lane-setting",
+            flowTickets: "ready-label-intervals-and-current-ticket-body-dependency-close-times",
+            flowIdle: "elapsed-hours-with-spare-capacity-and-at-least-one-eligible-ticket",
+            flowWait: "sum-of-ticket-hours-by-dependency-or-full-lanes",
+            flowStreak: "terminal-time-then-sequence;current-carries-history;longest-counts-window-ends",
+            operatorLabels: "time-match-within-2-minutes-for-same-issue",
+            costs: "lifetime-turn-cost-attributed-at-run-end",
+        },
+        ...metricCollection(input, window),
+        sources: {
+            daemon: {
+                status: input.completions === null ? "unavailable" : "available",
+            },
+            github: input.github?.sources ?? {
+                issues: { status: "unavailable" },
+                pulls: { status: "unavailable" },
+                history: { status: "unavailable" },
+            },
+        },
+        quality: reportQualityMetrics({
+            ...input.github,
+            effects: input.effects ?? null,
+            daemonObservedSince: input.observedSince ?? null,
+        }, githubWindow(input, window)),
+        ci: reportCiMetrics(input.github?.ciUsage ?? undefined, githubWindow(input, window)),
+        operator: operatorMetrics(input, window),
+        coverage: {},
+    };
+}
+export function reportRunCosts(completions, costs) {
+    const byRun = new Map();
+    for (const cost of costs)
+        if (!byRun.has(cost.runId))
+            byRun.set(cost.runId, cost);
+    return completions.map((event) => {
+        const cost = byRun.get(event.runId);
+        const turns = cost?.turns ?? null;
+        const known = turns !== null && turns.every((turn) => turn.costUsd !== null);
+        const total = known
+            ? turns.reduce((sum, turn) => sum + (turn.costUsd ?? 0), 0)
+            : null;
+        return {
+            runId: event.runId,
+            ticketId: cost?.ticketId,
+            outcome: event.outcome,
+            completedAt: event.at,
+            costUsd: total !== null && Number.isFinite(total) ? total : null,
+            turns,
+            evidence: { runId: event.runId, sequence: event.sequence },
+        };
+    });
+}
+function commonHistory(daemon, github) {
+    return daemon === null || github === null ? null : Math.max(daemon, github);
+}
+function completedCosts(completed, costs) {
+    const issues = new Map(completed
+        .toSorted((left, right) => left.at - right.at)
+        .map((issue) => [issue.evidence["issue"], issue]));
+    return [...issues.values()].map((issue) => {
+        const number = issue.evidence["issue"];
+        const runs = costs.filter((cost) => cost.ticketId === String(number));
+        const unknown = costs.some((cost) => cost.ticketId === undefined) ||
+            runs.length === 0 ||
+            runs.some((run) => run.costUsd === null);
+        const total = unknown
+            ? null
+            : runs.reduce((sum, run) => sum + (run.costUsd ?? 0), 0);
+        return {
+            issue: number,
+            closedAt: issue.at,
+            costUsd: total !== null && Number.isFinite(total) ? total : null,
+            runs,
+            evidence: { issue: number, runIds: runs.map((run) => run.runId) },
+        };
+    });
+}

package/dist/src/repository-identity.d.ts

@@ -0,0 +1,4 @@
+export declare function repositoryFileName(identity: {
+    readonly name: string;
+    readonly sha256: string;
+}): string;

package/dist/src/repository-identity.js

@@ -0,0 +1,4 @@
+export function repositoryFileName(identity) {
+    const name = identity.name.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 24);
+    return `${name}-${identity.sha256.slice(0, 8)}`;
+}

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

@@ -0,0 +1,41 @@
+export interface CommitReviewSubject {
+    readonly commit: string;
+    readonly target: string;
+    readonly number?: number;
+}
+export interface DraftReviewSubject {
+    readonly draft: string;
+    readonly commit?: string;
+}
+export type ReviewSubject = CommitReviewSubject | DraftReviewSubject;
+export type Reviewer = {
+    readonly kind: "greptile";
+} | {
+    readonly kind: "turn";
+    readonly profile: string;
+};
+export interface ReviewResult {
+    readonly accepted: boolean;
+    readonly feedback: string;
+    readonly commit: string | null;
+    readonly subjectDigest: string;
+}
+export declare function reviewSubjectText(subject: ReviewSubject): string;
+export declare function commitId(value: unknown): value is string;
+export interface ReviewSnapshot {
+    readonly commit: string | null;
+    readonly subjectDigest: string;
+    readonly prompt: string;
+}
+export type ReviewVerdict = "accept" | "change";
+export declare function reviewReport(text: string): {
+    readonly reviewVerdict: ReviewVerdict | null;
+    readonly feedback: string;
+};
+export declare function reviewReportStream(limit: number): {
+    write: (chunk: string) => void;
+    result: () => {
+        reviewVerdict: ReviewVerdict | null;
+        feedback: string;
+    };
+};

package/dist/src/review-subject.js

@@ -0,0 +1,91 @@
+import { record } from "./protocol.js";
+export function reviewSubjectText(subject) {
+    if (record(subject) === undefined)
+        throw new Error("invalid-review-subject");
+    if ("draft" in subject)
+        return draftReviewText(subject);
+    if (!commitId(subject.commit) ||
+        typeof subject.target !== "string" ||
+        subject.target.trim() === "")
+        throw new Error("invalid-review-subject");
+    const identity = [
+        "cloving-review-subject",
+        1,
+        "commit",
+        subject.target,
+        subject.commit,
+    ];
+    if (subject.number !== undefined)
+        identity.push(subject.number);
+    return JSON.stringify(identity);
+}
+function draftReviewText(subject) {
+    if (typeof subject.draft !== "string" ||
+        subject.draft.trim() === "" ||
+        (subject.commit !== undefined && !commitId(subject.commit)))
+        throw new Error("invalid-review-subject");
+    return JSON.stringify([
+        "cloving-review-subject",
+        1,
+        "draft",
+        subject.commit ?? null,
+        subject.draft,
+    ]);
+}
+export function commitId(value) {
+    return (typeof value === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(value));
+}
+export function reviewReport(text) {
+    const trimmed = text.trimEnd();
+    const start = trimmed.lastIndexOf("\n") + 1;
+    const line = trimmed.slice(start);
+    const verdict = line.slice("Review verdict: ".length);
+    if (!line.startsWith("Review verdict: ") ||
+        (verdict !== "accept" && verdict !== "change"))
+        return { reviewVerdict: null, feedback: text };
+    return {
+        reviewVerdict: verdict,
+        feedback: trimmed.slice(0, start).trimEnd(),
+    };
+}
+export function reviewReportStream(limit) {
+    let text = "";
+    let trailing = "";
+    let prefix = "";
+    let length = 0;
+    let contentLength = 0;
+    let verdict = null;
+    const finish = () => {
+        if (contentLength > 0)
+            verdict =
+                contentLength > 24
+                    ? null
+                    : reviewReport(prefix.slice(0, contentLength)).reviewVerdict;
+        prefix = "";
+        length = 0;
+        contentLength = 0;
+    };
+    return {
+        write: (chunk) => {
+            const trimmed = chunk.trimEnd();
+            if (trimmed === "")
+                trailing = (trailing + chunk).slice(-limit);
+            if (trimmed !== "") {
+                text = (text + trailing + trimmed).slice(-limit);
+                trailing = chunk.slice(trimmed.length).slice(-limit);
+            }
+            for (const [index, part] of chunk.split("\n").entries()) {
+                if (index > 0)
+                    finish();
+                if (part.trimEnd() !== "")
+                    contentLength = Math.min(25, length + part.trimEnd().length);
+                prefix = (prefix + part).slice(0, 24);
+                length = Math.min(25, length + part.length);
+            }
+        },
+        result: () => {
+            finish();
+            return { reviewVerdict: verdict, feedback: reviewReport(text).feedback };
+        },
+    };
+}

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

@@ -0,0 +1,23 @@
+import type { RunWaitOutcome, RunWaitRequest } from "./step-bridge.ts";
+export interface RunWaitTarget {
+    readonly parentRunId: string | null;
+    readonly status: string;
+    readonly endedAt: number | null;
+    readonly outcome: RunWaitOutcome | null;
+}
+export type RunWaitResult = {
+    readonly kind: "waiting";
+    readonly deadline: number;
+} | {
+    readonly kind: "completed";
+    readonly outcome: RunWaitOutcome;
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+};
+export declare function runWaitResult(request: RunWaitRequest, context: {
+    readonly callerRunId: string;
+    readonly startedAt: number;
+    readonly now: number;
+    readonly target: RunWaitTarget | undefined;
+}): RunWaitResult;

package/dist/src/run-wait.js

@@ -0,0 +1,20 @@
+function validSeconds(seconds) {
+    return Number.isInteger(seconds) && seconds >= 1 && seconds <= 86400;
+}
+export function runWaitResult(request, context) {
+    const { target, callerRunId, startedAt, now } = context;
+    const seconds = request.maximumWaitSeconds;
+    if (!validSeconds(seconds) ||
+        target?.parentRunId !== callerRunId ||
+        request.runId === callerRunId)
+        return { kind: "refused", reason: "run-wait-refused" };
+    const deadline = startedAt + seconds * 1000;
+    if (["completed", "failed", "cancelled"].includes(target.status) &&
+        target.outcome !== null &&
+        target.endedAt !== null &&
+        target.endedAt <= deadline)
+        return { kind: "completed", outcome: target.outcome };
+    if (now >= deadline)
+        return { kind: "refused", reason: "run-wait-timeout" };
+    return { kind: "waiting", deadline };
+}

package/dist/src/schedule-progress.d.ts

@@ -0,0 +1,33 @@
+import { type Fields, type Reply } from "./protocol.ts";
+export type SchedulePort = (parameters: Fields) => Promise<Reply>;
+export type PendingSlot = {
+    readonly kind: "run";
+    readonly input: Fields;
+} | {
+    readonly kind: "skip";
+    readonly runId: string;
+};
+export interface ScheduleStop {
+    readonly stoppedAt: number;
+    readonly stoppedSlot: number;
+    readonly failedRunIds: readonly string[];
+}
+export interface ScheduleProgress {
+    readonly everySeconds: number;
+    readonly nextAt: number;
+    readonly lastSlot: number;
+    readonly state: "active" | "paused" | "stopped";
+    readonly failuresInRow: number;
+    readonly failedRunIds: readonly string[];
+    readonly stoppedAt?: number;
+    readonly stoppedSlot?: number;
+    readonly stops?: readonly ScheduleStop[];
+    readonly activeCommandId?: string;
+    readonly pending?: PendingSlot;
+}
+export declare function scheduleStops(progress: ScheduleProgress): readonly ScheduleStop[];
+export declare function finishedScheduleRun(progress: ScheduleProgress, run: {
+    readonly runId: string;
+    readonly status: Fields;
+    readonly now: number;
+}): ScheduleProgress;

package/dist/src/schedule-progress.js

@@ -0,0 +1,45 @@
+import { record } from "./protocol.js";
+export function scheduleStops(progress) {
+    if (progress.stops !== undefined)
+        return progress.stops;
+    if (progress.state !== "stopped" ||
+        progress.stoppedAt === undefined ||
+        progress.stoppedSlot === undefined)
+        return [];
+    return [
+        {
+            stoppedAt: progress.stoppedAt,
+            stoppedSlot: progress.stoppedSlot,
+            failedRunIds: progress.failedRunIds,
+        },
+    ];
+}
+export function finishedScheduleRun(progress, run) {
+    const rest = { ...progress };
+    delete rest.activeCommandId;
+    const state = run.status["state"];
+    if (state === "cancelled")
+        return rest;
+    const failed = state === "failed" || record(run.status["outcome"])?.["kind"] === "blocked";
+    if (!failed)
+        return { ...rest, failuresInRow: 0, failedRunIds: [] };
+    const failedRunIds = [...progress.failedRunIds, run.runId];
+    const failuresInRow = failedRunIds.length;
+    const stop = {
+        stoppedAt: run.now,
+        stoppedSlot: progress.lastSlot,
+        failedRunIds,
+    };
+    return {
+        ...rest,
+        failedRunIds,
+        failuresInRow,
+        ...(failuresInRow < 3
+            ? {}
+            : {
+                state: "stopped",
+                ...stop,
+                stops: [...scheduleStops(progress), stop],
+            }),
+    };
+}

package/dist/src/service/active-tickets.d.ts

@@ -0,0 +1,4 @@
+import { type Fields } from "../protocol.ts";
+import type { ServiceContext } from "./replies.ts";
+export declare function activeWorkflow(context: ServiceContext, workflowId: string): Promise<Fields[]>;
+export declare function queueOverview(context: ServiceContext): Promise<Fields>;

package/dist/src/service/active-tickets.js

@@ -0,0 +1,49 @@
+import { record } from "../protocol.js";
+import { queueRun, queueSpend } from "./queue-spend.js";
+export 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) => !["completed", "failed", "cancelled"].includes(run.status));
+    const own = runs.filter((run) => workflows[run.runId] === workflowId);
+    const queued = context.registry.byId(workflowId)?.queue === true ||
+        (await Promise.all(own.map((run) => queueRun(context, run.runId)))).includes(true);
+    const active = await Promise.all(runs.map(async (run) => {
+        if (workflows[run.runId] !== workflowId &&
+            !(queued && (await queueRun(context, run.runId))))
+            return undefined;
+        return storedTicket(context, state.details[run.runId]?.input);
+    }));
+    return active.filter((input) => input !== undefined);
+}
+export async function queueOverview(context) {
+    const workflow = context.registry.workflowIds
+        .map((id) => context.registry.byId(id))
+        .find((workflow) => workflow?.admission !== undefined);
+    if (workflow?.admission === undefined)
+        return {};
+    const active = await activeWorkflow(context, workflow.workflowId);
+    return {
+        queue: {
+            workflowId: workflow.workflowId,
+            ...(await queueSpend(context)),
+            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?.() ?? []),
+            ],
+        },
+    };
+}
+async function storedTicket(context, digest) {
+    const text = digest
+        ? await context.authority.queries.document(digest)
+        : undefined;
+    const input = record(JSON.parse(text ?? "null")) ?? {};
+    const ticket = record(record(input["input"])?.["ticket"]);
+    return ticket === undefined
+        ? input
+        : { ...input, ticketId: ticket["id"], ticket: ticket["text"] };
+}

package/dist/src/service/command-effects.d.ts

@@ -0,0 +1,4 @@
+import type { ServiceContext } from "./replies.ts";
+import type { Fields } from "../protocol.ts";
+import type { OperationView } from "../broker/actor/authority.ts";
+export declare function commandFields(context: ServiceContext, operations: readonly OperationView[]): Promise<Fields>;

package/dist/src/service/command-effects.js

@@ -0,0 +1,16 @@
+export async function commandFields(context, operations) {
+    const effects = operations
+        .filter((operation) => operation.capability === "command")
+        .map((operation) => ({
+        operationId: operation.operationId,
+        name: operation.method.slice(4),
+        state: operation.status,
+        exitCode: null,
+        durationMilliseconds: null,
+    }));
+    if (effects.length === 0)
+        return {};
+    return {
+        commandEffects: (await context.commandEffects?.(effects)) ?? effects,
+    };
+}

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

@@ -0,0 +1,34 @@
+import { type CommandWaitView } from "../authority/command-wait-view.ts";
+import { type CommandWaitState, type CommandWaitsState } from "../authority/command-waits.ts";
+import type { Authority, StoreReceipt } from "../broker/actor/authority.ts";
+import type { Gateway } from "./gateway.ts";
+export declare function expireCommandWaits(parts: {
+    readonly waits: CommandWaitsState;
+    readonly gateway: Gateway;
+    readonly now: string;
+}): Promise<void>;
+interface WaitName {
+    readonly runId: string;
+    readonly name: string;
+}
+interface WaitCall extends WaitName {
+    readonly commandId: string;
+}
+export interface CommandWaitPort {
+    readonly open: (wait: WaitCall & {
+        readonly input: string;
+    }) => Promise<StoreReceipt>;
+    readonly check: (wait: WaitCall) => Promise<StoreReceipt>;
+    readonly read: (wait: WaitName) => Promise<CommandWaitState | undefined>;
+}
+export declare function commandWaitPort(parts: {
+    readonly authority: Authority;
+    readonly gateway: Gateway;
+}): CommandWaitPort;
+export declare function commandWaitDisplay(input: {
+    readonly authority: Authority;
+    readonly runId: string;
+    readonly waits: CommandWaitsState | undefined;
+    readonly now: string;
+}): Promise<readonly CommandWaitView[]>;
+export {};