co-maintainer 0.4.0-beta.1

package/dist/src/cli/review_result.js

@@ -0,0 +1,281 @@
+import { parseFindings } from "../pr/findings.js";
+import { readSuggestion, stripSuggestion } from "../pr/suggestion.js";
+import { anchorTextFromPatch, } from "../review/carry_over.js";
+import { humanCopy } from "../services/review.js";
+const SEVERITY_RANK = {
+    P0: 0,
+    P1: 1,
+    P2: 2,
+    P3: 3,
+};
+export function isBlockingFinding(title, severity) {
+    if (/\[P0\b/i.test(title) || /^P0$/i.test(severity))
+        return true;
+    if (/\[P\d\s*·\s*blocking\]/i.test(title))
+        return true;
+    return false;
+}
+export function resolvedFromFirstReview(parsed, filesByPath) {
+    return parsed.map((finding) => {
+        const file = finding.path ? filesByPath.get(finding.path) : undefined;
+        const anchor = file && finding.from
+            ? anchorTextFromPatch(file.patch, finding.from, finding.to ?? finding.from)
+            : null;
+        return {
+            id: crypto.randomUUID(),
+            state: "new",
+            path: finding.path,
+            lineFrom: finding.from,
+            lineTo: finding.to,
+            title: finding.heading || finding.path,
+            bodyMd: finding.excerpt,
+            anchorText: anchor,
+            severity: finding.severity ?? "P2",
+            carriedFromId: null,
+            firstSeenReviewId: null,
+        };
+    });
+}
+function compareFindings(a, b) {
+    const stateOrder = { new: 0, open: 1, closed: 2 };
+    const ds = stateOrder[a.state] - stateOrder[b.state];
+    if (ds !== 0)
+        return ds;
+    const sa = SEVERITY_RANK[a.severity] ?? 9;
+    const sb = SEVERITY_RANK[b.severity] ?? 9;
+    if (sa !== sb)
+        return sa - sb;
+    const pa = a.path ?? "";
+    const pb = b.path ?? "";
+    if (pa !== pb)
+        return pa.localeCompare(pb);
+    return (a.lineFrom ?? 0) - (b.lineFrom ?? 0);
+}
+export function sortResolvedFindings(findings) {
+    return [...findings].sort(compareFindings);
+}
+export function toJsonFinding(row) {
+    const suggestion = readSuggestion(row.bodyMd);
+    return {
+        id: row.id,
+        state: row.state,
+        closeReason: row.closeReason ?? null,
+        severity: row.severity,
+        blocking: isBlockingFinding(row.title, row.severity),
+        path: row.path,
+        lineFrom: row.lineFrom,
+        lineTo: row.lineTo,
+        title: humanCopy(row.title),
+        body: humanCopy(stripSuggestion(row.bodyMd)),
+        suggestion: suggestion
+            ? {
+                lineFrom: suggestion.from,
+                lineTo: suggestion.to,
+                text: suggestion.code,
+            }
+            : null,
+    };
+}
+export function revisionStats(revision) {
+    let additions = 0;
+    let deletions = 0;
+    for (const file of revision.files) {
+        additions += file.additions;
+        deletions += file.deletions;
+    }
+    return {
+        files: revision.files.length,
+        additions,
+        deletions,
+        truncated: false,
+    };
+}
+export function summaryCounts(findings) {
+    let blocking = 0;
+    for (const row of findings) {
+        if ((row.state === "new" || row.state === "open") &&
+            isBlockingFinding(row.title, row.severity)) {
+            blocking++;
+        }
+    }
+    return {
+        new: findings.filter((f) => f.state === "new").length,
+        open: findings.filter((f) => f.state === "open").length,
+        closed: findings.filter((f) => f.state === "closed").length,
+        blocking,
+    };
+}
+export function reviewExitCodeFromResolved(findings) {
+    return summaryCounts(findings).blocking > 0 ? 1 : 0;
+}
+function locationLabel(row) {
+    if (!row.path)
+        return row.title;
+    const from = row.lineFrom ?? 0;
+    const to = row.lineTo ?? from;
+    const span = from === to ? `${from}` : `${from}-${to}`;
+    return `${row.path}:${span}`;
+}
+function shortTitle(row) {
+    const title = humanCopy(row.title);
+    const dash = title.indexOf(" — ");
+    return dash === -1
+        ? title
+        : title
+            .slice(dash + 3)
+            .replace(/^`|`$/g, "")
+            .trim();
+}
+function impactLabel(row) {
+    const blocking = isBlockingFinding(row.title, row.severity);
+    return `[${row.severity} · ${blocking ? "blocking" : "non-blocking"}]`;
+}
+/** Plan §9.1 human-readable local review output. */
+export function formatHumanLocalReview(header, revision, guideBuiltAt, codegraphState, findings, warnings) {
+    const stats = revisionStats(revision);
+    const guideBit = guideBuiltAt
+        ? `guide ${guideBuiltAt.slice(0, 10)}`
+        : "guide unknown";
+    const cgBit = codegraphState === "used"
+        ? "codegraph used"
+        : codegraphState === "disabled"
+            ? "codegraph disabled"
+            : "codegraph unavailable";
+    const lines = [
+        header,
+        `${stats.files} files · +${stats.additions} −${stats.deletions} · ${guideBit} · ${cgBit}`,
+        "",
+    ];
+    const sorted = sortResolvedFindings(findings);
+    const groups = [
+        { label: "Closed", state: "closed", bullet: "✓" },
+        { label: "Still open", state: "open", bullet: "•" },
+        { label: "New", state: "new", bullet: "•" },
+    ];
+    let any = false;
+    for (const group of groups) {
+        const rows = sorted.filter((f) => f.state === group.state);
+        if (rows.length === 0)
+            continue;
+        any = true;
+        lines.push(`${group.label} (${rows.length})`);
+        for (const row of rows) {
+            const loc = locationLabel(row);
+            const head = `${group.bullet} ${loc}  ${impactLabel(row)} ${shortTitle(row)}`;
+            lines.push(`  ${head}`);
+            if (row.state !== "closed") {
+                const body = humanCopy(stripSuggestion(row.bodyMd)).trim();
+                if (body) {
+                    for (const part of body.split("\n")) {
+                        lines.push(`    ${part}`);
+                    }
+                    const suggestion = readSuggestion(row.bodyMd);
+                    if (suggestion && row.path) {
+                        lines.push(`    Suggested replacement for ${row.path}:${suggestion.from}${suggestion.to !== suggestion.from ? `-${suggestion.to}` : ""}`);
+                        lines.push("    ```");
+                        for (const part of suggestion.code.split("\n")) {
+                            lines.push(`    ${part}`);
+                        }
+                        lines.push("    ```");
+                    }
+                }
+            }
+        }
+        lines.push("");
+    }
+    if (!any) {
+        lines.push("No actionable findings.");
+        lines.push("");
+    }
+    const counts = summaryCounts(findings);
+    lines.push(`Summary: ${counts.new} new · ${counts.open} open · ${counts.closed} closed · ${counts.blocking} blocking`);
+    if (warnings.length) {
+        lines.push("Warnings:");
+        for (const w of warnings)
+            lines.push(`  - ${w.message}`);
+    }
+    return lines.join("\n");
+}
+/** Human-readable findings block for remote sync JSON (same shape as `toJsonFinding`). */
+export function formatHumanJsonFindings(findings) {
+    if (findings.length === 0) {
+        return "## Findings\n\nNo actionable findings.";
+    }
+    const lines = ["## Findings", ""];
+    const sorted = [...findings].sort((a, b) => (SEVERITY_RANK[a.severity] ?? 9) - (SEVERITY_RANK[b.severity] ?? 9));
+    for (const row of sorted) {
+        const blocking = row.blocking || isBlockingFinding(row.title, row.severity);
+        const impact = `[${row.severity} · ${blocking ? "blocking" : "non-blocking"}]`;
+        let prefix = "";
+        if (row.path) {
+            const from = row.lineFrom ?? 0;
+            const to = row.lineTo ?? from;
+            const span = from === to ? `${from}` : `${from}-${to}`;
+            prefix = `${row.path}:${span}  `;
+        }
+        lines.push(`- ${prefix}${impact} ${row.title}`);
+        const body = row.body.trim();
+        if (body) {
+            for (const part of body.split("\n")) {
+                lines.push(`  ${part}`);
+            }
+        }
+        if (row.suggestion && row.path) {
+            const { lineFrom, lineTo, text } = row.suggestion;
+            lines.push(`  Suggested replacement for ${row.path}:${lineFrom}${lineTo !== lineFrom ? `-${lineTo}` : ""}`);
+            lines.push("  ```");
+            for (const part of text.split("\n")) {
+                lines.push(`  ${part}`);
+            }
+            lines.push("  ```");
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+}
+export function reviewExitCodeFromJsonFindings(findings) {
+    return findings.some((f) => f.blocking || isBlockingFinding(f.title, f.severity))
+        ? 1
+        : 0;
+}
+export function buildPrReviewJson(input) {
+    const findings = resolvedFromFirstReview(parseFindings(input.markdown), new Map());
+    const sorted = sortResolvedFindings(findings);
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: true,
+        mode: "pr",
+        subject: { repo: input.repo, branch: null, prNumber: input.prNumber },
+        guide: { builtAt: input.guideBuiltAt },
+        codegraph: {
+            state: input.codegraphState,
+            reason: input.codegraphReason,
+        },
+        summary: summaryCounts(findings),
+        findings: sorted.map(toJsonFinding),
+        warnings: [],
+        usage: input.usage,
+        durationMs: input.durationMs,
+    });
+}
+export function buildLocalReviewJson(input) {
+    const sorted = sortResolvedFindings(input.findings);
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: true,
+        mode: "local",
+        subject: { repo: input.repo, branch: input.branch, prNumber: null },
+        base: { toBranch: input.baseLabel, label: input.baseLabel },
+        revision: revisionStats(input.revision),
+        guide: { builtAt: input.guideBuiltAt },
+        codegraph: {
+            state: input.codegraphState,
+            reason: input.codegraphReason,
+        },
+        summary: summaryCounts(input.findings),
+        findings: sorted.map(toJsonFinding),
+        warnings: input.warnings,
+        usage: input.usage,
+        durationMs: input.durationMs,
+    });
+}

