co-maintainer 0.4.0-beta.1

package/dist/src/review/carry_over.d.ts

@@ -0,0 +1,63 @@
+import type { ParsedFinding } from "../pr/findings.ts";
+import { type Revision, type RevisionFile } from "./revision.ts";
+export type StoredFinding = {
+    id: string;
+    path: string | null;
+    lineFrom: number | null;
+    lineTo: number | null;
+    title: string;
+    bodyMd: string;
+    anchorText: string | null;
+    severity: string;
+    firstSeenReviewId: string | null;
+};
+export type CarryPrevious = {
+    files: RevisionFile[];
+    visiblePaths: Set<string>;
+    findings: StoredFinding[];
+    guideBuiltAt: string | null;
+};
+export type CarryClass = "file_reverted" | "file_removed" | "unverifiable" | "verify_guide_changed" | "unchanged" | "verify_present" | "verify_likely_fixed" | "verify_unlocated";
+export type CarryItem = {
+    id: string;
+    finding: StoredFinding;
+    class: CarryClass;
+    targetPath: string | null;
+    lineFrom: number;
+    lineTo: number;
+};
+export type ResolvedFinding = {
+    id: string;
+    state: "new" | "open" | "closed";
+    closeReason?: "fixed" | "file_reverted";
+    path: string | null;
+    lineFrom: number | null;
+    lineTo: number | null;
+    title: string;
+    bodyMd: string;
+    anchorText: string | null;
+    severity: string;
+    carriedFromId: string | null;
+    firstSeenReviewId: string | null;
+};
+export declare function anchorTextFromPatch(patch: string, from: number, to: number): string | null;
+export declare function relocate(anchorText: string | null, oldFrom: number, patch: string): {
+    from: number;
+    to: number;
+} | null;
+export declare function classifyCarryItems(previous: CarryPrevious, current: Revision, visiblePaths: Set<string>, currentGuideBuiltAt: string | null): CarryItem[];
+export declare function buildCarryPromptSection(items: CarryItem[], current: Revision): string;
+export type PreviousVerdict = {
+    id: string;
+    state: "open" | "closed";
+    path?: string;
+    from?: number;
+    to?: number;
+};
+export declare function parsePreviousVerdicts(markdown: string): PreviousVerdict[];
+export declare function findingsMarkdownForParse(markdown: string): string;
+export declare function resolveCarryOutcomes(items: CarryItem[], current: Revision, visiblePaths: Set<string>, verdicts: PreviousVerdict[], parsedNew: ParsedFinding[], currentGuideBuiltAt: string | null, previous: CarryPrevious): ResolvedFinding[];
+export declare function incrementalDiffPaths(current: Revision, previousFiles: RevisionFile[] | null): {
+    changed: RevisionFile[];
+    unchanged: string[];
+};

package/dist/src/review/carry_over.js

