@event4u/agent-config 16.5.0 → 17.1.0

package/src/scripts/analysis_pr_optimize.ts

@@ -0,0 +1,219 @@
+/**
+ * analysis_pr_optimize.ts — `analyze:pr --optimize` (step 5.3, ADR-288 D6).
+ *
+ * Eligibility first: an open PR whose head branch lives in this repository and
+ * is writable gets fixes pushed to it; anything else gets a patch file beside
+ * the verdict. Each fix carries exactly one test disposition. Every push is a
+ * compare-and-swap on the head the run last saw — a moved head stops the run
+ * before it pushes. Re-review after each push; stop when nothing new clears
+ * the threshold or after three rounds.
+ *
+ * The port has no merge and no approve: the flow cannot do either.
+ */
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { assertRefName, PublishError } from './analysis_publish.js';
+
+export const MAX_OPTIMIZE_ROUNDS = 3;
+
+/** Why a fix ships without a test; the disprove pass reviews each one. */
+export const INFEASIBLE_REASONS = ['no-test-harness', 'nondeterministic', 'external-dependency', 'docs-only', 'config-only'] as const;
+
+const OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+
+export class OptimizeError extends Error {}
+
+export interface PrBranch {
+    pr: number;
+    state: 'OPEN' | 'CLOSED' | 'MERGED';
+    headRefName: string;
+    headSha: string;
+    isCrossRepository: boolean;
+    viewerCanPush: boolean;
+}
+
+export type Eligibility = { kind: 'push'; branch: string } | { kind: 'patch'; reason: string };
+
+export type Disposition =
+    | { kind: 'regression-test-red'; test: string }
+    | { kind: 'existing-test-red'; test: string }
+    | { kind: 'static-check'; check: string }
+    | { kind: 'infeasible'; reasonCode: string; reviewedBy: string };
+
+export interface Fix {
+    findingKey: string;
+    disposition: Disposition;
+}
+
+export interface KeyedFinding {
+    key: string;
+}
+
+export interface OptimizePort {
+    remoteHead(branch: string): string | null;
+    /** Applies and commits the fixes on top of `baseSha`, new files included; returns the new head. */
+    applyFixes(fixes: readonly Fix[], baseSha: string): string;
+    /** Fails, changing nothing, unless the remote head is exactly `expected`. */
+    push(branch: string, expected: string): void;
+    /** Writes the fixes, applied to `headSha`, as a patch file (new files included); returns its path. */
+    writePatch(pr: number, headSha: string, fixes: readonly Fix[]): string;
+}
+
+export type OptimizeEnd = 'converged' | 'round-cap' | 'moved-head' | 'patch' | 'fix-failed';
+
+export interface OptimizeResult {
+    end: OptimizeEnd;
+    rounds: number;
+    fixes: Fix[];
+    patch?: string;
+    reason?: string;
+    /** Findings a pushed fix was meant to remove that the re-review still reports. */
+    persisting?: string[];
+}
+
+export function eligibility(pr: PrBranch): Eligibility {
+    if (pr.state !== 'OPEN') return { kind: 'patch', reason: `PR #${pr.pr} is ${pr.state.toLowerCase()}` };
+    if (pr.isCrossRepository) return { kind: 'patch', reason: `PR #${pr.pr} comes from a fork` };
+    if (!pr.viewerCanPush) return { kind: 'patch', reason: `the head branch of PR #${pr.pr} is not writable` };
+    try {
+        return { kind: 'push', branch: assertRefName(pr.headRefName, 'head branch') };
+    } catch (err) {
+        if (err instanceof PublishError) return { kind: 'patch', reason: err.message };
+        throw err;
+    }
+}
+
+function nonEmpty(s: string): boolean {
+    return s.trim() !== '';
+}
+
+function checkDispositions(findings: readonly KeyedFinding[], fixes: readonly Fix[]): void {
+    const wanted = new Set(findings.map((f) => f.key));
+    const seen = new Set<string>();
+    for (const fix of fixes) {
+        if (!wanted.has(fix.findingKey)) throw new OptimizeError(`fix for ${fix.findingKey} answers no finding of this round`);
+        if (seen.has(fix.findingKey)) throw new OptimizeError(`finding ${fix.findingKey} carries more than one disposition`);
+        seen.add(fix.findingKey);
+        const d = fix.disposition;
+        const ok =
+            d.kind === 'infeasible'
+                ? (INFEASIBLE_REASONS as readonly string[]).includes(d.reasonCode) && nonEmpty(d.reviewedBy)
+                : nonEmpty(d.kind === 'static-check' ? d.check : d.test);
+        if (!ok) throw new OptimizeError(`finding ${fix.findingKey} has an incomplete ${d.kind} disposition`);
+    }
+    const missing = [...wanted].filter((k) => !seen.has(k));
+    if (missing.length > 0) throw new OptimizeError(`no disposition for: ${missing.join(', ')}`);
+}
+
+export function optimizePr(
+    pr: PrBranch,
+    port: OptimizePort,
+    review: (headSha: string) => KeyedFinding[],
+    planFixes: (findings: KeyedFinding[]) => Fix[],
+): OptimizeResult {
+    if (!OBJECT_ID.test(pr.headSha)) throw new OptimizeError(`head SHA ${JSON.stringify(pr.headSha)} is not a full object id`);
+    const target = eligibility(pr);
+    const done: Fix[] = [];
+    const known = new Set<string>();
+    let expected = pr.headSha;
+    for (let rounds = 0; ; rounds += 1) {
+        const found = review(expected);
+        const persisting = found.filter((f) => known.has(f.key)).map((f) => f.key);
+        if (persisting.length > 0) {
+            return { end: 'fix-failed', rounds, fixes: done, persisting, reason: `still reported after their fix: ${persisting.join(', ')}` };
+        }
+        const fresh = found;
+        if (fresh.length === 0) return { end: 'converged', rounds, fixes: done };
+        if (rounds >= MAX_OPTIMIZE_ROUNDS) return { end: 'round-cap', rounds, fixes: done };
+        const fixes = planFixes(fresh);
+        checkDispositions(fresh, fixes);
+        if (target.kind === 'patch') {
+            done.push(...fixes);
+            return { end: 'patch', rounds: rounds + 1, fixes: done, patch: port.writePatch(pr.pr, expected, fixes), reason: target.reason };
+        }
+        const remote = port.remoteHead(target.branch);
+        if (remote !== expected) {
+            return { end: 'moved-head', rounds, fixes: done, reason: `${target.branch} is at ${String(remote)}, expected ${expected}` };
+        }
+        const next = port.applyFixes(fixes, expected);
+        try {
+            port.push(target.branch, expected);
+        } catch (err) {
+            const why = err instanceof Error ? err.message : String(err);
+            return { end: 'moved-head', rounds, fixes: done, reason: `lease on ${target.branch} at ${expected} refused at push (${why}); local commit ${next} not pushed` };
+        }
+        for (const f of fresh) known.add(f.key);
+        done.push(...fixes);
+        expected = next;
+    }
+}
+
+/**
+ * The git port a door uses. Fixes are applied in a private detached worktree at
+ * the head the run pinned, never in the caller's checkout; every file the fix
+ * touches is staged, new files included. A push leases the expected head and
+ * fast-forwards only. `dispose` removes the worktree.
+ */
+export function gitOptimizePort(
+    repoCwd: string,
+    apply: (fixes: readonly Fix[], dir: string) => void,
+): OptimizePort & { dispose(): void } {
+    const run = (cwd: string, args: string[]): string => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: 'pipe' }).trim();
+    const sha = (s: string, what: string): string => {
+        if (!OBJECT_ID.test(s)) throw new OptimizeError(`${what} ${JSON.stringify(s)} is not a full object id`);
+        return s;
+    };
+    let dir: string | null = null;
+    const worktreeAt = (base: string): string => {
+        if (dir === null) {
+            dir = fs.mkdtempSync(path.join(os.tmpdir(), 'analyze-pr-fix-'));
+            run(repoCwd, ['worktree', 'add', '--detach', dir, sha(base, 'base SHA')]);
+        } else if (run(dir, ['rev-parse', 'HEAD']) !== base) {
+            throw new OptimizeError(`fix worktree is not at ${base}`);
+        }
+        return dir;
+    };
+    return {
+        remoteHead: (branch) => {
+            const ref = `refs/heads/${assertRefName(branch, 'branch')}`;
+            const row = run(repoCwd, ['ls-remote', 'origin', ref])
+                .split('\n')
+                .map((l) => l.split(/\s+/))
+                .find((cols) => cols[1] === ref);
+            return row?.[0] ?? null;
+        },
+        applyFixes: (fixes, baseSha) => {
+            const wt = worktreeAt(baseSha);
+            apply(fixes, wt);
+            run(wt, ['add', '--all']);
+            run(wt, ['commit', '-m', `fix: analyze:pr --optimize (${fixes.length} finding(s))`]);
+            return run(wt, ['rev-parse', 'HEAD']);
+        },
+        push: (branch, expected) => {
+            if (dir === null) throw new OptimizeError('nothing applied to push');
+            const ref = `refs/heads/${assertRefName(branch, 'branch')}`;
+            run(dir, ['merge-base', '--is-ancestor', sha(expected, 'expected head'), 'HEAD']);
+            run(dir, ['push', '--porcelain', `--force-with-lease=${ref}:${expected}`, 'origin', `HEAD:${ref}`]);
+        },
+        writePatch: (pr, headSha, fixes) => {
+            const wt = fs.mkdtempSync(path.join(os.tmpdir(), 'analyze-pr-patch-'));
+            run(repoCwd, ['worktree', 'add', '--detach', wt, sha(headSha, 'head SHA')]);
+            try {
+                apply(fixes, wt);
+                run(wt, ['add', '--all']);
+                const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'analyze-pr-')), `pr-${pr}.patch`);
+                fs.writeFileSync(file, `${run(wt, ['diff', '--cached', '--binary', '--no-color', '--no-ext-diff', 'HEAD'])}\n`);
+                return file;
+            } finally {
+                run(repoCwd, ['worktree', 'remove', '--force', wt]);
+            }
+        },
+        dispose: () => {
+            if (dir !== null) run(repoCwd, ['worktree', 'remove', '--force', dir]);
+            dir = null;
+        },
+    };
+}