package/dist/src/config.d.ts

@@ -0,0 +1,108 @@
+import { type Platform } from "./util/runtime.ts";
+/** Everything init/remake resolved for one repo, except secrets — an API
+ * token is never written to config.json, only ever taken from --token or
+ * an env file. Remembering this lets `remake owner/repo` run with no
+ * flags and no interactive prompts, reusing what `init` was told. */
+export type RepoConfig = {
+    auth?: "gh" | "pat";
+    ai?: "none" | "openrouter" | "hetzner";
+    lowModel?: string;
+    highModel?: string;
+    maxCommits?: number;
+    maxPrMonths?: number;
+    maxPullRequestChangeLines?: number;
+    maxComments?: number;
+    includeCodebase?: boolean;
+    includePullRequests?: boolean;
+    includePullRequestChanges?: boolean;
+    includeCommitHistory?: boolean;
+    includeHowRepoWorks?: boolean;
+};
+export type UserConfig = {
+    auth?: "gh" | "pat";
+    ai?: "none" | "openrouter" | "hetzner";
+    lowModel?: string;
+    highModel?: string;
+    /** Written only by `co-maintainer set --token=...`. Every other write
+     * path (writeRepoConfig, init/remake) must never put a secret here. */
+    token?: string;
+    /** GitHub Personal Access Token, used when `--auth=pat`. Only ever
+     * written by `set --github-pat=...`. */
+    githubPat?: string;
+    /** GitHub App credentials for `co-maintainer serve` — also only ever
+     * written by `set`. `githubWebhookSecret` is optional. */
+    githubAppId?: string;
+    githubAppPrivateKey?: string;
+    githubWebhookSecret?: string;
+    webhookUrl?: string;
+    /** "Sign in with GitHub" for the dashboard, reusing the App's own OAuth
+     * client — only `githubOAuthAllowedUser` may complete it. All three only
+     * ever written by `set`. */
+    githubOAuthClientId?: string;
+    githubOAuthClientSecret?: string;
+    githubOAuthAllowedUser?: string;
+    /** Which sign-in methods `serve` accepts by default; a `--disable-auth`/
+     * `--enable-auth` flag on the `serve` command overrides these per run. */
+    passwordAuthDisabled?: boolean;
+    githubAuthEnabled?: boolean;
+    defaults?: {
+        maxCommits?: number;
+        maxPrMonths?: number;
+        maxPullRequestChangeLines?: number;
+    };
+    /** Cap on jobs running at once across all types. Unset means no limit. */
+    maxConcurrentJobs?: number;
+    /** Remote review CLI target (`co-maintainer set`). */
+    remoteHost?: string;
+    /** Bearer token for `/api/remote/*`; only written by `set`. */
+    remoteToken?: string;
+    /** Hosts for which the unpublished-code notice was shown (plan §14.1 G13). */
+    remoteNoticeShownFor?: string[];
+    /** Remote client watchdog timeout; dashboard may override (plan §19.6). */
+    remoteSyncTimeoutSeconds?: number;
+    maxConcurrentRemoteReviewsPerToken?: number;
+    remoteToolOutputMaxChars?: number;
+    repos?: Record<string, RepoConfig>;
+};
+/** Platform/env injection keeps the OS branches testable (plan §0b): the
+ * migration's `"windows"` vs `"win32"` trap is invisible otherwise. */
+export declare function getConfigDir(os?: Platform, env?: (name: string) => string | undefined): string;
+export declare function getCacheDir(os?: Platform, env?: (name: string) => string | undefined): string;
+/** `CM_CONFIG_PATH` overrides the path — tests point it at a temp file so
+ * they never read or write the real config.json. */
+export declare function configPath(): string;
+/** Where generated skills (SKILL.md, CODEBASE.md, review guides) live.
+ * Never relative to the current directory — a globally installed CLI can be
+ * invoked from anywhere, including directories it has no permission to
+ * write into (e.g. C:\Windows\System32). */
+export declare function reposDir(): string;
+/** Third-party binaries co-maintainer installs for itself, never onto the
+ * user's global PATH. Each tool lives under its own version directory so an
+ * upgrade installs alongside the old one instead of over it, and a rollback is
+ * just pointing at the previous directory. */
+export declare function toolsDir(): string;
+/** A short, stable directory name for a repository. Full `owner-repo` names
+ * blow the Windows 260 character path limit once a deep source tree is checked
+ * out under them: typescript-eslint's longest path is 169 characters on its
+ * own, which leaves under 91 for everything above it. */
+export declare function repoSlug(repo: string): string;
+/** Clones and worktrees are large, disposable and rebuildable in seconds, so
+ * they belong beside the cache rather than in the config directory, which on
+ * Windows is the roaming profile and gets synced across machines. */
+export declare function clonesDir(): string;
+export declare function cloneDir(repo: string): string;
+export declare function worktreeDir(repo: string, pr: number): string;
+export declare function cacheDbPath(): string;
+export declare function loadEnvFile(path: string): void;
+export declare function readConfig(): UserConfig;
+/** Merges `patch` into `repos[repo]` in config.json, dropping undefined
+ * fields. Never call this with a token or other secret. */
+export declare function writeRepoConfig(repo: string, patch: RepoConfig): Promise<void>;
+/** Merges `patch` into the top-level (global, cross-repo) config —
+ * used by `co-maintainer set`. This is the only path allowed to persist
+ * a token. */
+export declare function writeUserConfig(patch: Partial<UserConfig>): Promise<void>;
+export declare function prepareConfig(args: string[]): {
+    config: UserConfig;
+    envPath?: string;
+};

