co-maintainer 0.5.1 → 0.5.3

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "co-maintainer",
-    "version": "0.5.1",
+    "version": "0.5.3",
     "description": "An imitator of yours, A PR review tool like co-maintainer.",
     "keywords": [
         "ai",
@@ -59,11 +59,9 @@
         "dx:scenario": "node scripts/dx_scenario.ts",
         "dashboard:smoke": "node scripts/dashboard_smoke.ts"
     },
-    "dependencies": {
-        "marked": "^15.0.7"
-    },
     "devDependencies": {
         "@types/node": "^24.0.0",
+        "marked": "^15.0.7",
         "oxfmt": "^0.68.0",
         "oxlint": "^1.83.0",
         "playwright": "^1.63.0",

package/dist/src/ai/anthropic.js

@@ -1,4 +1,5 @@
 import { getEnv } from "../util/runtime.js";
+import { outputLimitError } from "./provider.js";
 import { CliError, EXIT_RUNTIME, EXIT_USAGE, networkFailure, } from "../cli/error.js";
 /** Required on every Messages request and the only version the errors below
  * are written against. */
@@ -197,8 +198,12 @@ export function parseMessagesBody(json, model) {
         }
     }
     const usage = json.usage;
+    const text = texts.join("");
+    if (json.stop_reason === "max_tokens" && !text.trim() && !toolCalls.length) {
+        throw outputLimitError("anthropic", model);
+    }
     return {
-        text: texts.join(""),
+        text,
         ...(toolCalls.length ? { toolCalls } : {}),
         // Tokens read from or written to the prompt cache are input too, and with
         // the guides cached they are most of it.

package/dist/src/ai/openai.js

@@ -1,4 +1,5 @@
 import { getEnv } from "../util/runtime.js";
+import { outputLimitError, withoutRefusedPart } from "./provider.js";
 import { CliError, EXIT_RUNTIME, EXIT_USAGE, networkFailure, } from "../cli/error.js";
 /** `CM_OPENAI_URL` points at a local fake in tests. Unset means the real
  * endpoint, so production behavior is unchanged. */
@@ -145,8 +146,12 @@ function parseResponsesBody(json, model) {
         }
     }
     const usage = json.usage;
