co-maintainer 0.5.0 → 0.5.1-beta.2

package/dist/src/github/permissions.js

@@ -0,0 +1,334 @@
+/** The one list of GitHub calls this codebase makes and what each needs.
+ *
+ * The App manifest, the App permission check on save, the 403 and 404 hints
+ * and the permission tables in the docs are all read from `ENDPOINTS`.
+ * `permissions.test.ts` scans the source for every endpoint it calls and fails
+ * when one is missing here, so a new call cannot ship without its permission. */
+/** Key order is the order the manifest and the doc tables list them in. */
+export const PERMISSION_LABEL = {
+    contents: "Contents",
+    issues: "Issues",
+    pull_requests: "Pull requests",
+    checks: "Checks",
+    metadata: "Metadata",
+};
+const ORDER = Object.keys(PERMISSION_LABEL);
+const READERS = ["gh", "pat", "app"];
+const APP_ONLY = ["app"];
+export const ENDPOINTS = [
+    {
+        method: "GET",
+        pattern: "repos/{repo}",
+        permission: "metadata",
+        level: "read",
+        identities: READERS,
+        feature: "Read the repository and its default branch",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/pulls",
+        permission: "pull_requests",
+        level: "read",
+        identities: READERS,
+        feature: "List pull requests",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/pulls/{n}",
+        permission: "pull_requests",
+        level: "read",
+        identities: READERS,
+        feature: "Read a pull request",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/pulls/{n}/files",
+        permission: "pull_requests",
+        level: "read",
+        identities: READERS,
+        feature: "Read the files a pull request changes",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/pulls/{n}/reviews",
+        permission: "pull_requests",
+        level: "read",
+        identities: READERS,
+        feature: "Read earlier reviews",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/pulls/{n}/comments",
+        permission: "pull_requests",
+        level: "read",
+        identities: READERS,
+        feature: "Read review comment threads",
+    },
+    {
+        method: "POST",
+        pattern: "repos/{repo}/pulls/{n}/reviews",
+        permission: "pull_requests",
+        level: "write",
+        identities: APP_ONLY,
+        feature: "Post a review",
+    },
+    {
+        method: "POST",
+        pattern: "repos/{repo}/pulls/{n}/comments",
+        permission: "pull_requests",
+        level: "write",
+        identities: APP_ONLY,
+        feature: "Reply in a review comment thread",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/issues/{n}/comments",
+        permission: "issues",
+        level: "read",
+        identities: READERS,
+        feature: "Read the conversation on a pull request",
+    },
+    {
+        method: "POST",
+        pattern: "repos/{repo}/issues/{n}/comments",
+        permission: "issues",
+        level: "write",
+        identities: APP_ONLY,
+        feature: "Post a conversation comment",
+    },
+    {
+        method: "POST",
+        pattern: "repos/{repo}/issues/{n}/reactions",
+        permission: "issues",
+        level: "write",
+        identities: APP_ONLY,
+        feature: "Acknowledge a review request on the pull request",
+    },
+    {
+        method: "POST",
+        pattern: "repos/{repo}/issues/comments/{id}/reactions",
+        permission: "issues",
+        level: "write",
+        identities: APP_ONLY,
+        feature: "Acknowledge a review request in a comment",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/contents/{path}",
+        permission: "contents",
+        level: "read",
+        identities: READERS,
+        feature: "Read files and PR_REVIEW_GUIDE.md",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/git/trees/{ref}",
+        permission: "contents",
+        level: "read",
+        identities: READERS,
+        feature: "Read the file tree",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/commits",
+        permission: "contents",
+        level: "read",
+        identities: READERS,
+        feature: "Read commit history",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/compare/{range}",
+        permission: "contents",
+        level: "read",
+        identities: READERS,
+        feature: "Compare two commits",
+    },
+    {
+        method: "GET",
+        pattern: "repos/{repo}/releases",
+        permission: "contents",
+        level: "read",
+        identities: READERS,
+        feature: "Read releases in the probe",
+    },
+    {
+        method: "POST",
+        pattern: "repos/{repo}/check-runs",
+        permission: "checks",
+        level: "write",
+        identities: APP_ONLY,
+        feature: "Create the review check run",
+    },
+    {
+        method: "PATCH",
+        pattern: "repos/{repo}/check-runs/{id}",
+        permission: "checks",
+        level: "write",
+        identities: APP_ONLY,
+        feature: "Update the review check run",
+    },
+    // Calls that need no repository permission. `credentials.ts` and `gh.ts`
+    // make the first two, `app.ts` the App ones, `oauth.ts` the dashboard sign-in.
+    {
+        method: "GET",
+        pattern: "user",
+        identities: ["gh", "pat"],
+        feature: "Check who the credential belongs to",
+    },
+    {
+        method: "GET",
+        pattern: "user/repos",
+        permission: "metadata",
+        level: "read",
+        identities: ["pat"],
+        feature: "Check the token can list repositories",
+    },
+    {
+        method: "GET",
+        pattern: "rate_limit",
+        identities: ["gh"],
+        feature: "Print the remaining quota with --debug",
+    },
+    {
+        method: "GET",
+        pattern: "app/installations",
+        identities: APP_ONLY,
+        feature: "List where the App is installed",
+    },
+    {
+        method: "POST",
+        pattern: "app/installations/{id}/access_tokens",
+        identities: APP_ONLY,
+        feature: "Mint an installation token",
+    },
+    {
+        method: "GET",
+        pattern: "installation/repositories",
+        identities: APP_ONLY,
+        feature: "List the repositories an installation can see",
+    },
+    {
+        method: "POST",
+        pattern: "app-manifests/{code}/conversions",
+        identities: [],
+        feature: "Finish creating the App from the dashboard",
+    },
+];
+function strongest(identity) {
+    const result = {};
+    for (const endpoint of ENDPOINTS) {
+        if (!endpoint.permission || !endpoint.identities.includes(identity)) {
+            continue;
+        }
+        const entry = (result[endpoint.permission] ??= {
+            level: "read",
+            features: [],
+        });
+        if (endpoint.level === "write")
+            entry.level = "write";
+        entry.features.push(endpoint.feature);
+    }
+    return result;
+}
+/** What the App must be granted, in the shape the manifest and the save-time
+ * check want. */
+export const APP_PERMISSIONS = Object.fromEntries(ORDER.flatMap((name) => {
+    const entry = strongest("app")[name];
+    return entry ? [[name, entry.level]] : [];
+}));
+function patternRegex(pattern) {
+    const source = pattern
+        .split(/(\{[a-z]+\})/)
+        .map((part) => {
+        if (part === "{repo}")
+            return "[^/]+/[^/]+";
+        if (part === "{path}")
+            return ".+";
+        if (part.startsWith("{"))
+            return "[^/]+";
+        return part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    })
+        .join("");
+    return new RegExp(`^${source}$`);
+}
+const REGEXES = ENDPOINTS.map((endpoint) => patternRegex(endpoint.pattern));
+/** The entry for a real request such as `repos/o/r/pulls/4/files?page=2`. */
+export function endpointFor(method, endpoint) {
+    const path = endpoint.replace(/\?.*$/, "").replace(/^\/+/, "");
+    const index = ENDPOINTS.findIndex((candidate, at) => candidate.method === method && REGEXES[at].test(path));
+    return index === -1 ? undefined : ENDPOINTS[index];
+}
+function accessLabel(level) {
+    return level === "write" ? "Read and write" : "Read";
+}
+/** `who` is what the failing credential is called in the sentence. */
+export function refusalHint(method, endpoint, who) {
+    const base = `GitHub refused ${method} ${endpoint}.`;
+    const found = endpointFor(method, endpoint);
+    if (!found?.permission)
+        return base;
+    if (who === "token" && !found.identities.includes("pat")) {
+        return `${base} Only a GitHub App can do this.`;
+    }
+    return `${base} ${needs(found, who)}`;
+}
+/** A fine-grained token is granted permissions and a classic one scopes, so a
+ * token error names both. */
+function needs(found, who) {
+    const grant = `${PERMISSION_LABEL[found.permission]}: ${accessLabel(found.level)}`;
+    return who === "App"
+        ? `The GitHub App needs ${grant}.`
+        : `A fine-grained token needs ${grant}. A classic token needs the repo scope.`;
+}
+export function missingHint(method, endpoint, who) {
+    const name = who === "token" ? "the token" : "the GitHub App";
+    const found = endpointFor(method, endpoint);
+    const base = `GitHub returned 404 for ${method} ${endpoint}. The repository may not exist or ${name} cannot see it.`;
+    if (!found?.permission)
+        return base;
+    return `${base} ${needs(found, who)}`;
+}
+/** Classic scopes cover every repository call above, for `gh` and a classic
+ * PAT alike. No scope is finer than that. */
+const SCOPES = [
+    { scope: "repo", why: "Read public and private repositories" },
+    { scope: "public_repo", why: "Read public repositories only" },
+];
+function rows(header, body) {
+    const line = (cells) => `| ${cells.join(" | ")} |`;
+    return [
+        line(header),
+        line(header.map((cell) => "-".repeat(Math.max(3, cell.length)))),
+        ...body.map(line),
+    ].join("\n");
+}
+function byPermission(identity, why) {
+    const strong = strongest(identity);
+    return rows(identity === "app"
+        ? ["Permission", "Access", why]
+        : ["Repository permission", "Access", why], ORDER.filter((name) => strong[name]).map((name) => [
+        PERMISSION_LABEL[name],
+        accessLabel(strong[name].level),
+        [...new Set(strong[name].features)]
+            .map((text, at) => at === 0 ? text : text[0].toLowerCase() + text.slice(1))
+            .join(", "),
+    ]));
+}
+/** A markdown table for the docs. `build_docs.ts` writes it between the
+ * `permissions:<kind>` markers and a test fails when the page is stale. */
+export function permissionTable(kind) {
+    if (kind === "app")
+        return byPermission("app", "Why");
+    if (kind === "pat-fine")
+        return byPermission("pat", "Needed for");
+    if (kind === "oauth") {
+        return rows(["Scope", "Why"], [
+            [
+                "None requested",
+                "The sign-in only reads your GitHub login from `GET /user`",
+            ],
+        ]);
+    }
+    return rows(["Scope", "Why"], SCOPES.map(({ scope, why }) => [`\`${scope}\``, why]));
+}