@@ -0,0 +1,372 @@
+import { spansOverlap } from "../pr/rounds.js";
+import { rightLines } from "../pr/hunks.js";
+import { normalizeAnchor, normalizeBody, normalizePath, revisionFilesEquivalent, resolvePathAfterRename, } from "./revision.js";
+export function anchorTextFromPatch(patch, from, to) {
+    const lines = rightLines(patch);
+    const low = Math.min(from, to);
+    const high = Math.max(from, to);
+    const picked = [];
+    for (let line = low; line <= high; line++) {
+        const text = lines.get(line);
+        if (text === undefined)
+            return null;
+        picked.push(text.replace(/\r$/, "").trimEnd());
+    }
+    return picked.length ? picked.join("\n") : null;
+}
+function anchorInPatch(anchor, patch) {
+    if (!anchor)
+        return false;
+    const want = normalizeAnchor(anchor).split("\n");
+    const numbered = [...rightLines(patch).entries()].sort((a, b) => a[0] - b[0]);
+    for (let i = 0; i <= numbered.length - want.length; i++) {
+        let ok = true;
+        for (let j = 0; j < want.length; j++) {
+            if (normalizeAnchor(numbered[i + j][1]) !== want[j]) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return true;
+    }
+    return false;
+}
+export function relocate(anchorText, oldFrom, patch) {
+    if (!anchorText)
+        return null;
+    const want = normalizeAnchor(anchorText).split("\n");
+    if (want.length === 0)
+        return null;
+    const numbered = [...rightLines(patch).entries()].sort((a, b) => a[0] - b[0]);
+    const matches = [];
+    for (let i = 0; i <= numbered.length - want.length; i++) {
+        let ok = true;
+        for (let j = 0; j < want.length; j++) {
+            if (normalizeAnchor(numbered[i + j][1]) !== want[j]) {
+                ok = false;
+                break;
+            }
+        }
+        if (!ok)
+            continue;
+        const from = numbered[i][0];
+        const to = numbered[i + want.length - 1][0];
+        matches.push({
+            from,
+            to,
+            distance: Math.abs(from - oldFrom),
+        });
+    }
+    if (matches.length === 0)
+        return null;
+    if (want.length === 1 && want[0].length < 12 && matches.length > 1) {
+        return null;
+    }
+    matches.sort((a, b) => a.distance - b.distance || a.from - b.from);
+    const best = matches[0];
+    return { from: best.from, to: best.to };
+}
+function guideChanged(previous, currentGuideBuiltAt) {
+    return (previous.guideBuiltAt ?? "") !== (currentGuideBuiltAt ?? "");
+}
+export function classifyCarryItems(previous, current, visiblePaths, currentGuideBuiltAt) {
+    const currentByPath = new Map(current.files.map((file) => [normalizePath(file.path), file]));
+    const items = [];
+    for (const finding of previous.findings) {
+        const targetPath = finding.path
+            ? resolvePathAfterRename(current, finding.path)
+            : null;
+        const file = targetPath
+            ? currentByPath.get(normalizePath(targetPath))
+            : undefined;
+        const lineFrom = finding.lineFrom ?? 0;
+        const lineTo = finding.lineTo ?? lineFrom;
+        let klass = "verify_unlocated";
+        const prevFile = finding.path
+            ? previous.files.find((f) => normalizePath(f.path) === normalizePath(finding.path))
+            : undefined;
+        const prevPatch = prevFile?.patch ?? "";
+        const sameBody = Boolean(prevFile && file && revisionFilesEquivalent(prevFile, file));
+        if (!finding.path) {
+            klass = "unverifiable";
+        }
+        else if (!targetPath || !file) {
+            klass = "file_reverted";
+        }
+        else if (file.status === "removed") {
+            klass = "file_removed";
+        }
+        else if (finding.path &&
+            !previous.visiblePaths.has(normalizePath(finding.path))) {
+            klass = "unverifiable";
+        }
+        else if (sameBody) {
+            klass = "unchanged";
+        }
+        else if (!visiblePaths.has(normalizePath(file.path))) {
+            klass = "unverifiable";
+        }
+        else if (guideChanged(previous, currentGuideBuiltAt)) {
+            klass = "verify_guide_changed";
+        }
+        else {
+            if (anchorInPatch(finding.anchorText, file.patch)) {
+                klass = "verify_present";
+            }
+            else if (finding.anchorText &&
+                finding.anchorText
+                    .split("\n")
+                    .every((line) => line.trim().startsWith("+"))) {
+                klass = "verify_likely_fixed";
+            }
+            else {
+                klass = "verify_unlocated";
+            }
+        }
+        items.push({
+            id: finding.id,
+            finding,
+            class: klass,
+            targetPath,
+            lineFrom,
+            lineTo,
+        });
+    }
+    return items;
+}
+const VERIFY_HINT = {
+    file_reverted: "",
+    file_removed: "",
+    unverifiable: "",
+    verify_guide_changed: "review guide was rebuilt",
+    unchanged: "",
+    verify_present: "still present in changed code",
+    verify_likely_fixed: "anchored code no longer found",
+    verify_unlocated: "could not locate",
+};
+export function buildCarryPromptSection(items, current) {
+    const verify = [];
+    const unchanged = [];
+    let index = 0;
+    for (const item of items) {
+        if (item.class === "file_reverted" || item.class === "file_removed") {
+            continue;
+        }
+        if (item.class === "unchanged") {
+            const file = current.files.find((f) => normalizePath(f.path) === normalizePath(item.targetPath ?? ""));
+            const relocated = file
+                ? relocate(item.finding.anchorText, item.lineFrom, file.patch)
+                : null;
+            const from = relocated?.from ?? item.lineFrom;
+            const to = relocated?.to ?? item.lineTo;
+            unchanged.push(`- ${item.targetPath}:${from}${to !== from ? `-${to}` : ""} · ${item.finding.title}`);
+            continue;
+        }
+        if (item.class === "unverifiable") {
+            continue;
+        }
+        index++;
+        const label = `F${index}`;
+        item.promptId = label;
+        const loc = item.targetPath
+            ? `${item.targetPath}:${item.lineFrom}${item.lineTo !== item.lineFrom ? `-${item.lineTo}` : ""}`
+            : "";
+        const body = item.finding.bodyMd.slice(0, 600);
+        verify.push(`${label} · ${VERIFY_HINT[item.class]} · ${loc}\n${item.finding.title}\n${body}`);
+    }
+    if (verify.length === 0 && unchanged.length === 0)
+        return "";
+    const lines = [
+        "PREVIOUS FINDINGS:",
+        "These were raised by an earlier review of this same change. For each one",
+        "listed under VERIFY, decide whether the code in the DIFF still has the",
+        'problem. Report every decision in a final "## Previous findings" section,',
+        'one line per id, exactly as "- F1: open path:from-to" or "- F1: closed".',
+        'Do not repeat an open previous finding under "## Findings".',
+        "",
+    ];
+    if (verify.length) {
+        lines.push("VERIFY:", verify.join("\n\n"), "");
+    }
+    if (unchanged.length) {
+        lines.push("STILL OPEN, UNCHANGED (do not report again):", unchanged.join("\n"), "");
+    }
+    return lines.join("\n");
+}
+export function parsePreviousVerdicts(markdown) {
+    const heading = markdown.search(/^## Previous findings\b/im);
+    if (heading === -1)
+        return [];
+    const section = markdown.slice(heading);
+    const verdicts = [];
+    const lineRe = /^-\s*(F\d+)\s*:\s*(open|closed)(?:\s+([^:\s]+):(\d+)(?:-(\d+))?)?\s*$/im;
+    for (const line of section.split("\n")) {
+        const match = lineRe.exec(line.trim());
+        if (!match)
+            continue;
+        verdicts.push({
+            id: match[1],
+            state: match[2].toLowerCase(),
+            path: match[3],
+            from: match[4] ? Number(match[4]) : undefined,
+            to: match[5] ? Number(match[5]) : match[4] ? Number(match[4]) : undefined,
+        });
+    }
+    return verdicts;
+}
+export function findingsMarkdownForParse(markdown) {
+    const cut = markdown.search(/^## Previous findings\b/im);
+    return cut === -1 ? markdown : markdown.slice(0, cut);
+}
+export function resolveCarryOutcomes(items, current, visiblePaths, verdicts, parsedNew, currentGuideBuiltAt, previous) {
+    const verdictByPromptId = new Map(verdicts.map((v) => [v.id, v]));
+    const promptIds = new Map();
+    let seq = 0;
+    for (const item of items) {
+        if (item.class === "file_reverted" ||
+            item.class === "file_removed" ||
+            item.class === "unchanged" ||
+            item.class === "unverifiable") {
+            continue;
+        }
+        seq++;
+        promptIds.set(item.finding.id, `F${seq}`);
+    }
+    const resolved = [];
+    const openForMerge = [];
+    for (const item of items) {
+        const base = item.finding;
+        if (item.class === "file_reverted") {
+            resolved.push({
+                id: crypto.randomUUID(),
+                state: "closed",
+                closeReason: "file_reverted",
+                path: base.path,
+                lineFrom: base.lineFrom,
+                lineTo: base.lineTo,
+                title: base.title,
+                bodyMd: base.bodyMd,
+                anchorText: base.anchorText,
+                severity: base.severity,
+                carriedFromId: base.id,
+                firstSeenReviewId: base.firstSeenReviewId,
+            });
+            continue;
+        }
+        if (item.class === "file_removed") {
+            resolved.push({
+                id: crypto.randomUUID(),
+                state: "closed",
+                closeReason: "fixed",
+                path: base.path,
+                lineFrom: base.lineFrom,
+                lineTo: base.lineTo,
+                title: base.title,
+                bodyMd: base.bodyMd,
+                anchorText: base.anchorText,
+                severity: base.severity,
+                carriedFromId: base.id,
+                firstSeenReviewId: base.firstSeenReviewId,
+            });
+            continue;
+        }
+        const file = item.targetPath
+            ? current.files.find((f) => normalizePath(f.path) === normalizePath(item.targetPath))
+            : undefined;
+        let lineFrom = item.lineFrom;
+        let lineTo = item.lineTo;
+        if (item.class === "unchanged" && file) {
+            const moved = relocate(base.anchorText, lineFrom, file.patch);
+            if (moved) {
+                lineFrom = moved.from;
+                lineTo = moved.to;
+            }
+        }
+        if (item.class === "unchanged" || item.class === "unverifiable") {
+            const row = {
+                id: crypto.randomUUID(),
+                state: "open",
+                path: item.targetPath ?? base.path,
+                lineFrom,
+                lineTo,
+                title: base.title,
+                bodyMd: base.bodyMd,
+                anchorText: file
+                    ? anchorTextFromPatch(file.patch, lineFrom, lineTo)
+                    : base.anchorText,
+                severity: base.severity,
+                carriedFromId: base.id,
+                firstSeenReviewId: base.firstSeenReviewId,
+            };
+            resolved.push(row);
+            openForMerge.push(row);
+            continue;
+        }
+        const promptId = promptIds.get(base.id);
+        const verdict = promptId ? verdictByPromptId.get(promptId) : undefined;
+        const state = verdict?.state ?? "open";
+        const anchor = file && verdict?.path
+            ? anchorTextFromPatch(file.patch, verdict.from ?? lineFrom, verdict.to ?? verdict.from ?? lineTo)
+            : base.anchorText;
+        const row = {
+            id: crypto.randomUUID(),
+            state,
+            path: verdict?.path ?? item.targetPath ?? base.path,
+            lineFrom: verdict?.from ?? lineFrom,
+            lineTo: verdict?.to ?? verdict?.from ?? lineTo,
+            title: base.title,
+            bodyMd: base.bodyMd,
+            anchorText: anchor,
+            severity: base.severity,
+            carriedFromId: base.id,
+            firstSeenReviewId: base.firstSeenReviewId,
+        };
+        resolved.push(row);
+        if (state === "open")
+            openForMerge.push(row);
+    }
+    for (const finding of parsedNew) {
+        const overlap = openForMerge.find((open) => open.path &&
+            spansOverlap({ path: open.path, from: open.lineFrom ?? 0, to: open.lineTo ?? 0 }, finding));
+        if (overlap) {
+            overlap.bodyMd = finding.excerpt;
+            overlap.title = finding.heading || finding.path;
+            overlap.lineFrom = finding.from;
+            overlap.lineTo = finding.to;
+            continue;
+        }
+        resolved.push({
+            id: crypto.randomUUID(),
+            state: "new",
+            path: finding.path,
+            lineFrom: finding.from,
+            lineTo: finding.to,
+            title: finding.heading || finding.path,
+            bodyMd: finding.excerpt,
+            anchorText: null,
+            severity: finding.severity ?? "P2",
+            carriedFromId: null,
+            firstSeenReviewId: null,
+        });
+    }
+    return resolved;
+}
+export function incrementalDiffPaths(current, previousFiles) {
+    if (!previousFiles) {
+        return { changed: current.files, unchanged: [] };
+    }
+    const prevByPath = new Map(previousFiles.map((file) => [normalizePath(file.path), file]));
+    const changed = [];
+    const unchanged = [];
+    for (const file of current.files) {
+        const prev = prevByPath.get(normalizePath(file.path));
+        if (!prev || !revisionFilesEquivalent(prev, file)) {
+            changed.push(file);
+        }
+        else {
+            unchanged.push(file.path);
+        }
+    }
+    return { changed, unchanged };
+}

package/dist/src/review/engine.d.ts

@@ -0,0 +1,13 @@
+/** Review prompt, tool loop, and improvement passes — PR adapter calls this
+ * after building a `Revision` and carry-over input. */
+import type { GitHubClient, Options } from "../types.ts";
+import type { Snapshot } from "../pr/snapshot.ts";
+import type { AiProvider, AiResponse } from "../types.ts";
+import { type ReviewExtras } from "../pr/reviewer.ts";
+type UsageSink = (response: AiResponse) => Promise<void>;
+type ProgressSink = (message: string) => void;
+export declare function runReviewEngine(client: GitHubClient, options: Options, usage?: UsageSink, snapshot?: Snapshot, ai?: AiProvider, progress?: ProgressSink, extras?: ReviewExtras): Promise<AiResponse & {
+    visiblePaths: string[];
+    guideBuiltAt: string | null;
+}>;
+export {};

package/dist/src/review/engine.js

@@ -0,0 +1,4 @@
+import { reviewPullRequest } from "../pr/reviewer.js";
+export async function runReviewEngine(client, options, usage, snapshot, ai, progress, extras) {
+    return reviewPullRequest(client, options, usage, snapshot, ai, progress, extras);
+}

package/dist/src/review/guides.d.ts

@@ -0,0 +1,12 @@
+export declare function knowledgeLockKey(repo: string): string;
+export type LoadedGuides = {
+    shortGuide: string;
+    detailed: string;
+    codebase: string;
+    skill: string;
+    guideBuiltAt: string | null;
+};
+/** Reads all review guides and `knowledge_built_at` under one lock so every
+ * file belongs to the same generation. */
+export declare function loadGuides(repo: string): Promise<LoadedGuides>;
+export declare function withKnowledgeLock<T>(repo: string, fn: () => Promise<T>): Promise<T>;

package/dist/src/review/guides.js

@@ -0,0 +1,44 @@
+import { reposDir } from "../config.js";
+import { getRepo } from "../store/repos.js";
+import { withKeyedLock } from "../util/keyed_lock.js";
+import { readTextFile } from "../util/runtime.js";
+export function knowledgeLockKey(repo) {
+    return `knowledge:${repo}`;
+}
+async function readGuideFile(repo, name) {
+    try {
+        return await readTextFile(`${reposDir()}/${repo}/${name}`);
+    }
+    catch {
+        return "";
+    }
+}
+/** Reads all review guides and `knowledge_built_at` under one lock so every
+ * file belongs to the same generation. */
+export async function loadGuides(repo) {
+    return withKeyedLock(knowledgeLockKey(repo), async () => {
+        const [shortGuide, detailed, codebase, skill] = await Promise.all([
+            readGuideFile(repo, "PR_REVIEW_GUIDE.md"),
+            readGuideFile(repo, "PR_REVIEW_DETAILED_GUIDE.md"),
+            readGuideFile(repo, "CODEBASE.md"),
+            readGuideFile(repo, "SKILL.md"),
+        ]);
+        let guideBuiltAt = null;
+        try {
+            guideBuiltAt = getRepo(repo)?.knowledge_built_at ?? null;
+        }
+        catch {
+            // Local CLI review without `serve` — guides still load from disk.
+        }
+        return {
+            shortGuide,
+            detailed,
+            codebase,
+            skill,
+            guideBuiltAt,
+        };
+    });
+}
+export async function withKnowledgeLock(repo, fn) {
+    return withKeyedLock(knowledgeLockKey(repo), fn);
+}

package/dist/src/review/revision.d.ts

@@ -0,0 +1,26 @@
+export type RevisionFileStatus = "added" | "modified" | "removed" | "renamed";
+export type RevisionFile = {
+    path: string;
+    previousPath: string | null;
+    status: RevisionFileStatus;
+    binary: boolean;
+    additions: number;
+    deletions: number;
+    patch: string;
+};
+export type Revision = {
+    files: RevisionFile[];
+    title: string;
+    description: string;
+    baseLabel: string;
+    producer: "github" | "local" | "remote";
+};
+export declare function normalizePath(path: string): string;
+/** Patch body for carry-over comparison (11.2). */
+/** Whether two revision files represent the same change for carry-over scope. */
+export declare function revisionFilesEquivalent(a: RevisionFile, b: RevisionFile): boolean;
+export declare function normalizeBody(patch: string): string;
+export declare function normalizeAnchor(text: string): string;
+export declare function revisionHash(revision: Revision): Promise<string>;
+export declare function fileByPath(revision: Revision, path: string): RevisionFile | undefined;
+export declare function resolvePathAfterRename(revision: Revision, previousPath: string | null): string | null;

package/dist/src/review/revision.js

@@ -0,0 +1,57 @@
+export function normalizePath(path) {
+    return path.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+/** Patch body for carry-over comparison (11.2). */
+/** Whether two revision files represent the same change for carry-over scope. */
+export function revisionFilesEquivalent(a, b) {
+    if (a.status !== b.status)
+        return false;
+    if (a.binary !== b.binary)
+        return false;
+    if (a.additions !== b.additions || a.deletions !== b.deletions)
+        return false;
+    if ((a.previousPath ?? "") !== (b.previousPath ?? ""))
+        return false;
+    return normalizeBody(a.patch) === normalizeBody(b.patch);
+}
+export function normalizeBody(patch) {
+    const lines = patch.split("\n").flatMap((line) => {
+        if (line.startsWith("@@"))
+            return ["@@"];
+        if (line === "\")
+            return [];
+        return [line.replace(/\r$/, "").trimEnd()];
+    });
+    return lines.join("\n");
+}
+export function normalizeAnchor(text) {
+    return text
+        .split("\n")
+        .map((line) => line.trim().replace(/\s+/g, " "))
+        .filter(Boolean)
+        .join("\n");
+}
+export async function revisionHash(revision) {
+    const parts = [];
+    const files = [...revision.files].sort((a, b) => a.path.localeCompare(b.path));
+    for (const file of files) {
+        parts.push(file.path, file.status, file.previousPath ?? "", String(file.binary), normalizeBody(file.patch));
+    }
+    const data = new TextEncoder().encode(parts.join("\0"));
+    const digest = await crypto.subtle.digest("SHA-256", data);
+    return [...new Uint8Array(digest)]
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+export function fileByPath(revision, path) {
+    const normalized = normalizePath(path);
+    return revision.files.find((file) => normalizePath(file.path) === normalized);
+}
+export function resolvePathAfterRename(revision, previousPath) {
+    if (!previousPath)
+        return null;
+    const renamed = revision.files.find((file) => file.status === "renamed" &&
+        file.previousPath &&
+        normalizePath(file.previousPath) === normalizePath(previousPath));
+    return renamed ? renamed.path : previousPath;
+}

package/dist/src/server/api/activity.d.ts

@@ -0,0 +1 @@
+export declare function handleActivityRoute(request: Request, url: URL): Response;

package/dist/src/server/api/activity.js

@@ -0,0 +1,12 @@
+import { errorResponse } from "../errors.js";
+import { activityFeed, skippedDeliveries } from "../../services/dashboard.js";
+export function handleActivityRoute(request, url) {
+    if (url.pathname === "/api/activity" && request.method === "GET") {
+        const page = Number(url.searchParams.get("page") ?? 1);
+        return Response.json(activityFeed(page, 20));
+    }
+    if (url.pathname === "/api/activity/skipped" && request.method === "GET") {
+        return Response.json({ items: skippedDeliveries() });
+    }
+    return errorResponse(404, "not_found", `no route for ${url.pathname}`);
+}

package/dist/src/server/api/analytics.d.ts

@@ -0,0 +1 @@
+export declare function handleAnalyticsRoute(request: Request, url: URL): Response;

package/dist/src/server/api/analytics.js

@@ -0,0 +1,9 @@
+import { errorResponse } from "../errors.js";
+import { statsForRange } from "../../services/dashboard.js";
+export function handleAnalyticsRoute(request, url) {
+    if (url.pathname === "/api/analytics" && request.method === "GET") {
+        const range = url.searchParams.get("range") ?? "30d";
+        return Response.json(statsForRange(range));
+    }
+    return errorResponse(404, "not_found", `no route for ${url.pathname}`);
+}

package/dist/src/server/api/installations.d.ts

@@ -0,0 +1,4 @@
+export declare function handleInstallationsRoute(request: Request, githubApp: {
+    appId: string;
+    privateKeyPem: string;
+} | undefined): Promise<Response>;

package/dist/src/server/api/installations.js

@@ -0,0 +1,24 @@
+import { errorResponse } from "../errors.js";
+import { listInstallationsWithRepos } from "../../github/app.js";
+import { getRepo } from "../../store/repos.js";
+export async function handleInstallationsRoute(request, githubApp) {
+    if (request.method !== "GET") {
+        return errorResponse(404, "not_found", "no route for /api/installations");
+    }
+    if (!githubApp) {
+        return errorResponse(422, "app_not_configured", "GitHub App is not configured; run: co-maintainer set --github-app-id=... --github-app-private-key=...");
+    }
+    const installations = await listInstallationsWithRepos(githubApp.appId, githubApp.privateKeyPem);
+    return Response.json({
+        items: installations.map(({ installation, repos }) => ({
+            id: installation.id,
+            accountLogin: installation.account?.login ?? "",
+            suspended: installation.suspended_at !== null,
+            repos: repos.map((repo) => ({
+                fullName: repo.fullName,
+                private: repo.private,
+                alreadyActive: Boolean(getRepo(repo.fullName)?.active),
+            })),
+        })),
+    });
+}

package/dist/src/server/api/jobs.d.ts

@@ -0,0 +1 @@
+export declare function handleJobsRoute(request: Request, url: URL): Response;