@wardby/cli 0.5.3 → 0.7.0

package/dist/core/mark-ready.js

@@ -0,0 +1,152 @@
+import { lastPusher } from "./budget-stopped-head.js";
+import { pullRequestOutcome } from "./host-status.js";
+import { MERGE_ORDER_CHECK_NAME } from "./merge-order-check.js";
+const CI_GREEN = new Set(["passing", "none"]);
+/** How far up the run tree (Run.parentRunId) the opt-in may come from. */
+const MAX_ANCESTOR_HOPS = 10;
+const CODING_RUN_SELECT = {
+    runId: true,
+    repository: true,
+    rootCodingRunId: true,
+    markedReadyAt: true,
+    result: true,
+    run: { select: { agentId: true, parentRunId: true, status: true } },
+};
+const passed = (c) => c !== undefined && c.status === "completed" && c.conclusion === "success";
+export async function maybeMarkReady(deps, repository, prNumber, provider = "github") {
+    try {
+        const host = deps.hosts?.[provider];
+        if (!host?.pullRequestOrigin || !host.readOwnChecks || !host.readCi || !host.markReadyForReview)
+            return "off";
+        const links = await deps.db.agentRepository.findMany({
+            where: { provider, repository },
+            select: {
+                agentId: true,
+                access: true,
+                triggers: true,
+                checkName: true,
+                markReadyWhenPassing: true,
+                authorizedVia: true,
+            },
+        });
+        const optedIn = new Set(links
+            .filter((l) => l.access === "write" && l.authorizedVia !== null && l.markReadyWhenPassing)
+            .map((l) => l.agentId));
+        if (optedIn.size === 0)
+            return "off";
+        const reviewChecks = links
+            .filter((l) => l.access === "write" && l.authorizedVia !== null && l.triggers.includes("pull_request") && l.checkName)
+            .map((l) => l.checkName);
+        if (reviewChecks.length === 0)
+            return "not_ready";
+        // readOwnChecks reads at most 10 names; MERGE_ORDER_CHECK_NAME plus the reviewer
+        // check names must fit, or the merge-order check would silently be read as absent.
+        if (reviewChecks.length > 9)
+            return "not_ready";
+        const origin = await host.pullRequestOrigin(repository, prNumber);
+        if (origin.state !== "open" || origin.draft !== true || origin.isFork || !origin.markerRunId)
+            return "not_ready";
+        const marked = await deps.db.codingRun.findUnique({
+            where: { runId: origin.markerRunId },
+            select: CODING_RUN_SELECT,
+        });
+        if (!marked)
+            return "not_ready";
+        const root = marked.rootCodingRunId
+            ? await deps.db.codingRun.findUnique({ where: { runId: marked.rootCodingRunId }, select: CODING_RUN_SELECT })
+            : marked;
+        if (!root || root.repository.toLowerCase() !== repository.toLowerCase())
+            return "not_ready";
+        if (pullRequestOutcome(root.result)?.pullRequestNumber !== prNumber)
+            return "not_ready";
+        if (!(await optedInInRunTree(deps.db, root.run, optedIn)))
+            return "not_ready";
+        if (root.markedReadyAt)
+            return "skipped";
+        if (await lastPushStoppedAtBudget(deps.db, root, prNumber))
+            return "not_ready";
+        const checks = await host.readOwnChecks(repository, origin.headSha, [MERGE_ORDER_CHECK_NAME, ...reviewChecks]);
+        if (!reviewChecks.every((name) => passed(checks.get(name))))
+            return "not_ready";
+        const order = checks.get(MERGE_ORDER_CHECK_NAME);
+        if (order !== undefined && !passed(order))
+            return "not_ready";
+        const ci = await host.readCi(repository, origin.headSha);
+        if (!CI_GREEN.has(ci.state) || ci.truncated)
+            return "not_ready";
+        const claimedAt = new Date();
+        // CodingRun.updatedAt is @updatedAt, so this claim (and a release below) bumps it, which
+        // feeds the merge-order sweep's ordering. Harmless: the sweep re-derives state from the
+        // host each time, it doesn't rely on updatedAt being untouched by mark-ready.
+        const claim = await deps.db.codingRun.updateMany({
+            where: { runId: root.runId, markedReadyAt: null },
+            data: { markedReadyAt: claimedAt },
+        });
+        if (claim.count === 0)
+            return "skipped";
+        const release = () => deps.db.codingRun
+            .updateMany({ where: { runId: root.runId, markedReadyAt: claimedAt }, data: { markedReadyAt: null } })
+            .catch((err) => deps.log?.warn({ err, repository, prNumber }, "could not release the mark-ready claim"));
+        try {
+            const result = await host.markReadyForReview(repository, prNumber, origin.headSha, origin.markerRunId);
+            if (result === "marked") {
+                deps.log?.info({ repository, prNumber }, "marked the pull request ready for review");
+                return "marked";
+            }
+            await release();
+            return "skipped";
+        }
+        catch (err) {
+            await release();
+            throw err;
+        }
+    }
+    catch (err) {
+        deps.log?.warn({ err, repository, prNumber }, "could not mark the pull request ready for review");
+        return "failed";
+    }
+}
+/**
+ * Whether the last run that pushed to the pull request (the root, or a later continuation of it)
+ * stopped at its budget: its pushed changes are unfinished work, so the draft stays a draft. A
+ * continuation that finished the work makes it eligible again.
+ */
+async function lastPushStoppedAtBudget(db, root, prNumber) {
+    return (await lastPusher(db, root, prNumber)).status === "budget_exhausted";
+}
+/**
+ * True when the opener's agent, or an agent up its run tree (bounded, cycle-safe), is opted in.
+ * A coding run's parentRunId is set when a lead delegated to it.
+ */
+async function optedInInRunTree(db, opener, optedIn) {
+    if (optedIn.has(opener.agentId))
+        return true;
+    const seen = new Set();
+    let next = opener.parentRunId ?? null;
+    for (let hop = 0; next && hop < MAX_ANCESTOR_HOPS && !seen.has(next); hop++) {
+        seen.add(next);
+        const run = await db.run.findUnique({ where: { id: next }, select: { agentId: true, parentRunId: true } });
+        if (!run)
+            return false;
+        if (optedIn.has(run.agentId))
+            return true;
+        next = run.parentRunId;
+    }
+    return false;
+}
+/** After a reviewer run ends: evaluate the pull request it reviewed. Null when it reviewed none. */
+export async function markReadyAfterRun(deps, runId) {
+    try {
+        const row = await deps.db.runHostCheck.findUnique({
+            where: { runId },
+            select: { provider: true, repository: true, prNumber: true, verdict: true },
+        });
+        if (!row || row.prNumber === null || !row.verdict)
+            return null;
+        return await maybeMarkReady(deps, row.repository, row.prNumber, row.provider);
+    }
+    catch (err) {
+        deps.log?.warn({ err, runId }, "could not evaluate mark-ready after the run");
+        return "failed";
+    }
+}

