pr-shepherd 0.16.3 → 0.17.0

package/bin/github/http.mjs

@@ -1,319 +1,4 @@
-import { execFile as execFileCb } from "node:child_process";
-import { promisify } from "node:util";
-import { appendEntry, nextEntry } from "../log/log-file.mjs";
-import { formatRequestEntry, formatResponseEntry } from "../log/session.mjs";
-import { GitHubRequestError } from "./errors.mjs";
-export { GitHubRequestError };
-const execFile = promisify(execFileCb);
-const BASE_URL = "https://api.github.com";
-// ---------------------------------------------------------------------------
-// Auth
-// ---------------------------------------------------------------------------
-let _token;
-export function _resetTokenCache() {
-    _token = undefined;
-}
-async function resolveToken() {
-    if (_token)
-        return _token;
-    const envToken = process.env["GH_TOKEN"] ?? process.env["GITHUB_TOKEN"];
-    if (envToken) {
-        _token = envToken;
-        return _token;
-    }
-    try {
-        const { stdout } = await execFile("gh", ["auth", "token"]);
-        const token = stdout.trim();
-        if (token) {
-            _token = token;
-            return _token;
-        }
-    }
-    catch {
-        // fall through to error
-    }
-    const codexToken = process.env["GITHUB_PERSONAL_ACCESS_TOKEN"];
-    if (codexToken) {
-        _token = codexToken;
-        return _token;
-    }
-    throw new Error("No GitHub token found. Set GH_TOKEN, GITHUB_TOKEN, or GITHUB_PERSONAL_ACCESS_TOKEN, or run `gh auth login`.");
-}
-async function makeHeaders() {
-    return {
-        Authorization: `Bearer ${await resolveToken()}`,
-        Accept: "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-        "User-Agent": "pr-shepherd",
-        "Content-Type": "application/json",
-    };
-}
-function sanitizeBody(body) {
-    return body.replace(/Bearer\s+\S+/gi, "[REDACTED]").slice(0, 200);
-}
-function redactToken(body) {
-    return body.replace(/Bearer\s+\S+/gi, "[REDACTED]");
-}
-function redactUrl(url) {
-    try {
-        const u = new URL(url);
-        return `${u.origin}${u.pathname}`;
-    }
-    catch {
-        return url;
-    }
-}
-async function requestWithTokenRetry(fn, t0, onIntermediate) {
-    const res = await fn();
-    if (res.status === 401 && _token !== undefined) {
-        onIntermediate?.(401, Math.round(performance.now() - t0));
-        try {
-            await res.arrayBuffer();
-        }
-        catch { }
-        _token = undefined;
-        const retryT0 = performance.now();
-        return { res: await fn(), attempt: 2, retryT0 };
-    }
-    return { res, attempt: 1, retryT0: t0 };
-}
-// ---------------------------------------------------------------------------
-// GraphQL
-// ---------------------------------------------------------------------------
-async function graphqlInner(query, vars) {
-    const url = `${BASE_URL}/graphql`;
-    const n = nextEntry();
-    appendEntry(formatRequestEntry({
-        n,
-        kind: "GraphQL",
-        method: "POST",
-        url,
-        body: { query, variables: vars },
-    }));
-    const t0 = performance.now();
-    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
-        method: "POST",
-        headers: await makeHeaders(),
-        body: JSON.stringify({ query, variables: vars }),
-    }), t0, (status, firstDurationMs) => {
-        appendEntry(formatResponseEntry({
-            n,
-            kind: "GraphQL",
-            method: "POST",
-            url,
-            status,
-            durationMs: firstDurationMs,
-        }));
-    });
-    const durationMs = Math.round(performance.now() - retryT0);
-    const rateLimit = parseRateLimit(res.headers);
-    const retryAfterSeconds = parseRetryAfter(res.headers);
-    if (!res.ok) {
-        const body = await res.text();
-        appendEntry(formatResponseEntry({
-            n,
-            kind: "GraphQL",
-            method: "POST",
-            url,
-            status: res.status,
-            durationMs,
-            textBody: redactToken(body),
-            attempt: attempt > 1 ? attempt : undefined,
-        }));
-        throw new GitHubRequestError(`GitHub GraphQL request failed: ${res.status} ${sanitizeBody(body)}`, { status: res.status, rateLimit: rateLimit ?? undefined, retryAfterSeconds });
-    }
-    const parsed = (await res.json());
-    appendEntry(formatResponseEntry({
-        n,
-        kind: "GraphQL",
-        method: "POST",
-        url,
-        status: res.status,
-        durationMs,
-        body: parsed,
-        attempt: attempt > 1 ? attempt : undefined,
-    }));
-    if (parsed.data == null) {
-        const messages = (parsed.errors ?? []).map((e) => e.message).join("; ");
-        throw new GitHubRequestError(`GitHub GraphQL error (no data): ${messages}`, {
-            status: res.status,
-            rateLimit: rateLimit ?? undefined,
-            retryAfterSeconds,
-        });
-    }
-    if (parsed.errors?.length) {
-        const messages = parsed.errors.map((e) => e.message).join("; ");
-        process.stderr.write(`pr-shepherd: GraphQL non-fatal errors: ${messages}\n`);
-    }
-    return { data: parsed.data, rateLimit, retryAfterSeconds, errors: parsed.errors };
-}
-export async function graphql(query, vars = {}) {
-    const { data } = await graphqlInner(query, vars);
-    return { data };
-}
-export async function graphqlWithRateLimit(query, vars = {}) {
-    const { data, rateLimit, retryAfterSeconds, errors } = await graphqlInner(query, vars);
-    return { data, rateLimit: rateLimit ?? undefined, retryAfterSeconds, errors };
-}
-// ---------------------------------------------------------------------------
-// REST
-// ---------------------------------------------------------------------------
-export async function rest(method, path, body) {
-    const url = `${BASE_URL}${path}`;
-    const n = nextEntry();
-    appendEntry(formatRequestEntry({ n, kind: "REST", method, url, body }));
-    const t0 = performance.now();
-    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
-        method,
-        headers: await makeHeaders(),
-        body: body !== undefined ? JSON.stringify(body) : undefined,
-    }), t0, (status, firstDurationMs) => {
-        appendEntry(formatResponseEntry({ n, kind: "REST", method, url, status, durationMs: firstDurationMs }));
-    });
-    const durationMs = Math.round(performance.now() - retryT0);
-    const ct = res.headers.get("content-type") ?? "";
-    if (!res.ok) {
-        const text = await res.text();
-        appendEntry(formatResponseEntry({
-            n,
-            kind: "REST",
-            method,
-            url,
-            status: res.status,
-            durationMs,
-            textBody: redactToken(text),
-            attempt: attempt > 1 ? attempt : undefined,
-        }));
-        throw new Error(`GitHub REST ${method} ${path} failed: ${res.status} ${sanitizeBody(text)}`);
-    }
-    if (ct.includes("application/json")) {
-        const json = (await res.json());
-        appendEntry(formatResponseEntry({
-            n,
-            kind: "REST",
-            method,
-            url,
-            status: res.status,
-            durationMs,
-            contentType: ct,
-            body: json,
-            attempt: attempt > 1 ? attempt : undefined,
-        }));
-        return json;
-    }
-    appendEntry(formatResponseEntry({
-        n,
-        kind: "REST",
-        method,
-        url,
-        status: res.status,
-        durationMs,
-        contentType: ct || undefined,
-        attempt: attempt > 1 ? attempt : undefined,
-    }));
-    return undefined;
-}
-export async function restText(path) {
-    const url = `${BASE_URL}${path}`;
-    const n = nextEntry();
-    appendEntry(formatRequestEntry({ n, kind: "restText", method: "GET", url }));
-    const t0 = performance.now();
-    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
-        method: "GET",
-        headers: await makeHeaders(),
-        redirect: "manual",
-    }), t0, (status, firstDurationMs) => {
-        appendEntry(formatResponseEntry({
-            n,
-            kind: "restText",
-            method: "GET",
-            url,
-            status,
-            durationMs: firstDurationMs,
-        }));
-    });
-    const durationMs = Math.round(performance.now() - retryT0);
-    if (res.status === 301 || res.status === 302 || res.status === 307 || res.status === 308) {
-        appendEntry(formatResponseEntry({
-            n,
-            kind: "restText",
-            method: "GET",
-            url,
-            status: res.status,
-            durationMs,
-            attempt: attempt > 1 ? attempt : undefined,
-        }));
-        const location = res.headers.get("location");
-        if (location) {
-            const n2 = nextEntry();
-            const logUrl = redactUrl(location);
-            appendEntry(formatRequestEntry({ n: n2, kind: "restText", method: "GET", url: logUrl }));
-            const t1 = performance.now();
-            const redirectRes = await fetch(location);
-            const duration2 = Math.round(performance.now() - t1);
-            const clRaw = redirectRes.headers.get("content-length");
-            const contentLength = clRaw !== null && Number.isFinite(Number(clRaw)) ? Number(clRaw) : undefined;
-            appendEntry(formatResponseEntry({
-                n: n2,
-                kind: "restText",
-                method: "GET",
-                url: logUrl,
-                status: redirectRes.status,
-                durationMs: duration2,
-                contentLength,
-            }));
-            if (!redirectRes.ok) {
-                throw new Error(`redirect target ${location} failed: ${redirectRes.status}`);
-            }
-            return redirectRes.text();
-        }
-    }
-    if (!res.ok) {
-        const text = await res.text();
-        appendEntry(formatResponseEntry({
-            n,
-            kind: "restText",
-            method: "GET",
-            url,
-            status: res.status,
-            durationMs,
-            attempt: attempt > 1 ? attempt : undefined,
-        }));
-        throw new Error(`GitHub REST GET ${path} failed: ${res.status} ${sanitizeBody(text)}`);
-    }
-    const clRaw = res.headers.get("content-length");
-    const contentLength = clRaw !== null && Number.isFinite(Number(clRaw)) ? Number(clRaw) : undefined;
-    appendEntry(formatResponseEntry({
-        n,
-        kind: "restText",
-        method: "GET",
-        url,
-        status: res.status,
-        durationMs,
-        contentLength,
-        attempt: attempt > 1 ? attempt : undefined,
-    }));
-    return res.text();
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function parseRateLimit(headers) {
-    const rRaw = headers.get("x-ratelimit-remaining");
-    const lRaw = headers.get("x-ratelimit-limit");
-    const tRaw = headers.get("x-ratelimit-reset");
-    if (rRaw === null || lRaw === null || tRaw === null)
-        return null;
-    const remaining = Number(rRaw);
-    const limit = Number(lRaw);
-    const resetAt = Number(tRaw);
-    if (Number.isFinite(remaining) && Number.isFinite(limit) && Number.isFinite(resetAt)) {
-        return { remaining, limit, resetAt };
-    }
-    return null;
-}
-function parseRetryAfter(headers) {
-    const raw = headers.get("retry-after");
-    const seconds = Number(raw);
-    return raw !== null && Number.isFinite(seconds) && seconds >= 0 ? seconds : undefined;
-}
+export { GitHubRequestError } from "./errors.mjs";
+export { _resetTokenCache } from "./http-auth.mjs";
+export { graphql, graphqlWithRateLimit } from "./graphql-http.mjs";
+export { rest, restText } from "./rest-http.mjs";