package/dist/src/knowledge/facts.js

@@ -295,7 +295,7 @@ export function extractFacts(source, options) {
                 add(facts, {
                     ...fact("review-bar", instruction, `review discussion (${count} mentions)`, count),
                     // A rule mined from discussion across several pull requests is
-                    // repository policy, not one request's narrative (CORE-32).
+                    // repository policy, not one request's narrative.
                     origin: "repository",
                 });
             }

package/dist/src/knowledge/guide.d.ts

@@ -5,10 +5,10 @@ export type ReviewDocuments = {
 };
 /** A fact read out of a single pull request describes that request, not the
  * repository. `origin` is absent on facts written before the field existed, so
- * those count as repository policy (CORE-32 / F26b). */
+ * those count as repository policy. */
 export declare function isPullRequestFact(item: Fact): boolean;
 /** The selected review signals, before the `>2` threshold is applied. Exported
- * so `init` can tell the user how far short of the threshold a repository is
- * (CORE-31), rather than silently skipping the two guide files. */
+ * so `init` can tell the user how far short of the threshold a repository is,
+ * rather than silently skipping the two guide files. */
 export declare function reviewSignalCount(facts: Fact[]): number;
 export declare function buildReviewDocuments(facts: Fact[]): ReviewDocuments | undefined;