+    const text = texts.join("");
+    if (json.status === "incomplete" && !text.trim() && !toolCalls.length) {
+        throw outputLimitError("openai", model);
+    }
     return {
-        text: texts.join(""),
+        text,
         ...(toolCalls.length ? { toolCalls } : {}),
         tokensIn: Number(usage?.input_tokens ?? 0),
         tokensOut: Number(usage?.output_tokens ?? 0),
@@ -184,25 +189,19 @@ export class OpenAiProvider {
         }
     }
     async complete(request) {
-        let response = await this.post(responsesBody(this.model, request));
-        // A model may reject `text.format` next to tools. The schema is only a
-        // hint (the prompt also asks for a fenced JSON block), so one retry
-        // without it beats failing the review outright.
-        if (response.status === 400 && request.responseFormat) {
-            const detail = await response.text();
-            if (/text\.format|json_schema|structured/i.test(detail)) {
-                const { responseFormat: _dropped, ...withoutSchema } = request;
-                response = await this.post(responsesBody(this.model, withoutSchema));
-                if (response.ok) {
-                    return parseResponsesBody((await response.json()), this.model);
-                }
-                throw openAiError(this.model, response.status, await response.text());
+        let current = request;
+        for (;;) {
+            const response = await this.post(responsesBody(this.model, current));
+            if (response.ok) {
+                return parseResponsesBody((await response.json()), this.model);
             }
-            throw openAiError(this.model, response.status, detail);
-        }
-        if (!response.ok) {
-            throw openAiError(this.model, response.status, await response.text());
+            const detail = await response.text();
+            const lighter = response.status === 400
+                ? withoutRefusedPart(current, detail, /text\.format|json_schema|structured/i)
+                : undefined;
+            if (!lighter)
+                throw openAiError(this.model, response.status, detail);
+            current = lighter;
         }
-        return parseResponsesBody((await response.json()), this.model);
     }
 }

package/dist/src/ai/openrouter.js

@@ -1,4 +1,4 @@
-import { chatBody, parseChatResponse } from "./provider.js";
+import { chatBody, parseChatResponse, withoutRefusedPart } from "./provider.js";
 import { getEnv } from "../util/runtime.js";
 import { CliError, EXIT_RUNTIME, EXIT_USAGE, networkFailure, } from "../cli/error.js";
 /** `CM_OPENROUTER_URL` points the provider at a local fake in tests. It is
@@ -75,25 +75,19 @@ export class OpenRouterProvider {
         return openRouterError(this.model, status, body, this.host);
     }
     async complete(request) {
-        let response = await this.post(chatBody(this.model, request));
-        // A provider may refuse `response_format` next to `tools`. The schema is
-        // only a hint — the prompt also asks for a fenced JSON block — so one
-        // retry without it is better than failing the review.
-        if (response.status === 400 && request.responseFormat) {
-            const detail = await response.text();
-            if (/response_format|json_schema|structured/i.test(detail)) {
-                const { responseFormat: _dropped, ...withoutSchema } = request;
-                response = await this.post(chatBody(this.model, withoutSchema));
-                if (response.ok) {
-                    return parseChatResponse((await response.json()), this.host.provider, this.model);
-                }
-                throw this.fail(response.status, await response.text());
+        let current = request;
+        for (;;) {
+            const response = await this.post(chatBody(this.model, current));
+            if (response.ok) {
+                return parseChatResponse((await response.json()), this.host.provider, this.model);
             }
-            throw this.fail(response.status, detail);
-        }
-        if (!response.ok) {
-            throw this.fail(response.status, await response.text());
+            const detail = await response.text();
+            const lighter = response.status === 400
+                ? withoutRefusedPart(current, detail, /response_format|json_schema|structured/i)
+                : undefined;
+            if (!lighter)
+                throw this.fail(response.status, detail);
+            current = lighter;
         }
-        return parseChatResponse((await response.json()), this.host.provider, this.model);
     }
 }

package/dist/src/ai/provider.d.ts

@@ -7,5 +7,14 @@ export { providerKeyEnv } from "../config.ts";
 /** Hetzner was dropped in 0.5.1. Naming it beats a generic "must be one of". */
 export declare function rejectRetiredProvider(value: string | undefined): void;
 export declare function createAiProvider(options: Options, model: string): AiProvider | undefined;
+/** A 400 that names one optional part of the request earns one retry without
+ * it: the JSON schema, which the prompt asks for anyway, or "thinking off",
+ * which a model that always thinks refuses. Undefined when nothing is left to
+ * drop, so the caller reports the error. */
+export declare function withoutRefusedPart(request: AiRequest, detail: string, schemaPattern: RegExp): AiRequest | undefined;
+/** The model stopped at its output limit before writing a word. Thinking counts
+ * toward that limit, so a thinking model can spend all of it there. Without
+ * this the empty answer read as a normal one and failed later as "not JSON". */
+export declare function outputLimitError(provider: string, model: string): Error;
 export declare function parseChatResponse(json: Json, provider: AiResponse["provider"], model: string): AiResponse;
 export declare function chatBody(model: string, request: AiRequest): Json;

package/dist/src/ai/provider.js

@@ -38,6 +38,28 @@ export function createAiProvider(options, model) {
     }
     die(`${options.ai} support is not finished yet. Use openrouter or none.`);
 }
