co-maintainer 0.4.8 → 0.4.10

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "co-maintainer",
-    "version": "0.4.8",
+    "version": "0.4.10",
     "description": "Analyzes a GitHub repository and writes repository-specific contribution guidance.",
     "license": "MIT",
     "repository": {

package/dist/src/cli/args.js

@@ -53,6 +53,7 @@ export async function parseArgs(args) {
         console.log("         --include-commit-history --include-how-repo-works");
         console.log("         --max-commits=N --max-pr-months=N --max-pull-request-change-lines=N --max-comment=N");
         console.log("         --only-request-changed-pr");
+        console.log("         --pr-state=open,closed,merged");
         console.log("         --auth=gh|pat --github-pat=... --ai=none|openrouter|hetzner --token=... --low-model=... --high-model=...");
         process.exit(0);
     }
@@ -111,6 +112,24 @@ export async function parseArgs(args) {
             : undefined;
     };
     const text = (name) => rest.find((item) => item.startsWith(`--${name}=`))?.slice(name.length + 3);
+    const prStateOption = (args, saved) => {
+        const prefix = "--pr-state=";
+        const raw = args
+            .find((arg) => arg.startsWith(prefix))
+            ?.slice(prefix.length);
+        if (raw === undefined)
+            return saved && saved.length > 0 ? saved : undefined;
+        const allowed = ["open", "closed", "merged"];
+        const parts = raw
+            .split(",")
+            .map((part) => part.trim())
+            .filter(Boolean);
+        if (parts.length === 0 ||
+            parts.some((part) => !allowed.includes(part))) {
+            die("pr-state must be a comma-separated list of: open, closed, merged");
+        }
+        return [...new Set(parts)];
+    };
     const choice = (name, allowed, fallback) => {
         const prefix = `--${name}=`;
         const raw = rest
@@ -130,6 +149,7 @@ export async function parseArgs(args) {
                 "max-pr-months",
                 "max-pull-request-change-lines",
                 "max-comment",
+                "pr-state",
                 "improve-matrix",
                 "env",
                 "gh-concurrent",
@@ -245,6 +265,7 @@ export async function parseArgs(args) {
         includeHowRepoWorks: enabled("include-how-repo-works"),
         onlyRequestChangedPr: rest.includes("--only-request-changed-pr") ||
             repoConfig.onlyRequestChangedPr === true,
+        prState: prStateOption(rest, repoConfig.prState),
         maxCommits: value("max-commits") ?? repoConfig.maxCommits ?? configDefault.maxCommits,
         maxPrMonths: value("max-pr-months") ??
             repoConfig.maxPrMonths ??

package/dist/src/config.d.ts

@@ -18,6 +18,7 @@ export type RepoConfig = {
     includeCommitHistory?: boolean;
     includeHowRepoWorks?: boolean;
     onlyRequestChangedPr?: boolean;
+    prState?: ("open" | "closed" | "merged")[];
     /** Five field cron in UTC, checked by `serve` to queue a remake. */
     remakeCron?: string;
 };

package/dist/src/github/collect.js

@@ -30,6 +30,36 @@ function listingCovers(cachedMonths, current) {
         return false;
     return cachedMonths >= current;
 }
+function stateKey(states) {
+    if (!states || states.length === 0)
+        return "";
+    return [...states].sort().join(",");
+}
+/** `closed` is closed and not merged. GitHub's list has no merged state. */
+function matchesPrState(pr, states) {
+    if (!states || states.length === 0)
+        return true;
+    const merged = Boolean(pr.merged_at);
+    const state = String(pr.state ?? "");
+    return states.some((wanted) => {
+        if (wanted === "merged")
+            return merged;
+        if (wanted === "open")
+            return state === "open";
+        return state === "closed" && !merged;
+    });
+}
+function listQueryState(states) {
+    if (!states || states.length === 0)
+        return "all";
+    const wantsOpen = states.includes("open");
+    const wantsClosed = states.includes("closed") || states.includes("merged");
+    if (wantsOpen && wantsClosed)
+        return "all";
+    if (wantsOpen)
+        return "open";
+    return "closed";
+}
 async function loadListing(repo) {
     const raw = await cacheGet("pr-listing", repo);
     if (!raw)
@@ -39,20 +69,26 @@ async function loadListing(repo) {
         return undefined;
     return parsed;
 }
-async function saveListing(repo, maxPrMonths, items) {
-    await cacheSet("pr-listing", repo, JSON.stringify({ maxPrMonths: maxPrMonths ?? 0, items }));
+async function saveListing(repo, maxPrMonths, states, items) {
+    await cacheSet("pr-listing", repo, JSON.stringify({
+        maxPrMonths: maxPrMonths ?? 0,
+        states: stateKey(states),
+        items,
+    }));
 }
 async function listPullRequestPages(client, options, phase) {
     const cached = await loadListing(options.repo);
     const canCatchUp = cached !== undefined &&
-        listingCovers(cached.maxPrMonths, options.maxPrMonths);
+        listingCovers(cached.maxPrMonths, options.maxPrMonths) &&
+        (cached.states ?? "") === stateKey(options.prState);
     const cachedByNumber = new Map((cached?.items ?? []).map((pr) => [Number(pr.number), pr]));
     const selected = [];
     const seen = new Set();
     const concurrency = Math.max(1, options.ghConcurrent);
-    log("fetch", `pull request listing · concurrency=${concurrency}`);
+    const states = stateKey(options.prState) || "all";
+    log("fetch", `pull request listing · ${states} · concurrency=${concurrency}`);
     const fetchPage = async (page) => {
-        const pageItems = await client.request(`repos/${options.repo}/pulls?state=all&sort=updated&direction=desc&per_page=100&page=${page}`);
+        const pageItems = await client.request(`repos/${options.repo}/pulls?state=${listQueryState(options.prState)}&sort=updated&direction=desc&per_page=100&page=${page}`);
         return Array.isArray(pageItems) ? pageItems : [];
     };
     const ingest = (page, pageItems) => {
@@ -72,6 +108,8 @@ async function listPullRequestPages(client, options, phase) {
                 reason = "window reached";
                 break;
             }
+            if (!matchesPrState(pr, options.prState))
+                continue;
             const number = Number(pr.number);
             selected.push(pr);
             seen.add(number);
@@ -111,6 +149,8 @@ async function listPullRequestPages(client, options, phase) {
             if (!withinPrWindow(String(pr.updated_at ?? ""), options.maxPrMonths)) {
                 continue;
             }
+            if (!matchesPrState(pr, options.prState))
+                continue;
             selected.push(pr);
             seen.add(number);
             reused++;
@@ -119,7 +159,7 @@ async function listPullRequestPages(client, options, phase) {
             log("fetch", `pull request listing · reused ${reused} cached PRs · ${selected.length} total`);
         }
     }
-    await saveListing(options.repo, options.maxPrMonths, selected);
+    await saveListing(options.repo, options.maxPrMonths, options.prState, selected);
     return selected;
 }
 async function mapPool(items, concurrency, fn) {
@@ -271,7 +311,8 @@ async function pullRequests(client, options, previous, phase, progress) {
         const discussionUnchanged = cached?.updatedAt === current.updatedAt;
         const decisionKnown = typeof cached?.changesRequested === "boolean";
         const diffUnchanged = cached?.headSha === current.headSha && Boolean(cached?.diff);
-        let dropped = only && discussionUnchanged && cached?.changesRequested === false;
+        let droppedFromCache = only && discussionUnchanged && cached?.changesRequested === false;
+        let dropped = droppedFromCache;
         const loadComments = async () => {
             const comments = await client.pages(`repos/${options.repo}/issues/${number}/comments`);
             current.comments = comments
@@ -296,7 +337,9 @@ async function pullRequests(client, options, previous, phase, progress) {
             await loadReviews();
         }
         const discussionStatus = dropped
-            ? "dropped"
+            ? droppedFromCache
+                ? "dropped cache"
+                : "dropped download"
             : discussionUnchanged
                 ? "comments/reviews cache"
                 : "download comments/reviews";

package/dist/src/services/setup.js

@@ -260,6 +260,7 @@ export async function runInitOrRemake(options) {
             includeCommitHistory: options.includeCommitHistory,
             includeHowRepoWorks: options.includeHowRepoWorks,
             onlyRequestChangedPr: options.onlyRequestChangedPr,
+            prState: options.prState,
         });
     });
     log("write", `${path} · ${result.changed.length
@@ -308,6 +309,7 @@ export function optionsFromConfig(repo, command) {
         includeCommitHistory: repoConfig.includeCommitHistory ?? true,
         includeHowRepoWorks: repoConfig.includeHowRepoWorks ?? true,
         onlyRequestChangedPr: repoConfig.onlyRequestChangedPr === true,
+        prState: repoConfig.prState,
         maxCommits: repoConfig.maxCommits ?? config.defaults?.maxCommits,
         maxPrMonths: repoConfig.maxPrMonths ?? config.defaults?.maxPrMonths,
         maxPullRequestChangeLines: repoConfig.maxPullRequestChangeLines ??

package/dist/src/types.d.ts

@@ -37,6 +37,8 @@ export type Options = {
     /** Keep only pull requests in the window that have at least one
      * `CHANGES_REQUESTED` review. Off by default, so the window is unchanged. */
     onlyRequestChangedPr: boolean;
+    /** Empty or omitted means every state. `closed` is closed and not merged. */
+    prState?: ("open" | "closed" | "merged")[];
     maxCommits?: number;
     maxPrMonths?: number;
     maxPullRequestChangeLines?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "co-maintainer",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Analyzes a GitHub repository and writes repository-specific contribution guidance.",
   "license": "MIT",
   "repository": {