package/dist/src/knowledge/guide.js

@@ -1,6 +1,6 @@
 /** A fact read out of a single pull request describes that request, not the
  * repository. `origin` is absent on facts written before the field existed, so
- * those count as repository policy (CORE-32 / F26b). */
+ * those count as repository policy. */
 export function isPullRequestFact(item) {
     return item.origin === "pull-request";
 }
@@ -22,12 +22,12 @@ function reviewBarFacts(facts) {
         .sort((a, b) => b.weight - a.weight || a.claim.localeCompare(b.claim));
 }
 /** The short guide's checklist: every recurring review signal, including the
- * ones mined from pull requests (CORE-32 keeps this file's PR source). */
+ * ones mined from pull requests. */
 function reviewFacts(facts) {
     return dedupe(reviewBarFacts(facts));
 }
 /** The detailed guide's checklist: only expectations backed by repository-wide
- * evidence, never a single pull request's narrative (CORE-32). */
+ * evidence, never a single pull request's narrative. */
 function detailedFacts(facts) {
     return dedupe(reviewBarFacts(facts).filter((item) => !isPullRequestFact(item)));
 }
@@ -65,8 +65,8 @@ ${bullets.join("\n")}
 `;
 }
 /** The selected review signals, before the `>2` threshold is applied. Exported
- * so `init` can tell the user how far short of the threshold a repository is
- * (CORE-31), rather than silently skipping the two guide files. */
+ * so `init` can tell the user how far short of the threshold a repository is,
+ * rather than silently skipping the two guide files. */
 export function reviewSignalCount(facts) {
     return reviewFacts(facts).length;
 }

package/dist/src/knowledge/probe.js

@@ -114,8 +114,7 @@ export function analyzeProbe(meta, pulls, detailSamples, commits) {
     else if (commits.length) {
         // Only claim the history is noise when the useful-commit ratio actually
         // supports it. With `commits: 8 · useful: 5` the ratio is above a half,
-        // and the old unconditional sentence contradicted the numbers beside it
-        // (CORE-24).
+        // and the old unconditional sentence contradicted the numbers beside it.
         const usefulRatio = usefulCommits / commits.length;
         if (usefulRatio < 0.5) {
             reasons.push("Commit history is mostly merge/noise commits, so it is not recommended as a source.");

package/dist/src/knowledge/sections.d.ts

@@ -1,11 +1,11 @@
 export declare const sectionTitles: Record<string, string>;
 export declare const sectionKeys: string[];
 /** Sections whose content also lives in `CODEBASE.md`. The skill links to that
- * file instead of keeping a second copy (CORE-32 / F26c). */
+ * file instead of keeping a second copy. */
 export declare const codebaseSectionKeys: Set<string>;
 /** A fact read out of a single pull request describes that request, not the
  * repository, so it may only feed the `review-bar` checklist. Every other
- * section states repository policy and must not learn from one PR's narrative
- * (CORE-32 / F26b). Keep this in sync with `guide.ts`, which applies the same
+ * section states repository policy and must not learn from one PR's narrative.
+ * Keep this in sync with `guide.ts`, which applies the same
  * rule to the review guides. */
 export declare function sectionAllowsPrFacts(key: string): boolean;

package/dist/src/knowledge/sections.js

@@ -12,7 +12,7 @@ export const sectionTitles = {
 };
 export const sectionKeys = Object.keys(sectionTitles);
 /** Sections whose content also lives in `CODEBASE.md`. The skill links to that
- * file instead of keeping a second copy (CORE-32 / F26c). */
+ * file instead of keeping a second copy. */
 export const codebaseSectionKeys = new Set([
     "layout",
     "style",
@@ -21,8 +21,8 @@ export const codebaseSectionKeys = new Set([
 ]);
 /** A fact read out of a single pull request describes that request, not the
  * repository, so it may only feed the `review-bar` checklist. Every other
- * section states repository policy and must not learn from one PR's narrative
- * (CORE-32 / F26b). Keep this in sync with `guide.ts`, which applies the same
+ * section states repository policy and must not learn from one PR's narrative.
+ * Keep this in sync with `guide.ts`, which applies the same
  * rule to the review guides. */
 export function sectionAllowsPrFacts(key) {
     return key === "review-bar";

package/dist/src/knowledge/skill.d.ts

@@ -2,7 +2,7 @@ import type { Fact } from "./types.ts";
 /** The full text of the sections that live in `CODEBASE.md`. The skill itself
  * only links to that file, so this is the single place the codebase guidance is
  * written out: the synthesized override when there is one, otherwise the
- * rendered facts (CORE-32 / F26c). */
+ * rendered facts. */
 export declare function codebaseBody(facts: Fact[], overrides?: Record<string, string>): string;
 /** Slices an assembled skill's `## Heading` sections back out by section key,
  * from `<!-- section:key -->` markers or (fallback) canonical heading text. */

