co-maintainer 0.4.0-beta.2 → 0.4.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Murat Kirazkaya
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Murat Kirazkaya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/package.json

@@ -1,10 +1,25 @@
 {
     "name": "co-maintainer",
-    "version": "0.4.0-beta.2",
+    "version": "0.4.0",
     "description": "Analyzes a GitHub repository and writes repository-specific contribution guidance.",
     "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/GroophyLifefor/co-maintainer"
+    },
+    "homepage": "https://github.com/GroophyLifefor/co-maintainer#readme",
+    "bugs": {
+        "url": "https://github.com/GroophyLifefor/co-maintainer/issues"
+    },
+    "keywords": [
+        "github",
+        "pull-request",
+        "code-review",
+        "maintainer",
+        "ai"
+    ],
     "bin": {
-        "co-maintainer": "./dist/main.js"
+        "co-maintainer": "dist/main.js"
     },
     "files": [
         "dist/",

package/dist/src/cli/commands/serve.js

@@ -67,15 +67,15 @@ export function resolveWebhookUrl(args, port, configured) {
     // `new URL` is lenient: "http://http://host/:5000/x" parses with host
     // "http" and the real URL buried in the path, and "http:///x" treats "x"
     // as the host. GitHub needs a routable host and a real webhook path, so
-    // reject a scheme leaking into the path, a bare host with no dot or port,
-    // and a path that is just "/".
-    const hasQualifiedHost = url.hostname === "localhost" ||
-        url.hostname.includes(".") ||
-        url.port !== "";
-    if (url.pathname.startsWith("//") ||
+    // reject a leaked scheme, an empty authority, and a path that is just "/".
+    // A single-label host (an internal Docker/k8s name) or an IPv6 literal is
+    // legitimate, and both are indistinguishable from the "http:///x" spelling
+    // once parsed, so the empty authority is caught on the raw string instead.
+    const hasAuthority = /^https?:\/\/[^/?#]+/.test(raw.trim());
+    if (!hasAuthority ||
+        url.pathname.startsWith("//") ||
         url.pathname.includes("://") ||
-        url.pathname === "/" ||
-        !hasQualifiedHost) {
+        url.pathname === "/") {
         die("--webhook-url must be an absolute http(s) URL with a webhook path, " +
             "e.g. --webhook-url=https://example.com/github/webhook");
     }

package/dist/src/cli/prompt.js

@@ -9,6 +9,12 @@ async function ask(question) {
     try {
         return (await rl.question(question)).trim();
     }
+    catch {
+        // `question` rejects when stdin closes mid-prompt (Ctrl-D, a detached
+        // pipeline, a killed parent). Treat that as "no answer" so the caller's
+        // own fallback/required validation runs instead of an uncaught rejection.
+        return "";
+    }
     finally {
         rl.close();
     }

package/dist/src/cli/review_args.js

@@ -1,4 +1,4 @@
-import { parseArgs } from "./args.js";
+import { parseArgs, setCliInteractive } from "./args.js";
 function die(message) {
     throw new Error(message);
 }
@@ -50,6 +50,10 @@ export function filterReviewConfigArgs(raw) {
 export async function parseReviewArgs(args) {
     const positional = args.filter((a) => !a.startsWith("--"));
     const flags = reviewFlags(args);
+    // `--json` must never prompt (plan §8.7). `parseArgs` only receives the
+    // filtered args, and `--json` is stripped before it sees them, so the flag
+    // has to be applied here rather than after the parse returns.
+    setCliInteractive(!flags.json);
     const isPr = positional.length >= 2 &&
         /^[^/]+\/[^/]+$/.test(positional[0]) &&
         /^\d+$/.test(positional[1]);

package/dist/src/pr/codegraph_tool_args.d.ts

@@ -2,6 +2,11 @@ type Args = Record<string, unknown>;
 export declare function toolError(message: string): string;
 export declare function rejectUnknownKeys(args: Args, allowed: ReadonlySet<string>): string | null;
 export declare function rejectFlagLike(value: string, label: string): string | null;
+/** `codegraph_exec.ts` routes through `cmd /c` on Windows (the CLI is a `.cmd`
+ * shim), and `cmd.exe` re-parses every argument, so a value carrying `&`, `|`,
+ * `>` or `%` can append a second command. None of them have a legitimate place
+ * in a search term, symbol name or repo-relative path, so refuse them. */
+export declare function rejectShellMetacharacters(value: string, label: string): string | null;
 /** Repo-relative path only — no `..`, no absolute paths (plan E103). */
 export declare function rejectEscapingPath(file: string): string | null;
 export declare function guardToolArgs(args: Args, allowed: ReadonlySet<string>): string | null;

package/dist/src/pr/codegraph_tool_args.js

@@ -14,11 +14,24 @@ export function rejectFlagLike(value, label) {
     }
     return null;
 }
+/** `codegraph_exec.ts` routes through `cmd /c` on Windows (the CLI is a `.cmd`
+ * shim), and `cmd.exe` re-parses every argument, so a value carrying `&`, `|`,
+ * `>` or `%` can append a second command. None of them have a legitimate place
+ * in a search term, symbol name or repo-relative path, so refuse them. */
+export function rejectShellMetacharacters(value, label) {
+    if (/[&|<>^%\r\n]/.test(value)) {
+        return toolError(`${label} must not contain shell metacharacters`);
+    }
+    return null;
+}
 /** Repo-relative path only — no `..`, no absolute paths (plan E103). */
 export function rejectEscapingPath(file) {
     const flag = rejectFlagLike(file, "file");
     if (flag)
         return flag;
+    const shell = rejectShellMetacharacters(file, "file");
+    if (shell)
+        return shell;
     const norm = file.replace(/\\/g, "/");
     if (norm.startsWith("/") ||
         norm.startsWith("//") ||
@@ -30,5 +43,15 @@ export function rejectEscapingPath(file) {
     return null;
 }
 export function guardToolArgs(args, allowed) {
-    return rejectUnknownKeys(args, allowed);
+    const unknown = rejectUnknownKeys(args, allowed);
+    if (unknown)
+        return unknown;
+    for (const [key, value] of Object.entries(args)) {
+        if (typeof value !== "string")
+            continue;
+        const shell = rejectShellMetacharacters(value, key);
+        if (shell)
+            return shell;
+    }
+    return null;
 }

package/dist/src/remote/fixtures.js

@@ -1,4 +1,10 @@
-/** Fixture directory hashing for plan §15.3. */
+/** Fixture directory hashing for plan §15.3.
+ *
+ * The hash exists to catch schema/content drift in the wire fixtures, not
+ * line-ending drift, so `\r\n` is normalized to `\n` before hashing. Without
+ * that the digest depends on the checkout: `.gitattributes` keeps the repo at
+ * LF, but a Windows working tree with `autocrlf` hands the test CRLF and a
+ * different digest. */
 import { readDir, readFile } from "../util/runtime.js";
 export async function hashRemoteFixtures(version) {
     const dir = new URL(`./fixtures/v${version}/`, import.meta.url);
@@ -11,9 +17,11 @@ export async function hashRemoteFixtures(version) {
     names.sort();
     const chunks = [];
     const enc = new TextEncoder();
+    const dec = new TextDecoder();
     for (const name of names) {
         chunks.push(enc.encode(`${name}\n`));
-        chunks.push(await readFile(new URL(name, dir)));
+        const raw = dec.decode(await readFile(new URL(name, dir)));
+        chunks.push(enc.encode(raw.replace(/\r\n/g, "\n")));
         chunks.push(enc.encode("\n"));
     }
     const total = chunks.reduce((n, c) => n + c.length, 0);

package/dist/src/remote/schema.d.ts

@@ -6,7 +6,8 @@ export declare const MIN_SERVER_SCHEMA = 1;
 export declare const REMOTE_CLI_UPGRADE_COMMAND = "npm install -g co-maintainer@latest";
 export declare const REMOTE_MAX_BODY_BYTES = 52428800;
 export declare const REMOTE_SYNC_INTERVAL_SECONDS = 3;
-/** SHA-256 of sorted `fixtures/v<N>/*.json` (name + contents); bump with schema version. */
+/** SHA-256 of sorted `fixtures/v<N>/*.json` (name + contents, `\r\n` normalized
+ * to `\n`); bump with schema version. */
 export declare const REMOTE_FIXTURE_HASH: Record<number, string>;
 export declare const REMOTE_SYNC_STATUSES: readonly ["queued", "running", "done", "failed", "canceled"];
 export type RemoteSyncStatus = (typeof REMOTE_SYNC_STATUSES)[number];

package/dist/src/remote/schema.js

@@ -6,9 +6,10 @@ export const MIN_SERVER_SCHEMA = 1;
 export const REMOTE_CLI_UPGRADE_COMMAND = "npm install -g co-maintainer@latest";
 export const REMOTE_MAX_BODY_BYTES = 52_428_800;
 export const REMOTE_SYNC_INTERVAL_SECONDS = 3;
-/** SHA-256 of sorted `fixtures/v<N>/*.json` (name + contents); bump with schema version. */
+/** SHA-256 of sorted `fixtures/v<N>/*.json` (name + contents, `\r\n` normalized
+ * to `\n`); bump with schema version. */
 export const REMOTE_FIXTURE_HASH = {
-    1: "1cbb11016227fcc7fc58b692ed5a2b72dc9b0e23b4cf68858e2d7facc98efd79",
+    1: "71e4e5f8637eab4b53d47817a688812a517310d967abe26aa0d7f4e7d7d65092",
 };
 export const REMOTE_SYNC_STATUSES = [
     "queued",

package/dist/src/server/pages/router.js

@@ -20,7 +20,16 @@ import { getRepo } from "../../store/repos.js";
 import { getJob } from "../../store/jobs.js";
 import { getLogsSince } from "../../services/jobs.js";
 import { listInstallationsWithRepos } from "../../github/app.js";
-const REPO = /^\/repos\/([^/]+)\/([^/]+)(?:\/(pulls|knowledge|settings)(?:\/(\d+))?)?$/;
+const REPO = /^\/repos\/([^/]+)\/([^/]+)(?:\/(pulls|knowledge|settings|remote)(?:\/(\d+))?)?$/;
+/** Matches a repository page URL. Only `pulls` is keyed by a number, so a stray
+ * suffix such as `/repos/o/r/remote/7` must fall through to a 404 rather than
+ * render the listing and silently drop the number. */
+function matchRepo(pathname) {
+    const match = REPO.exec(pathname);
+    if (match && match[4] && match[3] !== "pulls")
+        return null;
+    return match;
+}
 export async function handlePageRequest(request, deps, ip) {
     const url = new URL(request.url);
     if (url.pathname === "/styles.css" && request.method === "GET") {
@@ -126,7 +135,7 @@ export async function handlePageRequest(request, deps, ip) {
             const config = readConfig();
             return renderSettings(username, config, config.webhookUrl || deps.webhookUrl || "");
         }
-        const match = REPO.exec(url.pathname);
+        const match = matchRepo(url.pathname);
         if (match && request.method === "GET") {
             const fullName = `${decodeURIComponent(match[1])}/${decodeURIComponent(match[2])}`;
             const row = requireRepo(fullName);

package/dist/src/store/sqlite.d.ts

@@ -2,9 +2,10 @@
  * surface the store layer was written against: a synchronous `Database`,
  * `prepare<T>()` generics, `.get()/.all()/.run()`, and `db.changes`.
  *
- * Two behaviours of the JSR driver must be reproduced on top of
+ * Three behaviours of the JSR driver must be reproduced on top of
  * `node:sqlite`:
  *  - `undefined` parameters bind as SQL NULL (node:sqlite rejects undefined)
+ *  - `boolean` parameters bind as 0/1 (node:sqlite rejects booleans)
  *  - `db.changes` reports the rows modified by the most recent `run()`, which
  *    `node:sqlite` only returns from the statement call
  */

package/dist/src/store/sqlite.js

@@ -2,9 +2,10 @@
  * surface the store layer was written against: a synchronous `Database`,
  * `prepare<T>()` generics, `.get()/.all()/.run()`, and `db.changes`.
  *
- * Two behaviours of the JSR driver must be reproduced on top of
+ * Three behaviours of the JSR driver must be reproduced on top of
  * `node:sqlite`:
  *  - `undefined` parameters bind as SQL NULL (node:sqlite rejects undefined)
+ *  - `boolean` parameters bind as 0/1 (node:sqlite rejects booleans)
  *  - `db.changes` reports the rows modified by the most recent `run()`, which
  *    `node:sqlite` only returns from the statement call
  */
@@ -32,11 +33,25 @@ export class Statement {
     }
 }
 /** Normalizes call arguments: a single object binds by name, everything else
- * is a positional list with `undefined` mapped to NULL. */
+ * is a positional list. Values `node:sqlite` refuses are mapped to what it
+ * accepts — `undefined` to NULL, booleans to 0/1 — on both paths, so a field
+ * typed `boolean | undefined` survives a named bind too. */
 function args(params) {
-    if (params.length === 1 && isBindObject(params[0]))
-        return [params[0]];
-    return params.map((value) => value === undefined ? null : value);
+    if (params.length === 1 && isBindObject(params[0])) {
+        const bound = {};
+        for (const [key, value] of Object.entries(params[0])) {
+            bound[key] = normalize(value);
+        }
+        return [bound];
+    }
+    return params.map((value) => normalize(value));
+}
+function normalize(value) {
+    if (value === undefined)
+        return null;
+    if (typeof value === "boolean")
+        return value ? 1 : 0;
+    return value;
 }
 function isBindObject(value) {
     return (typeof value === "object" &&

package/dist/src/tools/codegraph.d.ts

@@ -15,10 +15,13 @@ export type EnsureOptions = {
     allowInstall?: boolean;
     interactive?: boolean;
     run?: Runner;
-    confirm?: (question: string) => boolean;
+    /** `node:readline/promises` made this async; both shapes are accepted. */
+    confirm?: (question: string) => boolean | Promise<boolean>;
     log?: (message: string) => void;
     /** Overrides `toolsDir()`, for tests. */
     root?: string;
+    /** Overrides `process.exit`, for tests. */
+    exit?: (code: number) => never;
 };
 export declare function runCommand(command: string, args: string[]): Promise<CommandResult>;
 /** One version per directory, so several can sit side by side and an upgrade

package/dist/src/tools/codegraph.js

@@ -85,6 +85,9 @@ export async function ensureCodegraph(options = {}) {
     const run = options.run ?? runCommand;
     const log = options.log ?? ((message) => console.log(message));
     const interactive = options.interactive ?? process.stdin.isTTY === true;
+    // Annotated so TypeScript can see the calls below never return and keeps the
+    // `Presence` narrowing intact.
+    const exit = options.exit ?? process.exit;
     const present = await detect(CODEGRAPH_VERSION, root, run);
     if (present.state === "ok")
         return present.path;
@@ -96,14 +99,16 @@ export async function ensureCodegraph(options = {}) {
         if (!interactive) {
             log(`[codegraph] co-maintainer needs codegraph ${CODEGRAPH_VERSION} to index the repository.\n` +
                 `Run it with --allow-tool-install, or install it yourself:\n  ${installHint(CODEGRAPH_VERSION, root)}`);
-            process.exit(1);
+            exit(1);
         }
         const confirm = options.confirm ?? defaultConfirm;
-        const approved = confirm(`co-maintainer needs codegraph ${CODEGRAPH_VERSION} to index the repository.\n` +
+        // `defaultConfirm` is async, so an unawaited call is always truthy and the
+        // user's "no" was silently ignored. Await it before deciding.
+        const approved = await confirm(`co-maintainer needs codegraph ${CODEGRAPH_VERSION} to index the repository.\n` +
             `Install it into ${versionDir(CODEGRAPH_VERSION, root)} (your global PATH is not touched)?`);
         if (!approved) {
             log("[codegraph] declined; nothing was installed");
-            process.exit(1);
+            exit(1);
         }
     }
     const { command, args } = installCommand(CODEGRAPH_VERSION, root);
@@ -112,12 +117,12 @@ export async function ensureCodegraph(options = {}) {
     const result = await run(command, args);
     if (result.code !== 0) {
         log(`[codegraph] install failed (exit ${result.code}): ${result.stderr.trim() || result.stdout.trim()}`);
-        process.exit(1);
+        exit(1);
     }
     const after = await detect(CODEGRAPH_VERSION, root, run);
     if (after.state !== "ok") {
         log(`[codegraph] install finished but ${binaryPath(CODEGRAPH_VERSION, root)} is still not usable`);
-        process.exit(1);
+        exit(1);
     }
     log(`[codegraph] ready at ${after.path}`);
     return after.path;
@@ -141,7 +146,8 @@ export async function ensureCodegraphForReview(options = {}) {
             };
         }
         const confirm = options.confirm ?? defaultConfirm;
-        const approved = confirm(`co-maintainer needs codegraph ${CODEGRAPH_VERSION} to index this repository.\n` +
+        // Same as `ensureCodegraph`: an unawaited async confirm is always truthy.
+        const approved = await confirm(`co-maintainer needs codegraph ${CODEGRAPH_VERSION} to index this repository.\n` +
             `Install into ${versionDir(CODEGRAPH_VERSION, root)}?`);
         if (!approved)
             return { reason: "codegraph install declined" };

package/dist/src/tools/codegraph_exec.d.ts

@@ -7,7 +7,13 @@ export type ExecOptions = {
     env?: Record<string, string>;
 };
 export type CodegraphRunner = (binary: string, args: string[], worktree: string) => Promise<CommandResult>;
-/** Run the codegraph CLI in a repo root (plan §13.4). No `cmd /c` wrapper. */
+/** Run the codegraph CLI in a repo root (plan §13.4).
+ *
+ * On Windows the CLI is a `.cmd`/`.ps1` shim, and `node:child_process.spawn`
+ * cannot execute those without a shell — it fails with `EINVAL`. `Deno.Command`
+ * resolved them natively, so this wrapper is needed only after the Node move.
+ * Route through `cmd /c` exactly like `pr/checkout.ts` does for `git`.
+ */
 export declare function execCodegraph(binary: string, args: string[], cwd: string, options?: ExecOptions): Promise<CommandResult>;
 export declare function createCodegraphRunner(indexDir: string): CodegraphRunner;
 export declare function runCodegraphTool(binary: string, args: string[], worktree: string, runner: CodegraphRunner): Promise<string>;

package/dist/src/tools/codegraph_exec.js

@@ -1,9 +1,15 @@
-import { commandOutput, commandSpawn, envToObject, } from "../util/runtime.js";
+import { commandOutput, commandSpawn, envToObject, isWindows, } from "../util/runtime.js";
 export const LOCAL_CODEGRAPH_DIR = ".co-maintainer-codegraph";
 export const SERVER_CODEGRAPH_DIR = ".codegraph";
 const TOOL_TIMEOUT_MS = 60_000;
 const INDEX_COMMANDS = new Set(["init", "sync", "index", "unlock"]);
-/** Run the codegraph CLI in a repo root (plan §13.4). No `cmd /c` wrapper. */
+/** Run the codegraph CLI in a repo root (plan §13.4).
+ *
+ * On Windows the CLI is a `.cmd`/`.ps1` shim, and `node:child_process.spawn`
+ * cannot execute those without a shell — it fails with `EINVAL`. `Deno.Command`
+ * resolved them natively, so this wrapper is needed only after the Node move.
+ * Route through `cmd /c` exactly like `pr/checkout.ts` does for `git`.
+ */
 export async function execCodegraph(binary, args, cwd, options = {}) {
     const indexDir = options.codegraphDir ?? LOCAL_CODEGRAPH_DIR;
     const env = {
@@ -12,18 +18,20 @@ export async function execCodegraph(binary, args, cwd, options = {}) {
         ...options.env,
     };
     const timeoutMs = options.timeoutMs === undefined ? TOOL_TIMEOUT_MS : options.timeoutMs;
+    const windows = isWindows();
     const commandOptions = {
-        args,
+        args: windows ? ["/c", binary, ...args] : args,
         cwd,
         env,
         stdout: "piped",
         stderr: "piped",
     };
+    const target = windows ? "cmd" : binary;
     if (timeoutMs === null) {
-        const output = await commandOutput(binary, commandOptions);
+        const output = await commandOutput(target, commandOptions);
         return decode(output);
     }
-    const proc = commandSpawn(binary, commandOptions);
+    const proc = commandSpawn(target, commandOptions);
     let timedOut = false;
     const timer = setTimeout(() => {
         timedOut = true;

package/dist/src/util/runtime.d.ts

@@ -40,7 +40,11 @@ export declare function makeTempDir(options?: {
 export declare function makeTempDirSync(options?: {
     prefix?: string;
 }): string;
-/** A uniquely named temp file (created empty), mirroring `Deno.makeTempFile`. */
+/** A uniquely named temp file (created empty), mirroring `Deno.makeTempFile`.
+ *
+ * `wx` fails on collision instead of truncating an existing file, so the retry
+ * loop preserves `mkdtemp`'s uniqueness without leaving a directory behind —
+ * callers only ever delete the returned file. */
 export declare function makeTempFile(options?: {
     prefix?: string;
     suffix?: string;
@@ -87,4 +91,13 @@ export declare function commandSpawn(command: string, options?: CommandOptions):
  * POSIX: signal 0 checks existence without delivering; `ESRCH` means dead,
  * while `EPERM` (or anything else) means it exists but is not ours — assume
  * alive rather than risk two writers on the same database. */
+/** Decides Windows PID liveness from a `tasklist` invocation. A matching row is
+ * CSV and starts with the quoted image name; the "no tasks" notice is prose, so
+ * the distinction is locale-independent. A spawn failure or an empty body is
+ * indeterminate and reports alive: refusing to start beats letting a second
+ * writer take over a live lock. */
+export declare function livenessFromTasklist(result: {
+    error?: unknown;
+    stdout?: string | null;
+}): boolean;
 export declare function isProcessAlive(pid: number): boolean;

package/dist/src/util/runtime.js

@@ -102,13 +102,27 @@ export function makeTempDir(options) {
 export function makeTempDirSync(options) {
     return fsMkdtempSync(join(tmpdir(), options?.prefix ?? "cm-"));
 }
-/** A uniquely named temp file (created empty), mirroring `Deno.makeTempFile`. */
+/** A uniquely named temp file (created empty), mirroring `Deno.makeTempFile`.
+ *
+ * `wx` fails on collision instead of truncating an existing file, so the retry
+ * loop preserves `mkdtemp`'s uniqueness without leaving a directory behind —
+ * callers only ever delete the returned file. */
 export async function makeTempFile(options) {
-    const dir = await fsMkdtemp(join(tmpdir(), options?.prefix ?? "cm-"));
-    const name = `${crypto.randomUUID()}${options?.suffix ?? ""}`;
-    const path = join(dir, name);
-    await fsWriteFile(path, "");
-    return path;
+    const prefix = options?.prefix ?? "cm-";
+    const suffix = options?.suffix ?? "";
+    for (let attempt = 0; attempt < 10; attempt++) {
+        const path = join(tmpdir(), `${prefix}${crypto.randomUUID()}${suffix}`);
+        try {
+            await fsWriteFile(path, "", { flag: "wx" });
+            return path;
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                continue;
+            throw error;
+        }
+    }
+    throw new Error(`could not create a temp file with prefix ${prefix}`);
 }
 export async function* readDir(dir) {
     for (const entry of await readdir(dir, { withFileTypes: true })) {
@@ -189,12 +203,25 @@ export function commandSpawn(command, options = {}) {
  * POSIX: signal 0 checks existence without delivering; `ESRCH` means dead,
  * while `EPERM` (or anything else) means it exists but is not ours — assume
  * alive rather than risk two writers on the same database. */
+/** Decides Windows PID liveness from a `tasklist` invocation. A matching row is
+ * CSV and starts with the quoted image name; the "no tasks" notice is prose, so
+ * the distinction is locale-independent. A spawn failure or an empty body is
+ * indeterminate and reports alive: refusing to start beats letting a second
+ * writer take over a live lock. */
+export function livenessFromTasklist(result) {
+    if (result.error)
+        return true;
+    const out = (result.stdout ?? "").trim();
+    if (out === "")
+        return true;
+    return out.startsWith('"');
+}
 export function isProcessAlive(pid) {
     if (isWindows()) {
         const result = spawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
             encoding: "utf8",
         });
-        return (result.stdout ?? "").trim().startsWith('"');
+        return livenessFromTasklist(result);
     }
     try {
         process.kill(pid, 0);

package/package.json

@@ -1,10 +1,25 @@
 {
   "name": "co-maintainer",
-  "version": "0.4.0-beta.2",
+  "version": "0.4.0",
   "description": "Analyzes a GitHub repository and writes repository-specific contribution guidance.",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GroophyLifefor/co-maintainer"
+  },
+  "homepage": "https://github.com/GroophyLifefor/co-maintainer#readme",
+  "bugs": {
+    "url": "https://github.com/GroophyLifefor/co-maintainer/issues"
+  },
+  "keywords": [
+    "github",
+    "pull-request",
+    "code-review",
+    "maintainer",
+    "ai"
+  ],
   "bin": {
-    "co-maintainer": "./dist/main.js"
+    "co-maintainer": "dist/main.js"
   },
   "files": [
     "dist/",