+/** A 400 that names one optional part of the request earns one retry without
+ * it: the JSON schema, which the prompt asks for anyway, or "thinking off",
+ * which a model that always thinks refuses. Undefined when nothing is left to
+ * drop, so the caller reports the error. */
+export function withoutRefusedPart(request, detail, schemaPattern) {
+    if (request.responseFormat && schemaPattern.test(detail)) {
+        const { responseFormat: _dropped, ...rest } = request;
+        return rest;
+    }
+    if (request.reasoningEffort === "none" &&
+        /reasoning|effort|thinking/i.test(detail)) {
+        const { reasoningEffort: _dropped, ...rest } = request;
+        return rest;
+    }
+    return undefined;
+}
+/** The model stopped at its output limit before writing a word. Thinking counts
+ * toward that limit, so a thinking model can spend all of it there. Without
+ * this the empty answer read as a normal one and failed later as "not JSON". */
+export function outputLimitError(provider, model) {
+    return new Error(`${provider} model ${model} reached its output limit before writing an answer. Thinking counts toward that limit.`);
+}
 export function parseChatResponse(json, provider, model) {
     const choice = Array.isArray(json.choices)
         ? json.choices[0]
@@ -61,8 +83,14 @@ export function parseChatResponse(json, provider, model) {
         })
             .filter((call) => call.id && call.function.name)
         : undefined;