package/bin/github/http.test-support.mjs

@@ -0,0 +1,52 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from "vitest";
+// ---------------------------------------------------------------------------
+// Stub fetch and child_process globally before any imports.
+// ---------------------------------------------------------------------------
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
+vi.mock("node:child_process", () => ({
+    execFile: (cmd, args, optsOrCb, maybeCb) => {
+        const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+        mockExecFile(cmd, args)
+            .then((result) => cb(null, result))
+            .catch((err) => cb(err, { stdout: "", stderr: "" }));
+    },
+}));
+import { GitHubRequestError, graphql, graphqlWithRateLimit, rest, restText, _resetTokenCache, } from "./http.mjs";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function jsonOk(data) {
+    return {
+        ok: true,
+        status: 200,
+        headers: new Headers({ "content-type": "application/json" }),
+        json: () => Promise.resolve(data),
+        text: () => Promise.resolve(JSON.stringify(data)),
+    };
+}
+function gqlOk(data) {
+    return {
+        ok: true,
+        status: 200,
+        headers: new Headers({ "content-type": "application/json" }),
+        json: () => Promise.resolve({ data }),
+        text: () => Promise.resolve(JSON.stringify({ data })),
+    };
+}
+// ---------------------------------------------------------------------------
+// Token resolution
+// ---------------------------------------------------------------------------
+export function registerHooks() {
+    beforeEach(() => {
+        mockFetch.mockReset();
+        mockExecFile.mockReset();
+        _resetTokenCache();
+        delete process.env["GH_TOKEN"];
+        delete process.env["GITHUB_TOKEN"];
+        delete process.env["GITHUB_PERSONAL_ACCESS_TOKEN"];
+    });
+}
+export { GitHubRequestError, _resetTokenCache, gqlOk, graphql, graphqlWithRateLimit, jsonOk, mockExecFile, mockFetch, rest, restText, };

