@deftai/directive-core 0.55.0

package/dist/pr-merge-readiness/compute.js

@@ -0,0 +1,210 @@
+import { FALLBACK2_NOT_CLEAN_MSG, VIA_ERROR, VIA_FALLBACK1, VIA_FALLBACK2, VIA_PRIMARY, } from "./constants.js";
+import { evaluateGates, isMergeReady } from "./evaluate.js";
+import { fetchCheckRunsRest, fetchGreptileBodyRest, fetchGreptileCommentBody, fetchPrHeadSha, fetchPrHeadShaRest, resolveRepo, } from "./gh.js";
+import { emptyVerdict, parseGreptileBody } from "./parse.js";
+function buildGateResult(prNumber, repo, headSha, body, via, partialData = {}, error = null) {
+    const verdict = parseGreptileBody(body);
+    const failures = evaluateGates(prNumber, headSha, verdict);
+    return {
+        prNumber,
+        repo,
+        headSha,
+        verdict,
+        failures,
+        via,
+        partialData,
+        error,
+    };
+}
+function computePrimary(prNumber, repo, runGh) {
+    const partial = {};
+    const headSha = fetchPrHeadSha(prNumber, repo, runGh);
+    if (headSha === null) {
+        partial.primary_error = "gh pr view headRefOid returned non-zero";
+        return { result: null, partial };
+    }
+    partial.head_sha = headSha;
+    const body = fetchGreptileCommentBody(prNumber, repo, runGh);
+    if (body === null) {
+        partial.primary_error = "gh api /issues/<N>/comments --jq returned non-zero";
+        return { result: null, partial };
+    }
+    const verdict = parseGreptileBody(body);
+    const failures = evaluateGates(prNumber, headSha, verdict);
+    return {
+        result: {
+            prNumber,
+            repo,
+            headSha,
+            verdict,
+            failures,
+            via: VIA_PRIMARY,
+            partialData: {},
+            error: null,
+        },
+        partial,
+    };
+}
+function computeFallback1(prNumber, repo, primaryPartial, runGh) {
+    const partial = { ...primaryPartial };
+    const resolved = resolveRepo(repo, runGh);
+    if (resolved.repo === null) {
+        partial.fallback1_error = resolved.error;
+        return { result: null, partial };
+    }
+    let headSha = typeof partial.head_sha === "string" ? partial.head_sha : null;
+    if (!headSha) {
+        const head = fetchPrHeadShaRest(prNumber, resolved.repo, runGh);
+        if (head.sha === null) {
+            partial.fallback1_error = head.error;
+            return { result: null, partial };
+        }
+        headSha = head.sha;
+        partial.head_sha = headSha;
+    }
+    const bodyResult = fetchGreptileBodyRest(prNumber, resolved.repo, runGh);
+    if (bodyResult.body === null) {
+        partial.fallback1_error = bodyResult.error;
+        return { result: null, partial };
+    }
+    const verdict = parseGreptileBody(bodyResult.body);
+    const failures = evaluateGates(prNumber, headSha, verdict);
+    const partialData = {};
+    for (const [key, value] of Object.entries(partial)) {
+        if (key !== "head_sha") {
+            partialData[key] = value;
+        }
+    }
+    return {
+        result: {
+            prNumber,
+            repo: resolved.repo,
+            headSha,
+            verdict,
+            failures,
+            via: VIA_FALLBACK1,
+            partialData,
+            error: null,
+        },
+        partial,
+    };
+}
+function computeFallback2(prNumber, repo, priorPartial, runGh) {
+    const partial = { ...priorPartial };
+    const resolved = resolveRepo(repo, runGh);
+    if (resolved.repo === null) {
+        partial.fallback2_error = resolved.error;
+        return { result: null, partial };
+    }
+    const rc = runGh(["gh", "api", `repos/${resolved.repo}/pulls/${prNumber}`]);
+    if (rc.returncode !== 0) {
+        partial.fallback2_error = `gh api /pulls/${prNumber} failed: ${rc.stderr.trim()}`;
+        return { result: null, partial };
+    }
+    let prPayload;
+    try {
+        prPayload = rc.stdout.trim().length > 0 ? JSON.parse(rc.stdout) : null;
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        partial.fallback2_error = `could not parse PR JSON: ${message}`;
+        return { result: null, partial };
+    }
+    if (prPayload === null || typeof prPayload !== "object" || Array.isArray(prPayload)) {
+        partial.fallback2_error = "unexpected PR JSON shape (not a dict)";
+        return { result: null, partial };
+    }
+    const pr = prPayload;
+    const state = pr.state;
+    const merged = Boolean(pr.merged);
+    const mergeable = pr.mergeable;
+    const mergeableState = pr.mergeable_state;
+    let headSha = null;
+    const headBlock = pr.head;
+    if (headBlock !== null && typeof headBlock === "object" && !Array.isArray(headBlock)) {
+        const candidate = headBlock.sha;
+        if (typeof candidate === "string" && candidate.length > 0) {
+            headSha = candidate;
+        }
+    }
+    if (headSha === null && typeof partial.head_sha === "string") {
+        headSha = partial.head_sha;
+    }
+    let checkSummary = null;
+    if (headSha) {
+        const check = fetchCheckRunsRest(headSha, resolved.repo, runGh);
+        if (check.summary === null && check.error) {
+            partial.fallback2_check_runs_error = check.error;
+        }
+        else {
+            checkSummary = check.summary;
+        }
+    }
+    const fallbackPartial = {
+        pr_state: state,
+        merged,
+        mergeable,
+        mergeable_state: mergeableState,
+        check_runs: checkSummary,
+    };
+    for (const key of ["primary_error", "fallback1_error", "fallback2_check_runs_error"]) {
+        if (key in partial) {
+            fallbackPartial[key] = partial[key];
+        }
+    }
+    return {
+        result: {
+            prNumber,
+            repo: resolved.repo,
+            headSha,
+            verdict: emptyVerdict(),
+            failures: [FALLBACK2_NOT_CLEAN_MSG],
+            via: VIA_FALLBACK2,
+            partialData: fallbackPartial,
+            error: null,
+        },
+        partial,
+    };
+}
+function errorResult(prNumber, repo, partial) {
+    const pieces = [];
+    for (const key of ["primary_error", "fallback1_error", "fallback2_error"]) {
+        if (key in partial) {
+            pieces.push(`${key}=${String(partial[key])}`);
+        }
+    }
+    const error = pieces.length > 0
+        ? pieces.join("; ")
+        : "every fallback layer failed without a reportable error";
+    return {
+        prNumber,
+        repo,
+        headSha: typeof partial.head_sha === "string" ? partial.head_sha : null,
+        verdict: emptyVerdict(),
+        failures: [
+            "pr_merge_readiness external error -- every fallback layer " +
+                "failed; see partial_data for diagnostic detail (#1368).",
+        ],
+        via: VIA_ERROR,
+        partialData: { ...partial },
+        error,
+    };
+}
+/** Run the primary->fallback1->fallback2 cascade and return a result. */
+export function computeGateResult(prNumber, repo, runGh) {
+    let { result, partial } = computePrimary(prNumber, repo, runGh);
+    if (result !== null) {
+        return result;
+    }
+    ({ result, partial } = computeFallback1(prNumber, repo, partial, runGh));
+    if (result !== null) {
+        return result;
+    }
+    ({ result, partial } = computeFallback2(prNumber, repo, partial, runGh));
+    if (result !== null) {
+        return result;
+    }
+    return errorResult(prNumber, repo, partial);
+}
+export { buildGateResult, isMergeReady };
+//# sourceMappingURL=compute.js.map