package/dist/src/knowledge/skill.js

@@ -6,8 +6,8 @@ function sectionFacts(facts, key) {
         .sort((a, b) => b.weight - a.weight);
 }
 /** Facts a section may state. A fact read out of a single pull request is that
- * request's narrative, not a rule, so only `review-bar` may use it (CORE-32 /
- * F26b). Facts written before `origin` existed count as repository policy. */
+ * request's narrative, not a rule, so only `review-bar` may use it. Facts
+ * written before `origin` existed count as repository policy. */
 function usableFacts(facts, key) {
     const items = sectionFacts(facts, key);
     return sectionAllowsPrFacts(key)
@@ -42,7 +42,7 @@ function codebaseSectionText(key, facts, overrides) {
 /** The full text of the sections that live in `CODEBASE.md`. The skill itself
  * only links to that file, so this is the single place the codebase guidance is
  * written out: the synthesized override when there is one, otherwise the
- * rendered facts (CORE-32 / F26c). */
+ * rendered facts. */
 export function codebaseBody(facts, overrides = {}) {
     return [...codebaseSectionKeys]
         .map((key) => codebaseSectionText(key, facts, overrides))
@@ -83,7 +83,7 @@ async function hash(value) {
 }
 /** The fields that decide a section's text. `origin` is included so a fact
  * moving from PR narrative to repository policy (or the reverse) counts as a
- * change rather than reusing a section built under the old rule (CORE-32). */
+ * change rather than reusing a section built under the old rule. */
 function hashInput(item) {
     return [
         item.id,

package/dist/src/knowledge/synthesis.d.ts

@@ -10,7 +10,7 @@ export declare function extractAiFactsWithReport(provider: AiProvider, repo: str
     skipped: SkippedUnit[];
 }>;
 /** Same as {@link extractAiFacts}, but also reports what the batch skipped so
- * the caller can put it in the final `[done]` line (CORE-30). */
+ * the caller can put it in the final `[done]` line. */
 export declare function enrichFactsWithReport(provider: AiProvider, repo: string, base: Fact[], source: Source, options: Options, usage?: UsageSink): Promise<{
     facts: Fact[];
     skipped: SkippedUnit[];

package/dist/src/knowledge/synthesis.js

@@ -131,7 +131,7 @@ function queueFor(provider, repo, ai, model, concurrency, validate) {
 }
 /** `factsFromResponse` as a validator: `null` when the text parses into facts,
  * otherwise the parse error's message. Used so an unparseable response is never
- * cached (CORE-30). */
+ * cached. */
 function validateFacts(response, evidence, defaultScope) {
     try {
         factsFromResponse(response.text, evidence, defaultScope, "repository");
@@ -187,7 +187,7 @@ function sectionGoal(key) {
 function synthesisFacts(facts, key) {
     return (facts
         // A section that states repository policy never learns from a single pull
-        // request's narrative; only `review-bar` may (CORE-32 / F26b).
+        // request's narrative; only `review-bar` may.
         .filter((item) => item.sectionKey === key &&
         (sectionAllowsPrFacts(key) || !isPullRequestFact(item)))
         .sort((a, b) => (b.status === "active" ? 1 : 0) - (a.status === "active" ? 1 : 0) ||
@@ -283,7 +283,7 @@ ${files}`, 2_200));
     return { facts, skipped: queue.skippedUnits() };
 }
 /** Same as {@link extractAiFacts}, but also reports what the batch skipped so
- * the caller can put it in the final `[done]` line (CORE-30). */
+ * the caller can put it in the final `[done]` line. */
 export async function enrichFactsWithReport(provider, repo, base, source, options, usage) {
     const { facts, skipped } = await extractAiFactsWithReport(provider, repo, source, options, usage);
     return { facts: mergeFacts(base, facts), skipped };
@@ -315,7 +315,7 @@ export async function synthesizeSections(provider, repo, facts, _previousMarkdow
         const relevant = synthesisFacts(facts, key);
         // A section whose only facts came from a single pull request has no
         // repository policy to synthesize, so it is left to the deterministic
-        // renderer instead of asking the model for an empty answer (CORE-32).
+        // renderer instead of asking the model for an empty answer.
         if (!relevant.length)
             continue;
         keys.push(key);
@@ -354,7 +354,7 @@ FACTS:
 ${JSON.stringify(relevant)}`,
         });
     }
-    const queue = queueFor(provider, repo, ai, model, ai === "hetzner" ? 1 : concurrency, (request, response) => validateSection(response, keys[requests.indexOf(request)] ?? ""));
+    const queue = queueFor(provider, repo, ai, model, concurrency, (request, response) => validateSection(response, keys[requests.indexOf(request)] ?? ""));
     const responses = await queue.run(requests, usage);
     // A section that the batch skipped has no response, and a unit that failed
     // validation never produces one: omit those keys entirely rather than

package/dist/src/knowledge/types.d.ts

@@ -41,7 +41,7 @@ export type Fact = {
     status: "active" | "contradicted" | "stale";
     /** Where the fact was mined from. A fact read out of a single pull request
      * describes that request, not the repository, so it may not become a
-     * repository-wide rule (CORE-32 / F26b). Missing means `repository`, which
+     * repository-wide rule. Missing means `repository`, which
      * keeps facts written before this field existed. */
     origin?: "repository" | "pull-request";
 };

package/dist/src/local/codegraph_exclude.d.ts

@@ -1,3 +1,3 @@
 import type { Run } from "../pr/checkout.ts";
-/** Plan §13.2 — hide the local codegraph index from git status. */
+/** Hide the local codegraph index from git status. */
 export declare function ensureCodegraphGitExclude(gitRoot: string, run: Run): Promise<void>;

package/dist/src/local/codegraph_exclude.js

@@ -1,7 +1,7 @@
 import { dirname } from "node:path";
 import { isNotFound, mkdir, readTextFile, writeTextFile, } from "../util/runtime.js";
 const EXCLUDE_LINE = "/.co-maintainer-codegraph/";
-/** Plan §13.2 — hide the local codegraph index from git status. */
+/** Hide the local codegraph index from git status. */
 export async function ensureCodegraphGitExclude(gitRoot, run) {
     const pathResult = await run("git", ["rev-parse", "--git-path", "info/exclude"], gitRoot);
     if (pathResult.code !== 0)

package/dist/src/local/codegraph_prepare.js

@@ -13,7 +13,7 @@ export async function prepareLocalCodegraph(input) {
     const resolved = await ensureCodegraphForReview({
         allowInstall: input.allowInstall,
         // The prompt is safe only when a human can answer it; `canPrompt` checks
-        // stdin, stdout and `CI`, so a `</dev/null` or piped run never asks (F01).
+        // stdin, stdout and `CI`, so a `</dev/null` or piped run never asks.
         interactive: input.interactive ?? canPrompt(),
         log: (message) => log("codegraph", message.replace(/^\[codegraph\]\s*/, "")),
     });

package/dist/src/local/git_ops.d.ts

@@ -2,7 +2,7 @@ import { type Run } from "../pr/checkout.ts";
 import { CliError } from "../cli/error.ts";
 export declare function gitRoot(cwd: string, run?: Run): Promise<string>;
 /** Backward-compatible name for the shared CLI error. Local and remote review
- * threw this before CORE-10 introduced `CliError`, so it stays as a thin
+ * threw this before `CliError` existed, so it stays as a thin
  * subclass and every existing call site keeps working. */
 export declare class ReviewCliError extends CliError {
     constructor(code: string, message: string, hint?: string, exitCode?: number);

package/dist/src/local/git_ops.js

@@ -10,7 +10,7 @@ export async function gitRoot(cwd, run = runCommand) {
     return result.stdout.trim();
 }
 /** Backward-compatible name for the shared CLI error. Local and remote review
- * threw this before CORE-10 introduced `CliError`, so it stays as a thin
+ * threw this before `CliError` existed, so it stays as a thin
  * subclass and every existing call site keeps working. */
 export class ReviewCliError extends CliError {
     constructor(code, message, hint, exitCode = EXIT_USAGE) {

package/dist/src/local/git_parse.d.ts

@@ -1,4 +1,4 @@
-/** Pure parsers for git -z output and remote URL normalization (plan §10). */
+/** Pure parsers for git -z output and remote URL normalization. */
 export type NameStatusEntry = {
     status: "added" | "modified" | "removed" | "renamed";
     path: string;
@@ -21,7 +21,7 @@ export declare function normalizeGithubRemote(url: string): NormalizeRemoteResul
 export declare function parseNameStatusZ(raw: string): NameStatusEntry[];
 /** Parse `git diff --numstat -z` (`add\tdelete\tpath\0` per file). */
 export declare function parseNumstatZ(raw: string): Map<string, NumstatEntry>;
-/** Paths from name-status that have no entry in a bulk unified diff (plan §10.7). */
+/** Paths from name-status that have no entry in a bulk unified diff. */
 export declare function pathsMissingPatches(statuses: NameStatusEntry[], patches: Map<string, string>): string[];
 /** Split unified diff output into per-file patch bodies (without diff --git header). */
 export declare function splitDiffPatches(raw: string): Map<string, string>;

package/dist/src/local/git_parse.js

@@ -1,4 +1,4 @@
-/** Pure parsers for git -z output and remote URL normalization (plan §10). */
+/** Pure parsers for git -z output and remote URL normalization. */
 export function normalizeGithubRemote(url) {
     const trimmed = url.trim().replace(/\/+$/, "");
     let host = "";
@@ -102,7 +102,7 @@ export function parseNumstatZ(raw) {
     }
     return map;
 }
-/** Paths from name-status that have no entry in a bulk unified diff (plan §10.7). */
+/** Paths from name-status that have no entry in a bulk unified diff. */
 export function pathsMissingPatches(statuses, patches) {
     return statuses
         .filter((entry) => entry.status !== "removed")

package/dist/src/local/git_revision.d.ts

@@ -1,7 +1,7 @@
 import type { Run } from "../pr/checkout.ts";
 import { type Revision } from "../review/revision.ts";
 import { type UntrackedWarning } from "./git_untracked.ts";
-/** Single-file unified patch when bulk `git diff` did not map a path (plan §10.7). */
+/** Single-file unified patch when bulk `git diff` did not map a path. */
 export declare function perFileUnifiedPatch(cwd: string, base: string, path: string, run: Run): Promise<string>;
 export declare function mergeBase(cwd: string, baseRef: string, remote: string, run: Run): Promise<string>;
 export declare function resolveBaseRef(cwd: string, remote: string, toBranch: string | undefined, run: Run): Promise<{

package/dist/src/local/git_revision.js

@@ -12,7 +12,7 @@ const unifiedDiffArgs = [
     "-M",
     "--unified=3",
 ];
-/** Single-file unified patch when bulk `git diff` did not map a path (plan §10.7). */
+/** Single-file unified patch when bulk `git diff` did not map a path. */
 export async function perFileUnifiedPatch(cwd, base, path, run) {
     const result = await run("git", [...diffEnv, ...unifiedDiffArgs, base, "--", path], cwd);
     if (result.code !== 0 || !result.stdout.trim())

package/dist/src/local/git_untracked.d.ts

@@ -3,7 +3,7 @@ export type UntrackedWarning = {
     code: "untracked_unreadable";
     message: string;
 };
-/** Build patch for a new untracked file (plan §10.8). */
+/** Build patch for a new untracked file. */
 export declare function patchFromNewFileContent(content: Uint8Array): {
     patch: string;
     additions: number;