co-maintainer 0.4.9 → 0.4.11

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "co-maintainer",
-    "version": "0.4.9",
+    "version": "0.4.11",
     "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) {

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

@@ -4,4 +4,4 @@ export type ValidationResult = {
     errors: string[];
     warnings: string[];
 };
-export declare function validateSkill(markdown: string, outputDirectory: string, source?: Source, referenceIssues?: "error" | "warning"): Promise<ValidationResult>;
+export declare function validateSkill(markdown: string, source?: Source, referenceIssues?: "error" | "warning"): Promise<ValidationResult>;

package/dist/src/knowledge/validate.js

@@ -1,5 +1,4 @@
-import { stat } from "../util/runtime.js";
-export async function validateSkill(markdown, outputDirectory, source, referenceIssues = "error") {
+export async function validateSkill(markdown, source, referenceIssues = "error") {
     const errors = [];
     const warnings = [];
     const referenceProblems = referenceIssues === "error" ? errors : warnings;
@@ -33,54 +32,6 @@ export async function validateSkill(markdown, outputDirectory, source, reference
     if (source) {
         const paths = new Set([...source.tree, ...Object.keys(source.files)]);
         const repositoryName = String(source.repo.full_name ?? "");
-        const commands = new Set();
-        for (const [path, content] of Object.entries(source.files)) {
-            if (path.endsWith("package.json")) {
-                try {
-                    const scripts = JSON.parse(content)
-                        .scripts ?? {};
-                    const prefix = source.tree.some((item) => /pnpm-lock\.yaml$/.test(item))
-                        ? "pnpm"
-                        : source.tree.some((item) => /yarn\.lock$/.test(item))
-                            ? "yarn"
-                            : "npm";
-                    for (const name of Object.keys(scripts)) {
-                        commands.add(`${prefix} ${name}`);
-                        commands.add(`${prefix} run ${name}`);
-                        commands.add(String(scripts[name]));
-                    }
-                }
-                catch {
-                    // Ignore malformed manifests; syntax validation is outside this gate.
-                }
-            }
-            if (/deno\.jsonc?$/.test(path)) {
-                try {
-                    const tasks = JSON.parse(content).tasks ??
-                        {};
-                    for (const [name, task] of Object.entries(tasks)) {
-                        commands.add(`deno task ${name}`);
-                        commands.add(String(task));
-                    }
-                }
-                catch {
-                    // Ignore malformed manifests; syntax validation is outside this gate.
-                }
-            }
-            for (const match of content.matchAll(/^\s*run:\s*([^\s#].*?)\s*$/gm)) {
-                commands.add(match[1].replace(/^['"]|['"]$/g, ""));
-            }
-            for (const match of content.matchAll(/`((?:npm|pnpm|yarn|bun|deno|cargo|make|go|python|node|git)\s+[^`\n]+)`/g)) {
-                commands.add(match[1]);
-            }
-            for (const match of content.matchAll(/^\s*((?:npm|pnpm|yarn|bun|deno|cargo|make|go|python|node|git)\s+[^\n`]+)$/gm)) {
-                commands.add(match[1].trim());
-            }
-        }
-        if (source.tree.some((path) => /Cargo\.toml$/.test(path))) {
-            commands.add("cargo test");
-            commands.add("cargo build");
-        }
         const references = [...markdown.matchAll(/`([^`\n]+)`/g)].map((match) => match[1]);
         for (const reference of references) {
             const isQualifier = /^[a-z][a-z\d_-]*:/i.test(reference);
@@ -109,27 +60,14 @@ export async function validateSkill(markdown, outputDirectory, source, reference
                     referenceProblems.push(`referenced path is absent from source: ${reference}`);
                 }
             }
-            if (/^(?:npm|pnpm|yarn|bun|deno|cargo|make|go|python|node|git)\s/.test(reference) &&
-                ![...commands].some((command) => reference === command ||
-                    reference.startsWith(`${command} `) ||
-                    command.startsWith(`${reference} `))) {
-                referenceProblems.push(`referenced command is absent from source: ${reference}`);
-            }
         }
     }
-    const links = [...markdown.matchAll(/\[[^\]]+\]\(([^)]+)\)/g)].map((match) => match[1]);
-    for (const link of links) {
-        if (/^[a-z][a-z\d+.-]*:/i.test(link) ||
-            link.startsWith("/") ||
-            link.includes("..")) {
-            errors.push(`link is not relative: ${link}`);
-            continue;
-        }
-        try {
-            await stat(`${outputDirectory}/${link}`);
-        }
-        catch {
-            errors.push(`linked file does not exist: ${link}`);
+    for (const link of markdown.matchAll(/\[[^\]]+\]\(([^)]+)\)/g)) {
+        const target = link[1];
+        if (/^[a-z][a-z\d+.-]*:/i.test(target) ||
+            target.startsWith("/") ||
+            target.includes("..")) {
+            errors.push(`link is not relative: ${target}`);
         }
     }
     return { valid: errors.length === 0, errors, warnings };

package/dist/src/services/setup.js

@@ -204,19 +204,19 @@ export async function runInitOrRemake(options) {
     let result = await timed("assemble skill", options.logTime, () => assembleSkill(options.repo, facts, previousMarkdown, previous?.sectionHashes ?? {}, overrides));
     const reviewDocuments = buildReviewDocuments(facts);
     result.markdown = addReviewLink(result.markdown, reviewDocuments);
-    const validation = await timed("validate skill", options.logTime, () => validateSkill(result.markdown, `${reposDir()}/${options.repo}`, source));
+    const validation = await timed("validate skill", options.logTime, () => validateSkill(result.markdown, source));
     if (!validation.valid && Object.keys(overrides).length) {
         log("validate", `AI output rejected: ${validation.errors.join("; ")}`);
         overrides = {};
         result = await timed("reassemble valid skill", options.logTime, () => assembleSkill(options.repo, facts, previousMarkdown, previous?.sectionHashes ?? {}, overrides));
         result.markdown = addReviewLink(result.markdown, reviewDocuments);
     }
-    const finalValidation = await timed("final skill validation", options.logTime, () => validateSkill(result.markdown, `${reposDir()}/${options.repo}`, source, "warning"));
+    const finalValidation = await timed("final skill validation", options.logTime, () => validateSkill(result.markdown, source, "warning"));
     if (finalValidation.warnings.length) {
         log("validate", `stale references kept: ${finalValidation.warnings.join(", ")}`);
     }
     if (!finalValidation.valid) {
-        throw new Error(`generated skill is invalid: ${finalValidation.errors.join("; ")}`);
+        log("validate", `skill problems kept: ${finalValidation.errors.join("; ")}`);
     }
     await timed("write skill and state", options.logTime, async () => {
         const { withKnowledgeLock } = await import("../review/guides.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.9",
+  "version": "0.4.11",
   "description": "Analyzes a GitHub repository and writes repository-specific contribution guidance.",
   "license": "MIT",
   "repository": {