package/dist/pr-merge-readiness/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const EXIT_OK = 0;
+export declare const EXIT_MERGE_BLOCKED = 1;
+export declare const EXIT_EXTERNAL_ERROR = 2;
+export declare const GREPTILE_LOGIN = "greptile-apps[bot]";
+export declare const GREPTILE_ERRORED_SENTINEL = "Greptile encountered an error while reviewing this PR";
+export declare const LAST_REVIEWED_RE: RegExp;
+export declare const CONFIDENCE_RE: RegExp;
+export declare const P0_BADGE = "<img alt=\"P0\"";
+export declare const P1_BADGE = "<img alt=\"P1\"";
+export declare const SECTION_RE: RegExp;
+export declare const INFORMAL_CLEAN_SIGNAL_RE: RegExp;
+export declare const INFORMAL_CLEAN_STATE = "informal-clean missing-canonical-fields";
+export declare const INFORMAL_CLEAN_DIAGNOSTIC: string;
+export declare const VIA_PRIMARY = "primary";
+export declare const VIA_FALLBACK1 = "fallback1";
+export declare const VIA_FALLBACK2 = "fallback2";
+export declare const VIA_ERROR = "error";
+export declare const FALLBACK2_NOT_CLEAN_MSG: string;
+export declare const GH_TIMEOUT_S = 60;
+//# sourceMappingURL=constants.d.ts.map