package/dist/core/markdown-code.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GitHub-flavoured Markdown with its code removed, so a mention quoted in code
+ * (`` `@app` ``, a fenced or indented block) is documentation, not a request.
+ * Close to CommonMark, not a full parser: when in doubt it keeps text, so a
+ * real mention is never lost to an odd construct.
+ */
+/** `markdown` without its code blocks and inline code spans. */
+export declare function withoutMarkdownCode(markdown: string): string;

package/dist/core/markdown-code.js

@@ -0,0 +1,107 @@
+/**
+ * GitHub-flavoured Markdown with its code removed, so a mention quoted in code
+ * (`` `@app` ``, a fenced or indented block) is documentation, not a request.
+ * Close to CommonMark, not a full parser: when in doubt it keeps text, so a
+ * real mention is never lost to an odd construct.
+ */
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+const INDENTED = /^(?: {4}|\t)/;
+const LIST_ITEM = /^ {0,3}(?:[-*+]|\d{1,9}[.)])(?:\s|$)/;
+const BLANK = /^\s*$/;
+/** Up to three spaces, at least the opening run of the fence's character, then only whitespace. */
+function closesFence(line, fence) {
+    let index = 0;
+    while (index < 3 && line[index] === " ")
+        index += 1;
+    const start = index;
+    while (line[index] === fence.char)
+        index += 1;
+    return index - start >= fence.length && line.slice(index).trim() === "";
+}
+/** Fenced and indented code blocks blanked out, line count kept. */
+function withoutCodeBlocks(markdown) {
+    const out = [];
+    let fence = null;
+    // Indented code needs a blank line before it, and indented text under a
+    // list item is the item's paragraph, not code.
+    let previousBlank = true;
+    let inIndentedCode = false;
+    let inList = false;
+    for (const line of markdown.split(/\r?\n/)) {
+        if (fence) {
+            if (closesFence(line, fence))
+                fence = null;
+            out.push("");
+            continue;
+        }
+        const open = FENCE_OPEN.exec(line);
+        // A backtick fence's info string cannot contain a backtick (CommonMark).
+        if (open && !(open[1][0] === "`" && line.slice(line.indexOf(open[1]) + open[1].length).includes("`"))) {
+            fence = { char: open[1][0], length: open[1].length };
+            inIndentedCode = false;
+            previousBlank = false;
+            out.push("");
+            continue;
+        }
+        if (BLANK.test(line)) {
+            previousBlank = true;
+            out.push(line);
+            continue;
+        }
+        if (INDENTED.test(line) && !inList && (previousBlank || inIndentedCode)) {
+            inIndentedCode = true;
+            previousBlank = false;
+            out.push("");
+            continue;
+        }
+        inIndentedCode = false;
+        if (LIST_ITEM.test(line))
+            inList = true;
+        else if (!INDENTED.test(line) && previousBlank)
+            inList = false;
+        previousBlank = false;
+        out.push(line);
+    }
+    return out;
+}
+/** Inline code spans in one paragraph replaced by a space; an unmatched run of backticks is literal. */
+function withoutCodeSpans(paragraph) {
+    const runs = [];
+    for (let index = 0; index < paragraph.length;) {
+        if (paragraph[index] !== "`") {
+            index += 1;
+            continue;
+        }
+        const start = index;
+        while (paragraph[index] === "`")
+            index += 1;
+        runs.push({ start, end: index });
+    }
+    // A span closes at the next run of exactly the opening run's length.
+    const closer = new Array(runs.length).fill(-1);
+    const nextOfLength = new Map();
+    for (let i = runs.length - 1; i >= 0; i--) {
+        const length = runs[i].end - runs[i].start;
+        closer[i] = nextOfLength.get(length) ?? -1;
+        nextOfLength.set(length, i);
+    }
+    let result = "";
+    let copied = 0;
+    for (let i = 0; i < runs.length; i++) {
+        const close = closer[i];
+        if (close === -1)
+            continue;
+        result += `${paragraph.slice(copied, runs[i].start)} `;
+        copied = runs[close].end;
+        i = close;
+    }
+    return result + paragraph.slice(copied);
+}
+/** `markdown` without its code blocks and inline code spans. */
+export function withoutMarkdownCode(markdown) {
+    return withoutCodeBlocks(markdown)
+        .join("\n")
+        .split(/(\n[ \t]*\n)/)
+        .map((part, i) => (i % 2 === 1 ? part : withoutCodeSpans(part)))
+        .join("");
+}