package/dist/src/config.js

@@ -0,0 +1,138 @@
+import { chmod, currentPlatform, getEnv, isNotFound, mkdir, readTextFileSync, setEnv, writeTextFile, } from "./util/runtime.js";
+function homeDir(env) {
+    const home = env("HOME") ?? env("USERPROFILE");
+    if (!home)
+        throw new Error("Could not determine the home directory");
+    return home;
+}
+/** Platform/env injection keeps the OS branches testable (plan §0b): the
+ * migration's `"windows"` vs `"win32"` trap is invisible otherwise. */
+export function getConfigDir(os = currentPlatform(), env = getEnv) {
+    const home = homeDir(env);
+    switch (os) {
+        case "windows":
+            return env("APPDATA") ?? `${home}\\AppData\\Roaming`;
+        case "darwin":
+            return `${home}/Library/Application Support`;
+        default:
+            return env("XDG_CONFIG_HOME") ?? `${home}/.config`;
+    }
+}
+export function getCacheDir(os = currentPlatform(), env = getEnv) {
+    const home = homeDir(env);
+    switch (os) {
+        case "windows":
+            return env("LOCALAPPDATA") ?? `${home}\\AppData\\Local`;
+        case "darwin":
+            return `${home}/Library/Caches`;
+        default:
+            return env("XDG_CACHE_HOME") ?? `${home}/.cache`;
+    }
+}
+/** `CM_CONFIG_PATH` overrides the path — tests point it at a temp file so
+ * they never read or write the real config.json. */
+export function configPath() {
+    return (getEnv("CM_CONFIG_PATH") ?? `${getConfigDir()}/co-maintainer/config.json`);
+}
+/** Where generated skills (SKILL.md, CODEBASE.md, review guides) live.
+ * Never relative to the current directory — a globally installed CLI can be
+ * invoked from anywhere, including directories it has no permission to
+ * write into (e.g. C:\Windows\System32). */
+export function reposDir() {
+    return getEnv("CM_REPOS_DIR") ?? `${getConfigDir()}/co-maintainer/repos`;
+}
+/** Third-party binaries co-maintainer installs for itself, never onto the
+ * user's global PATH. Each tool lives under its own version directory so an
+ * upgrade installs alongside the old one instead of over it, and a rollback is
+ * just pointing at the previous directory. */
+export function toolsDir() {
+    return getEnv("CM_TOOLS_DIR") ?? `${getConfigDir()}/co-maintainer/tools`;
+}
+/** A short, stable directory name for a repository. Full `owner-repo` names
+ * blow the Windows 260 character path limit once a deep source tree is checked
+ * out under them: typescript-eslint's longest path is 169 characters on its
+ * own, which leaves under 91 for everything above it. */
+export function repoSlug(repo) {
+    let hash = 2166136261;
+    for (let index = 0; index < repo.length; index++) {
+        hash ^= repo.charCodeAt(index);
+        hash = Math.imul(hash, 16777619) >>> 0;
+    }
+    return hash.toString(16).padStart(8, "0");
+}
+/** Clones and worktrees are large, disposable and rebuildable in seconds, so
+ * they belong beside the cache rather than in the config directory, which on
+ * Windows is the roaming profile and gets synced across machines. */
+export function clonesDir() {
+    return getEnv("CM_CLONES_DIR") ?? `${getCacheDir()}/co-maintainer/clones`;
+}
+export function cloneDir(repo) {
+    return `${clonesDir()}/${repoSlug(repo)}`;
+}
+export function worktreeDir(repo, pr) {
+    return `${getCacheDir()}/co-maintainer/wt/${repoSlug(repo)}/${pr}`;
+}
+export function cacheDbPath() {
+    return `${getCacheDir()}/co-maintainer/cache.db`;
+}
+export function loadEnvFile(path) {
+    const contents = readTextFileSync(path);
+    for (const line of contents.split(/\r?\n/)) {
+        const match = line.match(/^\s*(?:export\s+)?([A-Za-z_]\w*)\s*=\s*(.*)\s*$/);
+        if (!match)
+            continue;
+        let value = match[2].trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (getEnv(match[1]) === undefined)
+            setEnv(match[1], value);
+    }
+}
+export function readConfig() {
+    try {
+        return JSON.parse(readTextFileSync(configPath()));
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return {};
+        throw new Error(`Could not read config ${configPath()}: ${String(error)}`);
+    }
+}
+async function writeConfig(config) {
+    await mkdir(`${getConfigDir()}/co-maintainer`, { recursive: true });
+    const path = configPath();
+    await writeTextFile(path, `${JSON.stringify(config, null, 2)}\n`);
+    // config.json can hold an API token (see UserConfig.token) — keep it
+    // readable only by the current user where the platform supports it.
+    try {
+        await chmod(path, 0o600);
+    }
+    catch {
+        // Windows has no POSIX chmod; NotSupported there is expected.
+    }
+}
+/** Merges `patch` into `repos[repo]` in config.json, dropping undefined
+ * fields. Never call this with a token or other secret. */
+export async function writeRepoConfig(repo, patch) {
+    const config = readConfig();
+    const repos = { ...config.repos };
+    repos[repo] = Object.fromEntries(Object.entries({ ...repos[repo], ...patch }).filter(([, value]) => value !== undefined));
+    await writeConfig({ ...config, repos });
+}
+/** Merges `patch` into the top-level (global, cross-repo) config —
+ * used by `co-maintainer set`. This is the only path allowed to persist
+ * a token. */
+export async function writeUserConfig(patch) {
+    const config = readConfig();
+    const merged = Object.fromEntries(Object.entries({ ...config, ...patch }).filter(([, value]) => value !== undefined));
+    await writeConfig(merged);
+}
+export function prepareConfig(args) {
+    const envArg = args.find((arg) => arg.startsWith("--env="));
+    const envPath = envArg?.slice("--env=".length);
+    if (envPath)
+        loadEnvFile(envPath);
+    return { config: readConfig(), envPath };
+}