package/src/scripts/analysis_pr_review.ts

@@ -0,0 +1,240 @@
+/**
+ * analysis_pr_review.ts — the read-only verdict of `analyze:pr` (step 5.2,
+ * ADR-288 D1, D9).
+ *
+ * The PR head is read in a throwaway worktree, the analysts and seats propose
+ * candidate findings, a model of a different family tries to disprove each,
+ * and what survives the confidence threshold is folded and classified against
+ * `base..head`. Every remote effect goes through a `PrReviewPort`; the only
+ * write it has is a comment, and it runs only on `--comment`.
+ *
+ * Finding a defect is model work and stays with the door; this module decides
+ * what of it is reported, so a clean head reports "no finding above threshold"
+ * instead of a padded list.
+ */
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+export const DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
+
+const OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+
+export class ReviewError extends Error {}
+
+export type Severity = 'critical' | 'high' | 'medium' | 'low';
+
+export interface CandidateFinding {
+    severity: Severity;
+    file: string;
+    line: number;
+    claim: string;
+    evidence: string;
+    fix: string;
+    /** The proposer's own confidence, 0..1. */
+    confidence: number;
+    /** A command or input that shows the defect; null when there is none. */
+    reproduction: string | null;
+    /** A test that fails on the defect; null or absent when there is none. */
+    test?: string | null;
+    /** Model family of the analyst or seat that proposed it. */
+    family: string;
+}
+
+export interface DisproveResult {
+    refuted: boolean;
+    family: string;
+    note: string;
+}
+
+export interface PrFinding extends CandidateFinding {
+    origin: 'introduced' | 'pre-existing';
+    disprove_note: string;
+}
+
+export interface PrReviewPort {
+    /** A detached checkout of `headSha`; returns its path. */
+    openWorktree(headSha: string): string;
+    removeWorktree(worktree: string): void;
+    diff(baseSha: string, headSha: string): string;
+    comment(pr: number, body: string): void;
+}
+
+export interface PrReviewInput {
+    pr: number;
+    baseSha: string;
+    headSha: string;
+    comment: boolean;
+    threshold?: number;
+}
+
+export interface PrVerdict {
+    pr: number;
+    baseSha: string;
+    headSha: string;
+    findings: PrFinding[];
+    belowThreshold: number;
+    refuted: number;
+    duplicates: number;
+    /** ADR-288 D9 metric for this door: introduced findings that carry a reproduction or a test. */
+    metric: number;
+    text: string;
+}
+
+function assertObjectId(sha: string, what: string): string {
+    if (!OBJECT_ID.test(sha)) throw new ReviewError(`${what} ${JSON.stringify(sha)} is not a full object id`);
+    return sha;
+}
+
+function diffPath(raw: string): string | null {
+    let p = raw.trim();
+    if (p === '/dev/null') return null;
+    if (p.startsWith('"') && p.endsWith('"')) p = JSON.parse(p) as string;
+    return p.replace(/^b\//u, '');
+}
+
+/**
+ * Head-side line numbers added per file, read from a unified diff. Inside a
+ * hunk the header's line counts decide what is content, so an added line whose
+ * own text begins with `++ ` is never mistaken for a file header.
+ */
+export function addedLines(diff: string): Map<string, Set<number>> {
+    const out = new Map<string, Set<number>>();
+    let file: string | null = null;
+    let line = 0;
+    let oldLeft = 0;
+    let newLeft = 0;
+    for (const raw of diff.split('\n')) {
+        if (oldLeft > 0 || newLeft > 0) {
+            if (raw.startsWith('+')) {
+                if (file !== null) {
+                    let set = out.get(file);
+                    if (set === undefined) {
+                        set = new Set();
+                        out.set(file, set);
+                    }
+                    set.add(line);
+                }
+                line += 1;
+                newLeft -= 1;
+            } else if (raw.startsWith('-')) {
+                oldLeft -= 1;
+            } else if (raw.startsWith(' ') || raw === '') {
+                line += 1;
+                oldLeft -= 1;
+                newLeft -= 1;
+            }
+            continue;
+        }
+        if (raw.startsWith('+++ ')) {
+            file = diffPath(raw.slice(4));
+            continue;
+        }
+        const hunk = /^@@ -\d+(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/u.exec(raw);
+        if (hunk !== null) {
+            oldLeft = hunk[1] === undefined ? 1 : Number(hunk[1]);
+            line = Number(hunk[2]);
+            newLeft = hunk[3] === undefined ? 1 : Number(hunk[3]);
+        }
+    }
+    return out;
+}
+
+function dedupeKey(f: CandidateFinding): string {
+    return `${f.file}:${f.line}:${f.claim.trim().replace(/\s+/gu, ' ').toLowerCase()}`;
+}
+
+export function renderVerdict(v: Omit<PrVerdict, 'text'>, threshold: number): string {
+    const head = `analyze:pr #${v.pr} at ${v.headSha.slice(0, 12)} (base ${v.baseSha.slice(0, 12)})`;
+    const tally = `refuted ${v.refuted} · below threshold ${v.belowThreshold} · folded duplicates ${v.duplicates}`;
+    if (v.findings.length === 0) return `${head}\n\nno finding above threshold (${threshold}) — ${tally}\n`;
+    const rows = v.findings.map(
+        (f) =>
+            `- **${f.severity}** \`${f.file}:${f.line}\` — ${f.claim}\n` +
+            `  - evidence: ${f.evidence}\n` +
+            `  - fix: ${f.fix}\n` +
+            `  - confidence: ${f.confidence} · ${f.origin === 'introduced' ? 'introduced here' : 'pre-existing'}` +
+            (f.reproduction === null ? '' : `\n  - reproduction: ${f.reproduction}`) +
+            (f.test === null || f.test === undefined ? '' : `\n  - test: ${f.test}`),
+    );
+    return `${head}\n\n${rows.join('\n')}\n\n${tally}\n`;
+}
+
+/** Read-only by default: the port's `comment` runs only when `input.comment` is set. */
+export function reviewPr(
+    input: PrReviewInput,
+    port: PrReviewPort,
+    analyse: (worktree: string, diff: string) => CandidateFinding[],
+    disprove: (finding: CandidateFinding) => DisproveResult,
+): PrVerdict {
+    const baseSha = assertObjectId(input.baseSha, 'base SHA');
+    const headSha = assertObjectId(input.headSha, 'head SHA');
+    const threshold = input.threshold ?? DEFAULT_CONFIDENCE_THRESHOLD;
+    const worktree = port.openWorktree(headSha);
+    let candidates: CandidateFinding[];
+    let diff: string;
+    try {
+        diff = port.diff(baseSha, headSha);
+        candidates = analyse(worktree, diff);
+    } finally {
+        port.removeWorktree(worktree);
+    }
+    const added = addedLines(diff);
+    let belowThreshold = 0;
+    let refuted = 0;
+    let duplicates = 0;
+    const kept = new Map<string, PrFinding>();
+    for (const f of candidates) {
+        if (f.confidence < threshold) {
+            belowThreshold += 1;
+            continue;
+        }
+        const d = disprove(f);
+        if (d.family === f.family) {
+            throw new ReviewError(`disprove pass for ${f.file}:${f.line} ran on the proposer's own family (${f.family})`);
+        }
+        if (d.refuted) {
+            refuted += 1;
+            continue;
+        }
+        const key = dedupeKey(f);
+        const prior = kept.get(key);
+        if (prior !== undefined) {
+            duplicates += 1;
+            if (prior.confidence >= f.confidence) continue;
+        }
+        const origin = added.get(f.file)?.has(f.line) === true ? 'introduced' : 'pre-existing';
+        kept.set(key, { ...f, origin, disprove_note: d.note });
+    }
+    const findings = [...kept.values()];
+    const shown = (v: string | null | undefined): boolean => typeof v === 'string' && v.trim() !== '';
+    const metric = findings.filter((f) => f.origin === 'introduced' && (shown(f.reproduction) || shown(f.test))).length;
+    const base = { pr: input.pr, baseSha, headSha, findings, belowThreshold, refuted, duplicates, metric };
+    const text = renderVerdict(base, threshold);
+    if (input.comment) port.comment(input.pr, text);
+    return { ...base, text };
+}
+
+/** The git + gh port a door uses. Its one write is `gh pr comment`, reached only through `--comment`. */
+export function gitGhReviewPort(cwd: string): PrReviewPort {
+    const run = (bin: string, args: string[]): string => execFileSync(bin, args, { cwd, encoding: 'utf8', stdio: 'pipe' });
+    return {
+        openWorktree: (headSha) => {
+            const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'analyze-pr-'));
+            run('git', ['worktree', 'add', '--detach', dir, assertObjectId(headSha, 'head SHA')]);
+            return dir;
+        },
+        removeWorktree: (worktree) => {
+            run('git', ['worktree', 'remove', '--force', worktree]);
+        },
+        diff: (baseSha, headSha) =>
+            // Three dots: from the merge base, so commits the base gained later are never the PR's.
+            run('git', ['diff', '--no-color', '--no-ext-diff', `${assertObjectId(baseSha, 'base SHA')}...${assertObjectId(headSha, 'head SHA')}`]),
+        comment: (pr, body) => {
+            const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'analyze-pr-body-')), 'body.md');
+            fs.writeFileSync(file, body);
+            run('gh', ['pr', 'comment', String(pr), '--body-file', file]);
+        },
+    };
+}