package/bin/github/rest-http.mjs

@@ -0,0 +1,131 @@
+import { appendEntry, nextEntry } from "../log/log-file.mjs";
+import { formatRequestEntry, formatResponseEntry } from "../log/session.mjs";
+import { makeHeaders } from "./http-auth.mjs";
+import { requestWithTokenRetry } from "./http-request.mjs";
+import { redactToken, redactUrl, sanitizeBody } from "./http-utils.mjs";
+const BASE_URL = "https://api.github.com";
+export async function rest(method, path, body) {
+    const url = `${BASE_URL}${path}`;
+    const n = nextEntry();
+    appendEntry(formatRequestEntry({ n, kind: "REST", method, url, body }));
+    const t0 = performance.now();
+    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
+        method,
+        headers: await makeHeaders(),
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+    }), t0, (status, durationMs) => appendEntry(formatResponseEntry({ n, kind: "REST", method, url, status, durationMs })));
+    const durationMs = Math.round(performance.now() - retryT0);
+    const ct = res.headers.get("content-type") ?? "";
+    if (!res.ok) {
+        const text = await res.text();
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "REST",
+            method,
+            url,
+            status: res.status,
+            durationMs,
+            textBody: redactToken(text),
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
+        throw new Error(`GitHub REST ${method} ${path} failed: ${res.status} ${sanitizeBody(text)}`);
+    }
+    if (ct.includes("application/json")) {
+        const json = (await res.json());
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "REST",
+            method,
+            url,
+            status: res.status,
+            durationMs,
+            contentType: ct,
+            body: json,
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
+        return json;
+    }
+    appendEntry(formatResponseEntry({
+        n,
+        kind: "REST",
+        method,
+        url,
+        status: res.status,
+        durationMs,
+        contentType: ct || undefined,
+        attempt: attempt > 1 ? attempt : undefined,
+    }));
+    return undefined;
+}
+export async function restText(path) {
+    const url = `${BASE_URL}${path}`;
+    const n = nextEntry();
+    appendEntry(formatRequestEntry({ n, kind: "restText", method: "GET", url }));
+    const t0 = performance.now();
+    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, { method: "GET", headers: await makeHeaders(), redirect: "manual" }), t0, (status, durationMs) => appendEntry(formatResponseEntry({ n, kind: "restText", method: "GET", url, status, durationMs })));
+    const durationMs = Math.round(performance.now() - retryT0);
+    if ([301, 302, 307, 308].includes(res.status)) {
+        const redirected = await followRestTextRedirect(res, { n, url, durationMs, attempt });
+        if (redirected !== null)
+            return redirected;
+    }
+    if (!res.ok) {
+        const text = await res.text();
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "restText",
+            method: "GET",
+            url,
+            status: res.status,
+            durationMs,
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
+        throw new Error(`GitHub REST GET ${path} failed: ${res.status} ${sanitizeBody(text)}`);
+    }
+    appendEntry(formatResponseEntry({
+        n,
+        kind: "restText",
+        method: "GET",
+        url,
+        status: res.status,
+        durationMs,
+        contentLength: parseContentLength(res.headers),
+        attempt: attempt > 1 ? attempt : undefined,
+    }));
+    return res.text();
+}
+async function followRestTextRedirect(res, entry) {
+    appendEntry(formatResponseEntry({
+        n: entry.n,
+        kind: "restText",
+        method: "GET",
+        url: entry.url,
+        status: res.status,
+        durationMs: entry.durationMs,
+        attempt: entry.attempt > 1 ? entry.attempt : undefined,
+    }));
+    const location = res.headers.get("location");
+    if (!location)
+        return null;
+    const n2 = nextEntry();
+    const logUrl = redactUrl(location);
+    appendEntry(formatRequestEntry({ n: n2, kind: "restText", method: "GET", url: logUrl }));
+    const t1 = performance.now();
+    const redirectRes = await fetch(location);
+    appendEntry(formatResponseEntry({
+        n: n2,
+        kind: "restText",
+        method: "GET",
+        url: logUrl,
+        status: redirectRes.status,
+        durationMs: Math.round(performance.now() - t1),
+        contentLength: parseContentLength(redirectRes.headers),
+    }));
+    if (!redirectRes.ok)
+        throw new Error(`redirect target ${location} failed: ${redirectRes.status}`);
+    return redirectRes.text();
+}
+function parseContentLength(headers) {
+    const raw = headers.get("content-length");
+    return raw !== null && Number.isFinite(Number(raw)) ? Number(raw) : undefined;
+}