+    const text = String(message?.content ?? "");
+    if (choice?.finish_reason === "length" &&
+        !text.trim() &&
+        !toolCalls?.length) {
+        throw outputLimitError(provider, model);
+    }
     return {
-        text: String(message?.content ?? ""),
+        text,
         ...(toolCalls?.length ? { toolCalls } : {}),
         tokensIn: Number(usage?.prompt_tokens ?? 0),
         tokensOut: Number(usage?.completion_tokens ?? 0),

package/dist/src/cli/commands/clear.d.ts

@@ -0,0 +1 @@
+export declare function runClear(args: string[]): Promise<void>;

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

@@ -0,0 +1,152 @@
+/** `co-maintainer clear`: delete what `init` produced.
+ *
+ * A repository goes back to "never inited": guides, the knowledge stamp, the
+ * skill state and the settings `init` remembered are gone, so the next build
+ * is `init`, not `sync`. `--include-cache` reaches further and takes the
+ * fetched evidence too, which makes that next init a cold build.
+ *
+ * `all` touches every repository on the machine, so it asks first. Pending
+ * jobs are asked about separately because they would otherwise rebuild the
+ * knowledge after it was cleared. */
+import { CliError, EXIT_USAGE } from "../error.js";
+import { askConfirm } from "../prompt.js";
+import { canPrompt } from "../../tools/codegraph.js";
+import { liveLockPid } from "../../store/app_db.js";
+import { unknownOptionMessage } from "./registry.js";
+import { cancelOrphanedJobs, cancelQueuedJobs, clearRepos, clearRepo, isSafeRepoName, listStoredRepos, repoJobs, withAppDbIfPresent, } from "../../services/clear.js";
+/** "3 guides, 1 cache row, saved settings" without a trailing separator. */
+function joinParts(parts) {
+    return parts.join(", ");
+}
+function repoParts(result) {
+    const parts = [];
+    if (result.guides > 0)
+        parts.push(`${result.guides} guide file(s)`);
+    if (result.cacheRows > 0)
+        parts.push(`${result.cacheRows} cache row(s)`);
+    if (result.clones)
+        parts.push("the clone");
+    if (result.worktrees)
+        parts.push("the worktrees");
+    if (result.settings)
+        parts.push("saved settings");
+    return parts;
+}
+function printRepo(result) {
+    const parts = repoParts(result);
+    if (parts.length === 0) {
+        console.log(`Nothing to clear for ${result.repo}.`);
+        return;
+    }
+    console.log(`Cleared ${result.repo}: ${joinParts(parts)}.`);
+}
+function printAll(result) {
+    if (result.repos.length === 0) {
+        console.log("Nothing to clear.");
+        return;
+    }
+    for (const repo of result.repos) {
+        const parts = repoParts(repo);
+        if (parts.length > 0) {
+            console.log(`Cleared ${repo.repo}: ${joinParts(parts)}.`);
+        }
+    }
+    const extra = [];
+    if (result.cacheFile)
+        extra.push("cache.db");
+    if (result.clones)
+        extra.push("every clone");
+    if (result.worktrees)
+        extra.push("every worktree");
+    if (result.settings)
+        extra.push("saved settings");
+    const tail = extra.length > 0 ? ` Also cleared ${joinParts(extra)}.` : "";
+    console.log(`Cleared ${result.repos.length} repositories.${tail}`);
+}
+/** What the pending-job question should say. */
+function jobSummary(repos) {
+    const jobs = repoJobs(repos);
+    const parts = [];
+    if (jobs.queued.length > 0)
+        parts.push(`${jobs.queued.length} queued`);
+    if (jobs.running.length > 0)
+        parts.push(`${jobs.running.length} unfinished`);
+    if (parts.length === 0)
+        return undefined;
+    return `This target has ${joinParts(parts)} job(s).`;
+}
+/** Pending jobs would rebuild the knowledge this command is deleting. The
+ * question is asked once for the whole target. Without a terminal (or with
+ * `--yes`) they are canceled: keeping them would contradict the clear. */
+async function handlePendingJobs(repos, assumeYes) {
+    await withAppDbIfPresent(async () => {
+        const summary = jobSummary(repos);
+        if (summary === undefined)
+            return;
+        const cancelThem = !canPrompt()
+            ? true
+            : assumeYes || (await askConfirm(`${summary} Cancel them?`));
+        if (!cancelThem) {
+            console.log("Pending jobs were kept. They can rebuild the knowledge later.");
+            return;
+        }
+        const canceled = cancelQueuedJobs(repos) + cancelOrphanedJobs(repos);
+        if (canceled > 0)
+            console.log(`Canceled ${canceled} job(s).`);
+    });
+}
+export async function runClear(args) {
+    let includeCache = false;
+    let yes = false;
+    const positionals = [];
+    for (const arg of args) {
+        if (arg === "--include-cache") {
+            includeCache = true;
+            continue;
+        }
+        if (arg === "--yes") {
+            yes = true;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new CliError("usage", unknownOptionMessage(arg, "clear"));
+        }
+        positionals.push(arg);
+    }
+    const target = positionals[0];
+    if (positionals.length !== 1 || !target) {
+        throw new CliError("usage", "clear needs one target: owner/repo or all.", "Usage: co-maintainer clear <owner/repo|all> [--include-cache] [--yes]");
+    }
+    const all = target === "all";
+    if (!all && !isSafeRepoName(target)) {
+        throw new CliError("usage", "Repository must look like owner/repo");
+    }
+    // A live serve owns guides and caches: clearing underneath it would confuse
+    // webhooks and remote clients mid-flight. The same guard rollback uses.
+    const pid = await liveLockPid();
+    if (pid !== undefined) {
+        throw new CliError("serve_already_running", `A co-maintainer serve process (pid ${pid}) is using this data directory.`, "Stop it, then run clear again.", EXIT_USAGE);
+    }
+    const repos = all ? await listStoredRepos() : [target];
+    if (all && !yes) {
+        if (!canPrompt()) {
+            throw new CliError("confirmation_required", "clear all needs your confirmation.", "Run it in a terminal, or pass --yes.", EXIT_USAGE);
+        }
+        const scope = includeCache
+            ? "guides, settings, cached evidence, clones and worktrees"
+            : "guides and saved settings";
+        console.log(`This deletes the ${scope} of ${repos.length} repositories on this machine.`);
+        if (!(await askConfirm("Clear them?"))) {
+            console.log("Nothing changed.");
+            return;
+        }
+    }
+    await handlePendingJobs(repos, yes);
+    // The snapshot the jobs were negotiated against is the one that gets
+    // cleared, so the printed count matches what actually went.
+    if (all)
+        printAll(await clearRepos(repos, { includeCache }));
+    else
+        printRepo(await clearRepo(target, { includeCache }));
+    console.log(`Run co-maintainer init ${all ? "owner/repo" : target} to build the guides again.`);
+}

package/dist/src/cli/commands/registry.d.ts

@@ -30,6 +30,10 @@ export declare function findCommand(name: string): CommandSpec | undefined;
 /** Commands listed in the global help. A hidden alias or command is resolvable
  * but invisible. */
 export declare function visibleCommands(): CommandSpec[];
+/** The visible command names in help order. Tests and scripts iterate this
+ * instead of repeating the list, so a new command cannot be forgotten in one
+ * place and present in another. */
+export declare function visibleCommandNames(): string[];
 /** Levenshtein distance, iterative and allocation-light: the help path runs it
  * on every unknown token, and the strings are short. */
 export declare function levenshtein(a: string, b: string): number;

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

@@ -430,6 +430,48 @@ export const COMMANDS = [
             "co-maintainer view owner/repo --remote",
         ],
     },