package/dist/src/git/default_branch.d.ts

@@ -0,0 +1,5 @@
+import type { Run } from "../pr/checkout.ts";
+/** `refs/remotes/<remote>/…` for scope and PR algorithms (plan §10.5). */
+export declare function detectDefaultBranchRef(cwd: string, remote: string, run: Run): Promise<string | undefined>;
+/** Short branch name (`main`) for `refs/remotes/<remote>/<branch>`. */
+export declare function resolveDefaultBranchName(cwd: string, remote: string, run: Run): Promise<string | undefined>;

package/dist/src/git/default_branch.js

@@ -0,0 +1,22 @@
+/** `refs/remotes/<remote>/…` for scope and PR algorithms (plan §10.5). */
+export async function detectDefaultBranchRef(cwd, remote, run) {
+    const symref = await run("git", ["symbolic-ref", "-q", `refs/remotes/${remote}/HEAD`], cwd);
+    if (symref.code === 0 && symref.stdout.trim()) {
+        return symref.stdout.trim();
+    }
+    for (const name of ["main", "master"]) {
+        const ref = `refs/remotes/${remote}/${name}`;
+        const probe = await run("git", ["rev-parse", "--verify", "-q", ref], cwd);
+        if (probe.code === 0)
+            return ref;
+    }
+    return undefined;
+}
+/** Short branch name (`main`) for `refs/remotes/<remote>/<branch>`. */
+export async function resolveDefaultBranchName(cwd, remote, run) {
+    const ref = await detectDefaultBranchRef(cwd, remote, run);
+    if (!ref)
+        return undefined;
+    const parts = ref.split("/");
+    return parts[parts.length - 1];
+}