package/src/scripts/analysis_pr_target.ts

@@ -0,0 +1,121 @@
+/**
+ * analysis_pr_target.ts — which PR `analyze:pr` reads (step 5.1, ADR-288 D1).
+ *
+ * Order: the argument (number, `#number` or PR URL), else the current branch's
+ * open PR, else the one PR the conversation already named, else one question.
+ * Zero or several candidates at the deciding rung ask for the link once; a
+ * named PR that is not open asks rather than falling through to a guess.
+ * Base and head SHAs are pinned at resolution.
+ */
+import { execFileSync } from 'node:child_process';
+
+import { sanitize_text } from './_lib/retrieval_sanitize.js';
+
+export interface PrInfo {
+    number: number;
+    baseSha: string;
+    headSha: string;
+    state: 'OPEN' | 'CLOSED' | 'MERGED';
+}
+
+export interface PrLookup {
+    byNumber(n: number): PrInfo | null;
+    /** Open PR numbers whose head is `branch`. */
+    openForBranch(branch: string): number[];
+    /** `owner/name` of the repository `byNumber` reads, when known. */
+    repo?(): string | null;
+}
+
+export type PrTarget =
+    | { kind: 'resolved'; via: 'argument' | 'branch' | 'conversation'; pr: number; baseSha: string; headSha: string }
+    | { kind: 'ask'; question: string; candidates: number[] };
+
+const URL_RE = /\/pull\/(\d+)(?:[/?#]|$)/;
+const URL_REPO_RE = /\/([^/\s]+\/[^/\s]+)\/pull\/\d+(?:[/?#\s]|$)/;
+
+/**
+ * Whether a PR URL names another repository than the one the lookup reads. A
+ * number taken from a link to another repository is a different PR here.
+ */
+function foreignUrl(ref: string, lookup: PrLookup): boolean {
+    const named = URL_REPO_RE.exec(ref)?.[1];
+    const here = lookup.repo?.() ?? null;
+    return named !== undefined && here !== null && named.toLowerCase() !== here.toLowerCase();
+}
+
+/** A PR number from `42`, `#42` or a `…/pull/42` URL; null for anything else. */
+export function parsePrRef(ref: string): number | null {
+    const s = ref.trim();
+    const m = /^#?(\d+)$/.exec(s) ?? URL_RE.exec(s);
+    return m === null ? null : Number(m[1]);
+}
+
+function mentioned(conversation: readonly string[], lookup: PrLookup): number[] {
+    const out = new Set<number>();
+    for (const turn of conversation) {
+        for (const m of turn.matchAll(/(?:\S*\/pull\/|#)(\d+)\b/g)) {
+            if (!foreignUrl(m[0], lookup)) out.add(Number(m[1]));
+        }
+    }
+    return [...out];
+}
+
+function ask(candidates: number[]): PrTarget {
+    const which = candidates.length === 0 ? 'No open PR was found' : `Several PRs fit (${candidates.map((n) => `#${n}`).join(', ')})`;
+    return { kind: 'ask', question: `${which} — which PR should be analysed? Paste its link or number.`, candidates };
+}
+
+function resolved(via: 'argument' | 'branch' | 'conversation', info: PrInfo | null, candidates: number[]): PrTarget {
+    if (info === null || info.state !== 'OPEN') return ask(candidates);
+    return { kind: 'resolved', via, pr: info.number, baseSha: info.baseSha, headSha: info.headSha };
+}
+
+export function resolvePrTarget(
+    input: { argument: string | null; branch: string | null; conversation: readonly string[] },
+    lookup: PrLookup,
+): PrTarget {
+    if (input.argument !== null) {
+        const n = parsePrRef(input.argument);
+        if (n === null || foreignUrl(input.argument.trim(), lookup)) return ask([]);
+        return resolved('argument', lookup.byNumber(n), []);
+    }
+    if (input.branch !== null) {
+        const open = lookup.openForBranch(input.branch);
+        if (open.length > 1) return ask(open);
+        if (open.length === 1) return resolved('branch', lookup.byNumber(open[0] as number), open);
+    }
+    const named = mentioned(input.conversation, lookup);
+    if (named.length === 1) return resolved('conversation', lookup.byNumber(named[0] as number), named);
+    return ask(named);
+}
+
+/** The gh-backed lookup a door uses; read-only. */
+export function ghPrLookup(cwd: string): PrLookup {
+    const gh = (args: string[]): string => sanitize_text(execFileSync('gh', args, { cwd, encoding: 'utf8' })).trim();
+    return {
+        byNumber: (n) => {
+            try {
+                const j = JSON.parse(gh(['pr', 'view', String(n), '--json', 'number,baseRefOid,headRefOid,state'])) as {
+                    number: number;
+                    baseRefOid: string;
+                    headRefOid: string;
+                    state: PrInfo['state'];
+                };
+                return { number: j.number, baseSha: j.baseRefOid, headSha: j.headRefOid, state: j.state };
+            } catch {
+                return null;
+            }
+        },
+        openForBranch: (branch) =>
+            (JSON.parse(gh(['pr', 'list', '--head', branch, '--state', 'open', '--json', 'number'])) as Array<{ number: number }>).map(
+                (r) => r.number,
+            ),
+        repo: () => {
+            try {
+                return (JSON.parse(gh(['repo', 'view', '--json', 'nameWithOwner'])) as { nameWithOwner: string }).nameWithOwner;
+            } catch {
+                return null;
+            }
+        },
+    };
+}