package/dist/core/memory-tools.js

@@ -10,6 +10,7 @@
  * agents' data.
  */
 import { z } from "zod";
+import { SecretInValueError, SecretCheckUnavailableError } from "./secret-guard.js";
 import { MEMORY_CONTENT_MAX_BYTES, MEMORY_KEY_MAX_BYTES, MEMORY_MAX_KEYS_PER_AGENT, MEMORY_SEARCH_MAX_LIMIT, } from "../providers/memory/types.js";
 export const MEMORY_TOOL_NAMES = new Set([
     "memory_get",
@@ -116,6 +117,12 @@ export async function handleMemoryTool(name, argsJson, agentId, memory) {
                 message: err.issues.map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; "),
             });
         }
+        if (err instanceof SecretInValueError) {
+            return JSON.stringify({ error: err.code, message: err.message, secretNames: err.secretNames });
+        }
+        if (err instanceof SecretCheckUnavailableError) {
+            return JSON.stringify({ error: err.code, message: err.message });
+        }
         const code = err instanceof Error ? err.message : "memory_error";
         return JSON.stringify({ error: code, message: MEMORY_ERROR_MESSAGES[code] ?? code });
     }

package/dist/core/merge-order-check.d.ts

@@ -0,0 +1,130 @@
+/**
+ * The `wardby merge order` check: pure state computation from a related
+ * pull request set's declared merge order (CodingRun.mergeOrder, see
+ * related-pull-requests.ts). See
+ * docs/private/2026-10-10-delegated-merge-order-design.md Part 3.
+ *
+ * For a member with order *k*, its dependencies are the set's members with
+ * a strictly lower, non-null order; equal-order peers are not dependencies,
+ * and a null-order member is never a dependency (and has none of its own).
+ * The check is posted only when the set has more than one distinct non-null
+ * order; otherwise (or when `self` itself has no order) there is nothing to
+ * gate and the verdict is "skip".
+ *
+ * syncMergeOrderChecks keeps the check current on every open pull request
+ * of a set: at the lead's end (syncMergeOrderChecksAfterRun), when a pull
+ * request closes or gets a new head (syncMergeOrderChecksForPullRequest,
+ * from host-events), and from the reconciler (sweepMergeOrderChecks) for
+ * missed events. State is read fresh from the host each time; nothing is
+ * stored. Best effort: none of these ever throws.
+ */
+import type { Run } from "#prisma";
+import type { PullRequestOrigin, ReviewHostRegistry, UpsertNamedCheckInput } from "../providers/review-host/types.js";
+import { type Logger } from "./logger.js";
+import { type MarkReadyDb } from "./mark-ready.js";
+import { type RelatedPullRequestsDb } from "./related-pull-requests.js";
+export declare const MERGE_ORDER_CHECK_NAME = "wardby merge order";
+export interface MergeOrderMember {
+    repository: string;
+    number: number;
+    mergeOrder: number | null;
+    state: "open" | "draft" | "merged" | "closed";
+    url?: string;
+}
+export type MergeOrderVerdict = {
+    status: "skip";
+} | {
+    status: "in_progress";
+    waitingFor: MergeOrderMember[];
+} | {
+    status: "success";
+    dependencies: MergeOrderMember[];
+} | {
+    status: "failure";
+    closedUnmerged: MergeOrderMember[];
+};
+/**
+ * `set` may include or omit `self`: self's own order always counts toward
+ * the distinct orders, and self is never its own dependency (dependencies
+ * have a strictly lower order). `self` need not be the same object instance
+ * as its entry in `set`; only `mergeOrder` is read from it.
+ */
+export declare function mergeOrderVerdict(self: MergeOrderMember, set: readonly MergeOrderMember[]): MergeOrderVerdict;
+export type MergeOrderDb = RelatedPullRequestsDb & MarkReadyDb;
+export interface MergeOrderSyncDeps {
+    db: MergeOrderDb;
+    hosts: ReviewHostRegistry | undefined;
+    log?: Logger;
+}
+export interface MergeOrderSyncOptions {
+    /** A pull request this event already read: reused instead of reading it a second time. */
+    origin?: {
+        repository: string;
+        number: number;
+        read: () => Promise<PullRequestOrigin>;
+    };
+    /** A pull request this event reports closed: its state comes from the event, and it is not read. */
+    closed?: {
+        repository: string;
+        number: number;
+        merged: boolean;
+    };
+    /**
+     * Sets already synced in this event or sweep pass, keyed by their sorted
+     * members: seeds from different roots of one set (an original request
+     * and a follow-up) collect the same set, which is then written once.
+     */
+    synced?: Set<string>;
+}
+/**
+ * The check run's text for one verdict: step label, then the pull requests
+ * it depends on, as links. While the delegating run is still running
+ * (`leadRunning`) it may still add or reorder steps, so a success for any
+ * step above the set's lowest is posted as in_progress, waiting for it.
+ */
+export declare function mergeOrderCheckInput(self: MergeOrderMember, verdict: Exclude<MergeOrderVerdict, {
+    status: "skip";
+}>, steps: readonly number[], headSha: string, leadRunning?: boolean): UpsertNamedCheckInput;
+/**
+ * Recomputes and posts the `wardby merge order` check on every open (or
+ * draft) pull request of the set `seedRunId` belongs to (any run of the
+ * request's tree). Nothing happens unless the set has more than one
+ * distinct merge order. Each member's state is read live from the host
+ * (a stored "merged" is final and not re-read); the check is posted only on
+ * an open or draft pull request the App opened whose marker names a coding
+ * run this deployment recorded for that repository, on its current head.
+ * A member that can't be read holds back only the checks that depend on it.
+ * Never throws.
+ */
+export declare function syncMergeOrderChecks(deps: MergeOrderSyncDeps, seedRunId: string, opts?: MergeOrderSyncOptions): Promise<void>;
+/**
+ * At a run's end: a tree root (the lead) that delegated anything syncs its
+ * set. A run that delegated nothing costs one indexed lookup. Never throws.
+ */
+export declare function syncMergeOrderChecksAfterRun(deps: MergeOrderSyncDeps, run: Pick<Run, "id" | "parentRunId">): Promise<void>;
+/**
+ * A pull request closed or got a new head: syncs every set it is an
+ * ordered member of. Only a pull request a coding run with a merge order
+ * opened or continued can change any verdict (a member without an order is
+ * no one's dependency and gets no check), so anything else costs one query
+ * and no host call. Never throws.
+ */
+export declare function syncMergeOrderChecksForPullRequest(deps: MergeOrderSyncDeps, pr: {
+    repository: string;
+    number: number;
+}, opts?: MergeOrderSyncOptions): Promise<void>;
+/** The sweep runs at most this often per process (the reconciler ticks every 15 s). */
+export declare const MERGE_ORDER_SWEEP_INTERVAL_MS: number;
+/** Coding runs with a merge order updated within this long are swept. */
+export declare const MERGE_ORDER_SWEEP_MAX_AGE_MS: number;
+/** Most sets synced per sweep pass; the least recently synced go first. */
+export declare const MERGE_ORDER_SWEEP_BATCH = 10;
+export declare function resetMergeOrderSweepForTests(): void;
+/**
+ * The reconciler's half, for missed pr_closed/pr_updated events: syncs the
+ * sets of pull requests that coding runs with a merge order opened or
+ * continued in the last 7 days, a bounded batch per pass, at most once per
+ * MERGE_ORDER_SWEEP_INTERVAL_MS per process. Returns the number of sets
+ * synced. Never throws.
+ */
+export declare function sweepMergeOrderChecks(deps: MergeOrderSyncDeps, now?: Date): Promise<number>;