package/dist/src/github/app.d.ts

@@ -0,0 +1,43 @@
+import type { GitHubClient } from "../types.ts";
+export type Installation = {
+    id: number;
+    account: {
+        login: string;
+        type: string;
+    } | null;
+    suspended_at: string | null;
+    permissions?: Record<string, string>;
+};
+/** App-level calls: list installations, mint an installation access token.
+ * Not scoped to one installation — `AppClient` below is. */
+export declare class AppJwtClient {
+    private readonly appId;
+    private readonly privateKeyPem;
+    constructor(appId: string, privateKeyPem: string);
+    private jwt;
+    listInstallations(): Promise<Installation[]>;
+    /** Cached until 60s before the token's own `expires_at`. */
+    installationToken(installationId: number): Promise<string>;
+}
+/** A `GitHubClient` scoped to one installation. */
+export declare class AppClient implements GitHubClient {
+    private readonly app;
+    private readonly installationId;
+    constructor(appId: string, privateKeyPem: string, installationId: number);
+    request<T>(endpoint: string): Promise<T>;
+    pages<T>(endpoint: string, limit?: number, progress?: (page: number, fetched: number) => void): Promise<T[]>;
+    write<T>(endpoint: string, body: unknown): Promise<T>;
+    createCheckRun<T>(endpoint: string, body: unknown): Promise<T>;
+    updateCheckRun<T>(endpoint: string, body: unknown): Promise<T>;
+}
+export type InstallationRepos = {
+    installation: Installation;
+    repos: {
+        fullName: string;
+        private: boolean;
+    }[];
+};
+/** For `GET /api/installations`: every installation the App has, each with
+ * the repos it can see. */
+export declare function listInstallationsWithRepos(appId: string, privateKeyPem: string): Promise<InstallationRepos[]>;
+export declare function findInstallationForRepo(appId: string, privateKeyPem: string, fullName: string): Promise<number | undefined>;