package/dist/pr-merge-readiness/constants.js

@@ -0,0 +1,32 @@
+export const EXIT_OK = 0;
+export const EXIT_MERGE_BLOCKED = 1;
+export const EXIT_EXTERNAL_ERROR = 2;
+export const GREPTILE_LOGIN = "greptile-apps[bot]";
+export const GREPTILE_ERRORED_SENTINEL = "Greptile encountered an error while reviewing this PR";
+export const LAST_REVIEWED_RE = /Last reviewed commit:\s*\[[^\]]*\]\(https?:\/\/github\.com\/[^/]+\/[^/]+\/commit\/(?<sha>[0-9a-f]{7,40})/g;
+export const CONFIDENCE_RE = /Confidence Score:\s*(?<score>\d+)\s*\/\s*5/i;
+export const P0_BADGE = '<img alt="P0"';
+export const P1_BADGE = '<img alt="P1"';
+export const SECTION_RE = /###\s+(?<sev>P[012])\s+findings\s*\((?<count>\d+)\)/gi;
+export const INFORMAL_CLEAN_SIGNAL_RE = /(?:diff is clean|(?:prior |previously flagged )?issues? (?:are )?now resolved|all prior issues resolved|no new issues(?: to flag)?|looks solid|good to proceed)/i;
+export const INFORMAL_CLEAN_STATE = "informal-clean missing-canonical-fields";
+export const INFORMAL_CLEAN_DIAGNOSTIC = `Greptile ${INFORMAL_CLEAN_STATE} state (#1543): the latest Greptile bot ` +
+    "comment says the diff is clean / prior issues are resolved, but omits the " +
+    "canonical rolling-summary fields `Last reviewed commit:` and " +
+    "`Confidence Score: X/5` that merge gates require. Prose alone cannot " +
+    "prove review currency or confidence. Recovery: (1) comment " +
+    "`@greptileai review` on the PR to retrigger a canonical rolling summary, " +
+    "(2) wait for Greptile to edit its primary summary comment with both " +
+    "canonical fields on the current HEAD, or (3) document an explicit " +
+    "operator override per skills/deft-directive-swarm/SKILL.md Phase 6 " +
+    "Step 1. Do NOT keep polling -- this is not 'review still writing'.";
+export const VIA_PRIMARY = "primary";
+export const VIA_FALLBACK1 = "fallback1";
+export const VIA_FALLBACK2 = "fallback2";
+export const VIA_ERROR = "error";
+export const FALLBACK2_NOT_CLEAN_MSG = "fallback2 is a coarse signal, not a CLEAN verdict -- the Greptile " +
+    "rolling-summary comment was not reachable on either the primary or " +
+    "fallback1 path. PR state / check-runs reported below as a heartbeat " +
+    "only; do NOT merge on this verdict alone (#1368).";
+export const GH_TIMEOUT_S = 60;
+//# sourceMappingURL=constants.js.map

package/dist/pr-merge-readiness/evaluate.d.ts

@@ -0,0 +1,5 @@
+import type { GreptileVerdict } from "./types.js";
+/** Return failure messages (empty list == merge-ready). */
+export declare function evaluateGates(_prNumber: number, headSha: string | null, verdict: GreptileVerdict): string[];
+export declare function isMergeReady(failures: readonly string[]): boolean;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/pr-merge-readiness/evaluate.js

@@ -0,0 +1,48 @@
+import { INFORMAL_CLEAN_DIAGNOSTIC } from "./constants.js";
+/** Return failure messages (empty list == merge-ready). */
+export function evaluateGates(_prNumber, headSha, verdict) {
+    const failures = [];
+    if (!verdict.found) {
+        failures.push("No Greptile rolling-summary comment found on the PR. " +
+            "Either Greptile has not posted yet, or the bot login filter is wrong. " +
+            "Wait for the review to land before merging (see #796 late-bot-review re-check).");
+        return failures;
+    }
+    if (verdict.errored) {
+        failures.push("Greptile review is in the ERRORED state on the current HEAD (#526). " +
+            "Retry via @greptileai or escalate per " +
+            "skills/deft-directive-swarm/SKILL.md Phase 6 Step 1.");
+    }
+    if (verdict.informalClean) {
+        failures.push(INFORMAL_CLEAN_DIAGNOSTIC);
+        return failures;
+    }
+    if (verdict.lastReviewedSha === null) {
+        failures.push("Could not parse `Last reviewed commit:` from Greptile body. " +
+            "The comment may be malformed or Greptile may still be writing it -- re-fetch.");
+    }
+    else if (headSha &&
+        !(headSha.startsWith(verdict.lastReviewedSha) || verdict.lastReviewedSha.startsWith(headSha))) {
+        failures.push(`Greptile last reviewed ${verdict.lastReviewedSha} but PR HEAD is ${headSha}. ` +
+            "Review is stale -- wait for Greptile to re-review the latest commit.");
+    }
+    if (verdict.confidence === null) {
+        failures.push("Could not parse `Confidence Score: X/5` from Greptile body. " +
+            "Confidence is a required exit-condition input per " +
+            "skills/deft-directive-review-cycle/SKILL.md Phase 2 Step 6.");
+    }
+    else if (verdict.confidence <= 3) {
+        failures.push(`Greptile confidence is ${verdict.confidence}/5; exit condition requires > 3. ` +
+            "Address remaining findings or push clarifying changes.");
+    }
+    if (verdict.p0Count > 0 || verdict.p1Count > 0) {
+        failures.push(`Greptile reports ${verdict.p0Count} P0 and ${verdict.p1Count} P1 findings ` +
+            "on the current HEAD. All P0 / P1 findings MUST be addressed before merge " +
+            "(P2 findings are non-blocking).");
+    }
+    return failures;
+}
+export function isMergeReady(failures) {
+    return failures.length === 0;
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/pr-merge-readiness/gh.d.ts

@@ -0,0 +1,22 @@
+import type { RunGhFn, RunGhResult } from "./types.js";
+/** UTF-8-safe gh capture via execFile (no shell) — mirrors _safe_subprocess.run_text (#1366). */
+export declare function defaultRunGh(cmd: readonly string[]): RunGhResult;
+export declare function fetchPrHeadSha(prNumber: number, repo: string | null, runGh: RunGhFn): string | null;
+export declare function fetchGreptileCommentBody(prNumber: number, repo: string | null, runGh: RunGhFn): string | null;
+export declare function resolveRepo(repo: string | null, runGh: RunGhFn): {
+    repo: string | null;
+    error: string;
+};
+export declare function fetchGreptileBodyRest(prNumber: number, repo: string, runGh: RunGhFn): {
+    body: string | null;
+    error: string;
+};
+export declare function fetchPrHeadShaRest(prNumber: number, repo: string, runGh: RunGhFn): {
+    sha: string | null;
+    error: string;
+};
+export declare function fetchCheckRunsRest(sha: string, repo: string, runGh: RunGhFn): {
+    summary: Record<string, unknown> | null;
+    error: string;
+};
+//# sourceMappingURL=gh.d.ts.map

package/dist/pr-merge-readiness/gh.js

@@ -0,0 +1,281 @@
+import { execFileSync } from "node:child_process";
+import { resolveBinary } from "../scm/binary.js";
+import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
+import { GH_TIMEOUT_S, GREPTILE_LOGIN } from "./constants.js";
+/** UTF-8-safe gh capture via execFile (no shell) — mirrors _safe_subprocess.run_text (#1366). */
+export function defaultRunGh(cmd) {
+    if (cmd.length === 0 || cmd[0] !== "gh") {
+        return { returncode: -1, stdout: "", stderr: "expected gh as first argv element" };
+    }
+    const binary = resolveBinary();
+    const args = cmd.slice(1);
+    try {
+        const stdout = execFileSync(binary, args, {
+            encoding: "utf8",
+            timeout: GH_TIMEOUT_S * 1000,
+            stdio: ["ignore", "pipe", "pipe"],
+            maxBuffer: SUBPROCESS_MAX_BUFFER,
+        });
+        return { returncode: 0, stdout: typeof stdout === "string" ? stdout : "", stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+            return { returncode: -1, stdout: "", stderr: "gh CLI not found. Install GitHub CLI." };
+        }
+        if (e.code === "ETIMEDOUT") {
+            return { returncode: -1, stdout: "", stderr: `gh CLI timed out: ${cmd.join(" ")}` };
+        }
+        return {
+            returncode: typeof e.status === "number" ? e.status : -1,
+            stdout: typeof e.stdout === "string" ? e.stdout : "",
+            stderr: typeof e.stderr === "string" ? e.stderr : String(e.message ?? ""),
+        };
+    }
+}
+export function fetchPrHeadSha(prNumber, repo, runGh) {
+    const cmd = ["gh", "pr", "view", String(prNumber), "--json", "headRefOid", "--jq", ".headRefOid"];
+    if (repo) {
+        cmd.push("--repo", repo);
+    }
+    const { returncode, stdout, stderr } = runGh(cmd);
+    if (returncode !== 0) {
+        process.stderr.write(`Error: gh failed fetching PR #${prNumber} headRefOid: ${stderr.trim()}\n`);
+        return null;
+    }
+    const sha = stdout.trim();
+    return sha.length > 0 ? sha : null;
+}
+export function fetchGreptileCommentBody(prNumber, repo, runGh) {
+    let resolvedRepo = repo;
+    if (!resolvedRepo) {
+        const rc = runGh(["gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"]);
+        if (rc.returncode !== 0) {
+            process.stderr.write(`Error: could not resolve --repo from cwd: ${rc.stderr.trim()}\n`);
+            return null;
+        }
+        resolvedRepo = rc.stdout.trim();
+        if (!resolvedRepo) {
+            process.stderr.write("Error: empty repo from gh repo view (specify --repo OWNER/REPO).\n");
+            return null;
+        }
+    }
+    const cmd = [
+        "gh",
+        "api",
+        `repos/${resolvedRepo}/issues/${prNumber}/comments`,
+        "--paginate",
+        "--jq",
+        `[.[] | select(.user.login == "${GREPTILE_LOGIN}")] | last | .body // ""`,
+    ];
+    const { returncode, stdout, stderr } = runGh(cmd);
+    if (returncode !== 0) {
+        process.stderr.write(`Error: gh failed fetching comments for PR #${prNumber}: ${stderr.trim()}\n`);
+        return null;
+    }
+    return stdout;
+}
+export function resolveRepo(repo, runGh) {
+    if (repo) {
+        return { repo, error: "" };
+    }
+    const rc = runGh(["gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"]);
+    if (rc.returncode !== 0) {
+        return { repo: null, error: `could not resolve --repo from cwd: ${rc.stderr.trim()}` };
+    }
+    const resolved = rc.stdout.trim();
+    if (!resolved) {
+        return { repo: null, error: "empty repo from gh repo view (specify --repo OWNER/REPO)" };
+    }
+    return { repo: resolved, error: "" };
+}
+export function fetchGreptileBodyRest(prNumber, repo, runGh) {
+    const rc = runGh(["gh", "api", `repos/${repo}/issues/${prNumber}/comments`, "--paginate"]);
+    if (rc.returncode !== 0) {
+        return {
+            body: null,
+            error: `gh api /issues/${prNumber}/comments failed: ${rc.stderr.trim()}`,
+        };
+    }
+    if (!rc.stdout.trim()) {
+        return { body: "", error: "" };
+    }
+    return parsePaginatedComments(rc.stdout.trim());
+}
+function parsePaginatedComments(text) {
+    const comments = [];
+    const decoder = new PaginatedJsonDecoder();
+    let idx = 0;
+    while (idx < text.length) {
+        const result = decoder.rawDecode(text, idx);
+        if (result === null) {
+            if (idx < text.length) {
+                return { body: null, error: "could not parse REST comments JSON: invalid JSON at offset" };
+            }
+            break;
+        }
+        const [obj, end] = result;
+        if (Array.isArray(obj)) {
+            comments.push(...obj);
+        }
+        else if (obj !== null && typeof obj === "object") {
+            comments.push(obj);
+        }
+        idx = end;
+    }
+    const greptileBodies = [];
+    for (const c of comments) {
+        if (c !== null &&
+            typeof c === "object" &&
+            !Array.isArray(c) &&
+            "user" in c &&
+            c.user !== null &&
+            typeof c.user === "object" &&
+            !Array.isArray(c.user) &&
+            "login" in c.user &&
+            c.user.login === GREPTILE_LOGIN &&
+            "body" in c &&
+            typeof c.body === "string") {
+            greptileBodies.push(c.body);
+        }
+    }
+    if (greptileBodies.length === 0) {
+        return { body: "", error: "" };
+    }
+    return { body: greptileBodies[greptileBodies.length - 1] ?? "", error: "" };
+}
+/** Mirrors Python json.JSONDecoder.raw_decode for concatenated paginate arrays. */
+class PaginatedJsonDecoder {
+    rawDecode(text, idx) {
+        let pos = idx;
+        while (pos < text.length && /\s/.test(text.charAt(pos))) {
+            pos += 1;
+        }
+        if (pos >= text.length) {
+            return null;
+        }
+        try {
+            let end = pos;
+            let depth = 0;
+            let inString = false;
+            let isEscaped = false;
+            const startChar = text.charAt(pos);
+            if (startChar !== "[" && startChar !== "{") {
+                return null;
+            }
+            for (; end < text.length; end += 1) {
+                const ch = text.charAt(end);
+                if (inString) {
+                    if (isEscaped) {
+                        isEscaped = false;
+                    }
+                    else if (ch === "\\") {
+                        isEscaped = true;
+                    }
+                    else if (ch === '"') {
+                        inString = false;
+                    }
+                    continue;
+                }
+                if (ch === '"') {
+                    inString = true;
+                    continue;
+                }
+                if (ch === "[" || ch === "{") {
+                    depth += 1;
+                }
+                else if (ch === "]" || ch === "}") {
+                    depth -= 1;
+                    if (depth === 0) {
+                        end += 1;
+                        break;
+                    }
+                }
+            }
+            const slice = text.slice(pos, end);
+            const obj = JSON.parse(slice);
+            return [obj, end];
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export function fetchPrHeadShaRest(prNumber, repo, runGh) {
+    const rc = runGh(["gh", "api", `repos/${repo}/pulls/${prNumber}`]);
+    if (rc.returncode !== 0) {
+        return { sha: null, error: `gh api /pulls/${prNumber} failed: ${rc.stderr.trim()}` };
+    }
+    if (!rc.stdout.trim()) {
+        return { sha: null, error: "empty body from gh api /pulls/<N>" };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(rc.stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        return { sha: null, error: `could not parse PR JSON: ${message}` };
+    }
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        return { sha: null, error: "unexpected PR JSON shape (not a dict)" };
+    }
+    const head = payload.head;
+    if (head !== null && typeof head === "object" && !Array.isArray(head)) {
+        const sha = head.sha;
+        if (typeof sha === "string" && sha.length > 0) {
+            return { sha, error: "" };
+        }
+    }
+    return { sha: null, error: "PR JSON missing head.sha" };
+}
+export function fetchCheckRunsRest(sha, repo, runGh) {
+    const rc = runGh(["gh", "api", `repos/${repo}/commits/${sha}/check-runs`]);
+    if (rc.returncode !== 0) {
+        return {
+            summary: null,
+            error: `gh api /commits/${"<"}sha>/check-runs failed: ${rc.stderr.trim()}`,
+        };
+    }
+    if (!rc.stdout.trim()) {
+        return { summary: null, error: "empty body from gh api /commits/<sha>/check-runs" };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(rc.stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        return { summary: null, error: `could not parse check-runs JSON: ${message}` };
+    }
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        return { summary: null, error: "unexpected check-runs JSON shape (not a dict)" };
+    }
+    const runs = payload.check_runs;
+    if (!Array.isArray(runs)) {
+        return { summary: null, error: "check-runs JSON missing check_runs list" };
+    }
+    const summary = {
+        total: runs.length,
+        by_status: {},
+        by_conclusion: {},
+        greptile_review: null,
+    };
+    const byStatus = summary.by_status;
+    const byConclusion = summary.by_conclusion;
+    for (const run of runs) {
+        if (run === null || typeof run !== "object" || Array.isArray(run)) {
+            continue;
+        }
+        const r = run;
+        const status = typeof r.status === "string" ? r.status : "unknown";
+        const conclusion = typeof r.conclusion === "string" ? r.conclusion : "none";
+        byStatus[status] = (byStatus[status] ?? 0) + 1;
+        byConclusion[conclusion] = (byConclusion[conclusion] ?? 0) + 1;
+        if (r.name === "Greptile Review") {
+            summary.greptile_review = { status, conclusion };
+        }
+    }
+    return { summary, error: "" };
+}
+//# sourceMappingURL=gh.js.map

package/dist/pr-merge-readiness/index.d.ts

@@ -0,0 +1,9 @@
+export { computeGateResult } from "./compute.js";
+export * from "./constants.js";
+export { evaluateGates, isMergeReady } from "./evaluate.js";
+export { defaultRunGh } from "./gh.js";
+export { cmdPrMergeReadiness, parseArgs, run } from "./main.js";
+export { emitJson, exitCodeFor, gateResultToDict, printHuman } from "./output.js";
+export { emptyVerdict, isInformalCleanMissingCanonicalFields, parseGreptileBody } from "./parse.js";
+export type { GateResult, GreptileVerdict, RunGhFn, RunGhResult } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/pr-merge-readiness/index.js

@@ -0,0 +1,8 @@
+export { computeGateResult } from "./compute.js";
+export * from "./constants.js";
+export { evaluateGates, isMergeReady } from "./evaluate.js";
+export { defaultRunGh } from "./gh.js";
+export { cmdPrMergeReadiness, parseArgs, run } from "./main.js";
+export { emitJson, exitCodeFor, gateResultToDict, printHuman } from "./output.js";
+export { emptyVerdict, isInformalCleanMissingCanonicalFields, parseGreptileBody } from "./parse.js";
+//# sourceMappingURL=index.js.map

package/dist/pr-merge-readiness/main.d.ts

@@ -0,0 +1,14 @@
+import type { RunGhFn } from "./types.js";
+export interface ParsedArgs {
+    readonly prNumber: number | null;
+    readonly repo: string | null;
+    readonly emitJson: boolean;
+    readonly error?: string;
+}
+export declare function parseArgs(argv: readonly string[]): ParsedArgs;
+export interface RunOptions {
+    readonly runGh?: RunGhFn;
+}
+export declare function run(argv: readonly string[], options?: RunOptions): number;
+export declare function cmdPrMergeReadiness(argv: readonly string[], options?: RunOptions): number;
+//# sourceMappingURL=main.d.ts.map