+    {
+        name: "clear",
+        summary: "Delete the generated guides and saved settings for a repository, or for every repository.",
+        usage: ["co-maintainer clear <owner/repo|all> [options]"],
+        groups: [
+            {
+                title: "Clear",
+                flags: [
+                    {
+                        name: "include-cache",
+                        description: "Also delete the fetched evidence: pull request listings, AI job cache, costs, local review carry-over, clones and worktrees. The next init is then a cold build.",
+                    },
+                    {
+                        name: "yes",
+                        description: "Skip the confirmation `all` asks. Needed when there is no terminal.",
+                    },
+                ],
+            },
+        ],
+        examples: [
+            "co-maintainer clear owner/repo",
+            "co-maintainer clear owner/repo --include-cache",
+            "co-maintainer clear all --include-cache --yes",
+        ],
+    },
+    {
+        name: "uninstall",
+        summary: "Delete every co-maintainer data file on this machine.",
+        usage: ["co-maintainer uninstall [--yes]"],
+        groups: [
+            {
+                title: "Uninstall",
+                flags: [
+                    {
+                        name: "yes",
+                        description: "Skip the confirmation. Needed when there is no terminal.",
+                    },
+                ],
+            },
+        ],
+        examples: ["co-maintainer uninstall", "co-maintainer uninstall --yes"],
+    },
     {
         name: "set",
         summary: "Persist defaults and secrets to the user config file.",
@@ -644,6 +686,12 @@ export function findCommand(name) {
 export function visibleCommands() {
     return COMMANDS.filter((command) => !command.hidden);
 }
+/** The visible command names in help order. Tests and scripts iterate this
+ * instead of repeating the list, so a new command cannot be forgotten in one
+ * place and present in another. */
+export function visibleCommandNames() {
+    return visibleCommands().map((command) => command.name);
+}
 /** Levenshtein distance, iterative and allocation-light: the help path runs it
  * on every unknown token, and the strings are short. */
 export function levenshtein(a, b) {

package/dist/src/cli/commands/uninstall.d.ts

@@ -0,0 +1 @@
+export declare function runUninstall(args: string[]): Promise<void>;

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

@@ -0,0 +1,43 @@
+/** `co-maintainer uninstall`: delete every data file this machine holds.
+ *
+ * The npm package cannot remove itself while the CLI runs from it, so the
+ * command deletes the config, databases, guides, clones, worktrees and tools
+ * and then prints the npm command that finishes the job. */
+import { CliError, EXIT_USAGE } from "../error.js";
+import { askConfirm } from "../prompt.js";
+import { canPrompt } from "../../tools/codegraph.js";
+import { liveLockPid } from "../../store/app_db.js";
+import { unknownOptionMessage } from "./registry.js";
+import { uninstallData } from "../../services/clear.js";
+export async function runUninstall(args) {
+    for (const arg of args) {
+        if (arg !== "--yes") {
+            throw new CliError("usage", unknownOptionMessage(arg, "uninstall"));
+        }
+    }
+    const pid = await liveLockPid();
+    if (pid !== undefined) {
+        throw new CliError("serve_already_running", `A co-maintainer serve process (pid ${pid}) is using this data directory.`, "Stop it, then run uninstall again.", EXIT_USAGE);
+    }
+    if (!args.includes("--yes")) {
+        if (!canPrompt()) {
+            throw new CliError("confirmation_required", "Uninstall needs your confirmation.", "Run it in a terminal, or pass --yes.", EXIT_USAGE);
+        }
+        console.log("This deletes every co-maintainer data file: config.json, the databases, guides, clones, worktrees and tools.");
+        if (!(await askConfirm("Uninstall?"))) {
+            console.log("Nothing changed.");
+            return;
+        }
+    }
+    const removed = await uninstallData();
+    if (removed.paths.length === 0) {
+        console.log("Nothing to remove.");
+    }
+    else {
+        console.log("Removed:");
+        for (const path of removed.paths)
+            console.log(`  ${path}`);
+    }
+    console.log("The CLI itself is still installed. Remove it with:");
+    console.log("  npm uninstall -g co-maintainer");
+}

package/dist/src/cli/main.js

@@ -6,6 +6,8 @@ import { runRollback } from "./commands/rollback.js";
 import { runSet } from "./commands/set.js";
 import { runConfig } from "./commands/config.js";
 import { runView } from "./commands/view.js";
+import { runClear } from "./commands/clear.js";
+import { runUninstall } from "./commands/uninstall.js";
 import { runProbe } from "./commands/probe.js";
 import { runReviewFromCli } from "./commands/review.js";
 import { runInitOrRemake } from "../services/setup.js";
@@ -68,6 +70,14 @@ export async function run(args) {
         await runView(args.slice(1));
         return;
     }
+    if (args[0] === "clear") {
+        await runClear(args.slice(1));
+        return;
+    }
+    if (args[0] === "uninstall") {
+        await runUninstall(args.slice(1));
+        return;
+    }
     if (args[0] === "serve") {
         await runServe(args.slice(1));
         return;

package/dist/src/config.d.ts

@@ -142,8 +142,16 @@ export declare function repoSlug(repo: string): string;
  * Windows is the roaming profile and gets synced across machines. */
 export declare function clonesDir(): string;
 export declare function cloneDir(repo: string): string;
+/** The directory holding one repository's PR worktrees. `clear` removes it
+ * whole, so the layout lives in one place instead of at each call site. */
+export declare function repoWorktreesDir(repo: string): string;
+/** Every repository's worktrees, for `clear all` and `uninstall`. */
+export declare function worktreesDir(): string;
 export declare function worktreeDir(repo: string, pr: number): string;
 export declare function cacheDbPath(): string;
+/** Transient pid files that keep one local review per repository root.
+ * `uninstall` still takes them: they are co-maintainer data too. */
+export declare function locksDir(): string;
 export declare function loadEnvFile(path: string): void;
 export declare function readConfig(): UserConfig;
 /** The App private key to sign with. An inline `githubAppPrivateKey` wins,
@@ -158,6 +166,12 @@ export declare function appPrivateKeyFileMissing(config: Pick<UserConfig, "githu
 /** 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>;
+/** Drops `repos[repo]` from config.json. `clear` uses this so the repository
+ * goes back to "never inited": the next run resolves its flags again. Returns
+ * whether there was an entry to drop. */
+export declare function removeRepoConfig(repo: string): Promise<boolean>;
+/** Drops every per-repo entry. `clear all` forgets every repository it knows. */
+export declare function removeAllRepoConfig(): Promise<boolean>;
 /** 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. */

package/dist/src/config.js

@@ -117,12 +117,26 @@ export function clonesDir() {
 export function cloneDir(repo) {
     return `${clonesDir()}/${repoSlug(repo)}`;
 }
+/** The directory holding one repository's PR worktrees. `clear` removes it
+ * whole, so the layout lives in one place instead of at each call site. */
+export function repoWorktreesDir(repo) {
+    return `${getCacheDir()}/co-maintainer/wt/${repoSlug(repo)}`;
+}
+/** Every repository's worktrees, for `clear all` and `uninstall`. */
+export function worktreesDir() {
+    return `${getCacheDir()}/co-maintainer/wt`;
+}
 export function worktreeDir(repo, pr) {
-    return `${getCacheDir()}/co-maintainer/wt/${repoSlug(repo)}/${pr}`;
+    return `${repoWorktreesDir(repo)}/${pr}`;
 }
 export function cacheDbPath() {
     return `${getCacheDir()}/co-maintainer/cache.db`;
 }
+/** Transient pid files that keep one local review per repository root.
+ * `uninstall` still takes them: they are co-maintainer data too. */
+export function locksDir() {
+    return `${getCacheDir()}/co-maintainer/locks`;
+}
 export function loadEnvFile(path) {
     const contents = readTextFileSync(path);
     for (const line of contents.split(/\r?\n/)) {
@@ -200,6 +214,29 @@ export async function writeRepoConfig(repo, patch) {
     repos[repo] = Object.fromEntries(Object.entries({ ...repos[repo], ...patch }).filter(([, value]) => value !== undefined));
     await writeConfig({ ...config, repos });
 }
+/** Drops `repos[repo]` from config.json. `clear` uses this so the repository
+ * goes back to "never inited": the next run resolves its flags again. Returns
+ * whether there was an entry to drop. */
+export async function removeRepoConfig(repo) {
+    const config = readConfig();
+    if (!config.repos || !(repo in config.repos))
+        return false;
+    const repos = { ...config.repos };
+    delete repos[repo];
+    await writeConfig({
+        ...config,
+        repos: Object.keys(repos).length > 0 ? repos : undefined,
+    });
+    return true;
+}
+/** Drops every per-repo entry. `clear all` forgets every repository it knows. */
+export async function removeAllRepoConfig() {
+    const config = readConfig();
+    if (!config.repos || Object.keys(config.repos).length === 0)
+        return false;
+    await writeConfig({ ...config, repos: undefined });
+    return true;
+}
 /** 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. */

package/dist/src/knowledge/synthesis.js

@@ -157,6 +157,9 @@ function extractRequest(prompt, maxTokens) {
         job: "extract_unit",
         prompt,
         maxTokens,
+        // Pulling facts out of a text needs no thinking, and on a thinking model
+        // the thinking used the whole limit and left the answer empty.
+        reasoningEffort: "none",
         system: "Extract only repository-specific facts. Never invent files, commands, or process.",
     };
 }

package/dist/src/local/review_lock.js

@@ -1,4 +1,4 @@
-import { getCacheDir } from "../config.js";
+import { locksDir } from "../config.js";
 import { ReviewCliError } from "./git_ops.js";
 import { isNotFound, isProcessAlive, mkdir, readTextFile, remove, removeSync, writeTextFile, } from "../util/runtime.js";
 async function lockPath(gitRoot) {
@@ -7,7 +7,7 @@ async function lockPath(gitRoot) {
         .map((b) => b.toString(16).padStart(2, "0"))
         .join("")
         .slice(0, 16);
-    const dir = `${getCacheDir()}/co-maintainer/locks`;
+    const dir = locksDir();
     await mkdir(dir, { recursive: true });
     return `${dir}/${hex}.lock`;
 }

package/dist/src/server/api/knowledge.d.ts

@@ -0,0 +1,7 @@
+/** `undefined` means the clear may go ahead. A 409 carries enough detail for
+ * the page to ask the right question: whether to abort reviews and queued
+ * jobs, or to wait out a sync. */
+export declare function negotiateJobs(repos: string[], abort: boolean): Response | undefined;
+export declare function handleKnowledgeRoute(request: Request, url: URL): Promise<Response>;
+/** Shared by the per-repo route, which knows exactly one repository. */
+export declare function clearOneRepo(fullName: string, url: URL): Promise<Response>;