package/bin/state/base.mjs

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 export function resolveStateBase() {
-    return process.env["PR_SHEPHERD_STATE_DIR"] ?? join(tmpdir(), "pr-shepherd-state");
+    const envDir = process.env["PR_SHEPHERD_STATE_DIR"];
+    return envDir ? envDir : join(tmpdir(), "pr-shepherd-state");
 }

package/bin/suggestions/patch.test-support.mjs

@@ -0,0 +1,4 @@
+// @ts-nocheck
+import { describe, it, expect } from "vitest";
+import { buildUnifiedDiff } from "./patch.mjs";
+export { buildUnifiedDiff };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pr-shepherd",
-  "version": "0.16.3",
+  "version": "0.17.0",
   "description": "Autonomous PR CI monitor and review-comment resolver for agentic coding tools",
   "license": "MIT",
   "author": "Jonathan Ong",
@@ -42,7 +42,7 @@
     "format": "oxfmt src/ plugins/ .agents/plugins/ docs/ README.md",
     "format:check": "oxfmt --check src/ plugins/ .agents/plugins/ docs/ README.md",
     "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "vitest run --coverage && node scripts/strip-lcov-branches.mjs",
     "test:watch": "vitest"
   },
   "keywords": [

package/plugins/pr-shepherd/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pr-shepherd",
-  "version": "0.16.3",
+  "version": "0.17.0",
   "description": "Autonomous PR CI monitor and review-comment resolver for Codex.",
   "author": {
     "name": "Jonathan Ong",

package/plugins/pr-shepherd/skills/pr-shepherd/SKILL.md

@@ -29,12 +29,12 @@ One-tick dispatcher for iterating a PR to completion.
    If `MERGED` or `CLOSED`, output: `PR #N is already merged/closed. Nothing to do.` and stop.
 
 3. **Select the package runner** from the target repository root:
-   - Prefer `package.json` `packageManager`: `pnpm@...` → `pnpm exec`, `yarn@...` → `yarn run`, `npm@...` → `npx`.
-   - If `packageManager` is absent, use lockfiles: `pnpm-lock.yaml` → `pnpm exec`, `yarn.lock` → `yarn run`, `package-lock.json` or no signal → `npx`.
+   - Prefer `package.json` `packageManager`: `pnpm@...` → `pnpm exec`, `yarn@...` → `yarn run`, `bun@...` → `bunx`, `npm@...` → `npx`.
+   - If `packageManager` is absent, use lockfiles: `pnpm-lock.yaml` → `pnpm exec`, `yarn.lock` → `yarn run`, `bun.lock` / `bun.lockb` → `bunx`, `package-lock.json` or no signal → `npx`.
 
 4. **Run one iterate tick:**
 
-   If the package is missing in the target repository, tell the user to install pr-shepherd with the matching dev-dependency command: `pnpm add -D pr-shepherd`, `yarn add -D pr-shepherd`, or `npm install --save-dev pr-shepherd`.
+   If the package is missing in the target repository, tell the user to install pr-shepherd with the matching dev-dependency command: `pnpm add -D pr-shepherd`, `yarn add -D pr-shepherd`, `bun add -d pr-shepherd`, or `npm install --save-dev pr-shepherd`.
 
    ```bash
    <runner> pr-shepherd <N>
@@ -45,4 +45,4 @@ One-tick dispatcher for iterating a PR to completion.
 5. **Stop conditions:**
    - Stop when the CLI emits `[CANCEL]` (ready-delay completed, or PR merged/closed).
    - Stop when the CLI emits `[ESCALATE]`, including `stall-timeout` for repeated unchanged CI failures.
-   - All other actions (`[WAIT]`, `[MARK_READY]`, `[FIX_CODE]`) are non-terminal: follow the `## Instructions`. For Claude, schedule exactly one next session-only iteration and end the turn; do not sleep inline and do not create a recurring cron.
+   - All other actions (`[WAIT]`, `[MARK_READY]`, `[FIX_CODE]`) are non-terminal: follow the `## Instructions`. For Claude, schedule exactly one next session-only iteration and end the turn; do not sleep inline and do not create a recurring cron or polling loop (`while true`, repeated polling, etc.).