co-maintainer 0.5.2 → 0.5.3

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

@@ -13,7 +13,7 @@ export function renderKnowledge(username, data, viewId) {
         ? `<div class="notice"><div class="txt">Built ${when(data.repo.knowledge_built_at)}.${drift
             ? ` Since then: <b>${drift.prs_since} new pull requests</b>, <b>${drift.prs_updated} changed pull requests</b>, <b>${capped(drift.commits_since, MAX_COMMITS_COUNTED)} new commits</b> and <b>${capped(drift.files_changed, COMPARE_FILE_CAP)} changed files</b>. <span class="muted">Checked ${when(drift.as_of)}.</span>`
             : ""}</div></div>`
-        : `<div class="notice info"><div class="txt">Knowledge has not been built yet. Run init from the repository list.</div></div>`;
+        : `<div class="notice info"><div class="txt">Knowledge has not been built yet. Use Sync to build it.</div></div>`;
     const viewer = viewing
         ? `<div class="card"><div class="hd"><h2>${text(viewing.title)}</h2>
         <a class="btn sm" style="margin-left:auto" href="/repos/${text(name)}/knowledge">Close</a></div>
@@ -53,12 +53,31 @@ export function renderKnowledge(username, data, viewId) {
       <div class="hd"><h2>History</h2></div>
       <div class="bd">${empty("Only the current knowledge is kept", "Older versions are not stored yet.")}</div>
     </div>
+    <div class="card" data-async>
+      ${skSlot()}
+      <div class="hd"><h2>Clear</h2></div>
+      <div class="bd">
+        <p class="muted" style="margin:0 0 16px">Delete the guides and the saved settings for this repository. The next Sync builds them from scratch.</p>
+        <div class="field wide"><label><input type="checkbox" id="clear-cache"> Also delete the cached evidence: pull request listings, costs, clones and worktrees</label>
+          <div class="hint">Without it the next build still reuses the files and pull requests it already paid for.</div></div>
+      </div>
+      <div class="ft"><button id="clear" style="color:var(--red)">Clear knowledge</button></div>
+    </div>
   </div>
 </div>
 <script>
 document.getElementById("update").addEventListener("click", function() {
   postAndGo("/api/repos/" + ${JSON.stringify(name)} + "/remake", {}, "/activity", this);
 });
+document.getElementById("clear").addEventListener("click", function() {
+  if (!confirm("Delete the guides and saved settings for this repository?")) return;
+  var includeCache = document.getElementById("clear-cache").checked;
+  var btn = this;
+  run(btn, btn.closest("[data-async]"), async function() {
+    var done = await clearKnowledge(${JSON.stringify(`/api/repos/${name}/knowledge`)}, includeCache);
+    if (done !== false) location.reload();
+  });
+});
 </script>`,
     }));
 }

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

@@ -239,6 +239,15 @@ Leave blank to keep the current key"></textarea></div>
       </div>
       <div class="ft"><button class="primary" id="save-password">Change password</button></div>
     </div>
+    <div class="card" id="danger" data-async>
+      ${skSlot()}
+      <div class="hd"><h2>Clear all knowledge</h2></div>
+      <div class="bd">
+        <p class="muted" style="margin:0 0 16px">Delete every repository's guides and saved settings on this server. Repository records, reviews and tokens stay, so this is not an uninstall.</p>
+        <div class="field wide"><label><input type="checkbox" id="clear-all-cache"> Also delete the cached evidence: pull request listings, costs, clones and worktrees</label></div>
+      </div>
+      <div class="ft"><button id="clear-all" style="color:var(--red)">Clear all knowledge</button></div>
+    </div>
     <div class="card" id="about">
       <div class="hd"><h2>About</h2></div>
       <div class="bd">
@@ -501,6 +510,15 @@ document.getElementById("save-def").addEventListener("click", function() {
   if (policy !== "__custom") body.reviewPolicy = policy === "" ? null : policy;
   save(this, body);
 });
+document.getElementById("clear-all").addEventListener("click", function() {
+  if (!confirm("Delete the guides and saved settings for every repository on this server?")) return;
+  var includeCache = document.getElementById("clear-all-cache").checked;
+  var btn = this;
+  run(btn, btn.closest("[data-async]"), async function() {
+    var done = await clearKnowledge("/api/knowledge", includeCache);
+    if (done !== false) location.reload();
+  });
+});
 </script>`,
     }));
 }

package/dist/src/services/clear.d.ts

@@ -0,0 +1,70 @@
+import type { JobRow } from "../store/rows.ts";
+/** Job cancel reasons, so the Activity page can say who asked. */
+export declare const CLEARED_REASON = "knowledge_cleared";
+export type ClearOptions = {
+    /** Also drop the fetched evidence (pull request listings, AI job cache,
+     * costs, local review carry-over, clones, worktrees). Without it the next
+     * init still finds what it paid for and only the knowledge is gone. */
+    includeCache?: boolean;
+};
+export type ClearRepoResult = {
+    repo: string;
+    guides: number;
+    cacheRows: number;
+    settings: boolean;
+    clones: boolean;
+    worktrees: boolean;
+};
+export type ClearAllResult = {
+    repos: ClearRepoResult[];
+    settings: boolean;
+    cacheFile: boolean;
+    clones: boolean;
+    worktrees: boolean;
+};
+export declare function isSafeRepoName(repo: string): boolean;
+/** Opens app.db for the work when it already exists, and never creates one:
+ * a repository that was never inited has nothing to clear there. Reuses an
+ * open connection (the dashboard) and closes one it opened itself. */
+export declare function withAppDbIfPresent<T>(fn: () => T | Promise<T>): Promise<T | undefined>;
+/** The repositories `clear all` should visit: the guide directories under
+ * `reposDir()` plus everything `config.json` still remembers. Names that
+ * cannot be joined onto a path are dropped: `config.json` is editable by
+ * hand, and a key like `acme/..` would otherwise resolve to the repos root
+ * and take every repository with it. */
+export declare function listStoredRepos(): Promise<string[]>;
+/** What queued and running jobs exist for these repositories. Empty when
+ * app.db is not open, which is the same as "no jobs to worry about". */
+export declare function repoJobs(repos: string[]): {
+    queued: JobRow[];
+    running: JobRow[];
+};
+/** Cancels queued jobs so a cleared repository does not rebuild itself from
+ * the queue. Running jobs are the caller's problem: reviews can be aborted,
+ * a running setup cannot (its fetch loops ignore the signal). */
+export declare function cancelQueuedJobs(repos: string[], reason?: string): number;
+/** Aborts running reviews. They never write guides, so clearing while one
+ * runs is safe either way; aborting stops the AI spend too. */
+export declare function abortRunningReviews(repos: string[], reason?: string): number;
+/** Running rows left behind by a crashed `serve`. Only safe when the caller
+ * holds the app.db lock, which the CLI guard guarantees. */
+export declare function cancelOrphanedJobs(repos: string[], reason?: string): number;
+/** Forgets one repository: knowledge, guides, cache (when asked) and the
+ * settings `init` remembered. */
+export declare function clearRepo(repo: string, options?: ClearOptions): Promise<ClearRepoResult>;
+/** Forgets exactly the repositories it is given. The dashboard route and the
+ * CLI pass the same snapshot they negotiated jobs against, so the list cannot
+ * move between the check and the delete. The app.db file and its review
+ * history stay: only the knowledge is gone. `--include-cache` takes the whole
+ * cache database plus every clone and worktree, the same as deleting
+ * `cache.db` by hand. */
+export declare function clearRepos(repos: string[], options?: ClearOptions): Promise<ClearAllResult>;
+/** Forgets every repository on this machine, from a fresh snapshot. */
+export declare function clearAllKnowledge(options?: ClearOptions): Promise<ClearAllResult>;
+export type UninstallResult = {
+    paths: string[];
+};
+/** Removes every co-maintainer data file. The npm package itself cannot be
+ * removed from inside the running CLI, so the command prints how to do that
+ * instead. Refuses nothing here; the caller checks for a running `serve`. */
+export declare function uninstallData(): Promise<UninstallResult>;

package/dist/src/services/clear.js

@@ -0,0 +1,310 @@
+/** Deleting what `init` produced, for the CLI's `clear`/`uninstall` and the
+ * dashboard's clear actions.
+ *
+ * The dashboard and the CLI share this module on purpose: the same data has to
+ * disappear whether a command or a button asked for it. The callers keep what
+ * differs instead: the CLI owns the `serve` lock guard, its prompts and its
+ * output, the dashboard route owns job negotiation before calling in.
+ *
+ * Deleting is ordered so an interruption never leaves the friendlier state:
+ * the app.db knowledge stamp goes first, then the guide files, then the
+ * rebuildable cache. An error partway leaves a repository that reads as "not
+ * built", which the next `init` fixes. */
+import { cacheDbPath, cloneDir, clonesDir, configPath, getCacheDir, getConfigDir, locksDir, readConfig, removeAllRepoConfig, removeRepoConfig, repoWorktreesDir, reposDir, toolsDir, worktreesDir, } from "../config.js";
+import { withKnowledgeLock } from "../review/guides.js";
+import { appDbLockPath, appDbPath, backupPaths, closeAppDb, isAppDbOpen, openAppDb, } from "../store/app_db.js";
+import { cacheDbExists, cacheDeleteRepoEvidence, cacheDeleteRepoKnowledge, } from "../store/cache_db.js";
+import { clearRepoKnowledge } from "../store/repos.js";
+import { listJobs, setJobStatus } from "../store/jobs.js";
+import { cancel } from "./jobs.js";
+import { isNotFound, readDir, remove, rmdir, stat } from "../util/runtime.js";
+/** Job cancel reasons, so the Activity page can say who asked. */
+export const CLEARED_REASON = "knowledge_cleared";
+/** A repository name that is safe to join onto a directory. Rejects the `..`
+ * segment the API's route pattern would otherwise accept. */
+const REPO_NAME = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+export function isSafeRepoName(repo) {
+    if (!REPO_NAME.test(repo))
+        return false;
+    return repo.split("/").every((part) => part !== "." && part !== "..");
+}
+function assertSafeRepoName(repo) {
+    if (!isSafeRepoName(repo)) {
+        throw new Error(`Not a repository name: ${repo}`);
+    }
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return false;
+        throw error;
+    }
+}
+async function removeIfExists(path, options) {
+    if (!(await pathExists(path)))
+        return false;
+    await remove(path, options);
+    return true;
+}
+async function countEntries(dir) {
+    let count = 0;
+    try {
+        for await (const _entry of readDir(dir))
+            count++;
+    }
+    catch (error) {
+        if (!isNotFound(error))
+            throw error;
+    }
+    return count;
+}
+/** Opens app.db for the work when it already exists, and never creates one:
+ * a repository that was never inited has nothing to clear there. Reuses an
+ * open connection (the dashboard) and closes one it opened itself. */
+export async function withAppDbIfPresent(fn) {
+    if (isAppDbOpen())
+        return await fn();
+    if (!(await pathExists(appDbPath())))
+        return undefined;
+    await openAppDb();
+    try {
+        return await fn();
+    }
+    finally {
+        await closeAppDb();
+    }
+}
+/** The repositories `clear all` should visit: the guide directories under
+ * `reposDir()` plus everything `config.json` still remembers. Names that
+ * cannot be joined onto a path are dropped: `config.json` is editable by
+ * hand, and a key like `acme/..` would otherwise resolve to the repos root
+ * and take every repository with it. */
+export async function listStoredRepos() {
+    const repos = new Set();
+    try {
+        for await (const owner of readDir(reposDir())) {
+            if (!owner.isDirectory || owner.isSymlink)
+                continue;
+            try {
+                for await (const child of readDir(`${reposDir()}/${owner.name}`)) {
+                    if (child.isDirectory && !child.isSymlink) {
+                        repos.add(`${owner.name}/${child.name}`);
+                    }
+                }
+            }
+            catch (error) {
+                if (!isNotFound(error))
+                    throw error;
+            }
+        }
+    }
+    catch (error) {
+        if (!isNotFound(error))
+            throw error;
+    }
+    for (const repo of Object.keys(readConfig().repos ?? {}))
+        repos.add(repo);
+    return [...repos].filter(isSafeRepoName).sort();
+}
+/** Guide files live in one directory per repository. The count is taken
+ * before the removal so the caller can report what went. An owner directory
+ * left empty by its last repository is pruned: it is a leftover, not data. */
+async function removeRepoGuides(repo) {
+    let removed = 0;
+    await withKnowledgeLock(repo, async () => {
+        const dir = `${reposDir()}/${repo}`;
+        removed = await countEntries(dir);
+        if (removed > 0)
+            await remove(dir, { recursive: true });
+        else
+            await removeIfExists(dir, { recursive: true });
+        await rmdir(dir.slice(0, dir.lastIndexOf("/"))).catch(() => { });
+    });
+    return removed;
+}
+/** `sync` used to keep its state as `.cache/<repo>/state.json` beside the
+ * working directory, and `readState` still falls back to it. Leaving it
+ * behind would let a `sync` run after a clear, which clear promises cannot
+ * happen. Best effort: it only exists on machines that ran the old layout. */
+async function removeLegacyState(repo) {
+    await removeIfExists(`${process.cwd()}/.cache/${repo}`, { recursive: true });
+}
+async function clearRepoCache(repo, includeCache) {
+    if (!(await cacheDbExists()))
+        return 0;
+    let removed = await cacheDeleteRepoKnowledge(repo);
+    if (includeCache)
+        removed += await cacheDeleteRepoEvidence(repo);
+    return removed;
+}
+/** What queued and running jobs exist for these repositories. Empty when
+ * app.db is not open, which is the same as "no jobs to worry about". */
+export function repoJobs(repos) {
+    if (!isAppDbOpen())
+        return { queued: [], running: [] };
+    const wanted = new Set(repos);
+    const queued = [];
+    const running = [];
+    for (const job of listJobs({})) {
+        if (!wanted.has(job.repo))
+            continue;
+        if (job.status === "queued")
+            queued.push(job);
+        else if (job.status === "running")
+            running.push(job);
+    }
+    return { queued, running };
+}
+/** Cancels queued jobs so a cleared repository does not rebuild itself from
+ * the queue. Running jobs are the caller's problem: reviews can be aborted,
+ * a running setup cannot (its fetch loops ignore the signal). */
+export function cancelQueuedJobs(repos, reason = CLEARED_REASON) {
+    if (!isAppDbOpen())
+        return 0;
+    let canceled = 0;
+    for (const job of repoJobs(repos).queued) {
+        if (cancel(job.id, reason))
+            canceled++;
+    }
+    return canceled;
+}
+/** Aborts running reviews. They never write guides, so clearing while one
+ * runs is safe either way; aborting stops the AI spend too. */
+export function abortRunningReviews(repos, reason = CLEARED_REASON) {
+    if (!isAppDbOpen())
+        return 0;
+    let aborted = 0;
+    for (const job of repoJobs(repos).running) {
+        if (job.type !== "review" && job.type !== "remote_review")
+            continue;
+        if (cancel(job.id, reason))
+            aborted++;
+    }
+    return aborted;
+}
+/** Running rows left behind by a crashed `serve`. Only safe when the caller
+ * holds the app.db lock, which the CLI guard guarantees. */
+export function cancelOrphanedJobs(repos, reason = CLEARED_REASON) {
+    if (!isAppDbOpen())
+        return 0;
+    let canceled = 0;
+    for (const job of repoJobs(repos).running) {
+        setJobStatus(job.id, "canceled", { cancel_reason: reason });
+        canceled++;
+    }
+    return canceled;
+}
+/** Forgets one repository: knowledge, guides, cache (when asked) and the
+ * settings `init` remembered. */
+export async function clearRepo(repo, options = {}) {
+    assertSafeRepoName(repo);
+    await withAppDbIfPresent(() => clearRepoKnowledge(repo));
+    const guides = await removeRepoGuides(repo);
+    const cacheRows = await clearRepoCache(repo, Boolean(options.includeCache));
+    await removeLegacyState(repo);
+    const settings = await removeRepoConfig(repo);
+    const clones = options.includeCache
+        ? await removeIfExists(cloneDir(repo), { recursive: true })
+        : false;
+    const worktrees = options.includeCache
+        ? await removeIfExists(repoWorktreesDir(repo), { recursive: true })
+        : false;
+    return { repo, guides, cacheRows, settings, clones, worktrees };
+}
+/** Forgets exactly the repositories it is given. The dashboard route and the
+ * CLI pass the same snapshot they negotiated jobs against, so the list cannot
+ * move between the check and the delete. The app.db file and its review
+ * history stay: only the knowledge is gone. `--include-cache` takes the whole
+ * cache database plus every clone and worktree, the same as deleting
+ * `cache.db` by hand. */
+export async function clearRepos(repos, options = {}) {
+    for (const repo of repos)
+        assertSafeRepoName(repo);
+    const results = [];
+    await withAppDbIfPresent(() => {
+        for (const repo of repos)
+            clearRepoKnowledge(repo);
+    });
+    for (const repo of repos) {
+        const guides = await removeRepoGuides(repo);
+        const cacheRows = options.includeCache
+            ? 0
+            : await clearRepoCache(repo, false);
+        await removeLegacyState(repo);
+        results.push({
+            repo,
+            guides,
+            cacheRows,
+            settings: false,
+            clones: false,
+            worktrees: false,
+        });
+    }
+    const cacheFile = options.includeCache
+        ? await removeIfExists(cacheDbPath())
+        : false;
+    const clones = options.includeCache
+        ? await removeIfExists(clonesDir(), { recursive: true })
+        : false;
+    const worktrees = options.includeCache
+        ? await removeIfExists(worktreesDir(), { recursive: true })
+        : false;
+    const settings = await removeAllRepoConfig();
+    return { repos: results, settings, cacheFile, clones, worktrees };
+}
+/** Forgets every repository on this machine, from a fresh snapshot. */
+export async function clearAllKnowledge(options = {}) {
+    return await clearRepos(await listStoredRepos(), options);
+}
+/** Every file and directory co-maintainer keeps on this machine. The `tools`
+ * directory (the codegraph install) goes too: uninstall means the disk is
+ * back to what it was before the first `init`. */
+function uninstallTargets() {
+    const appDb = appDbPath();
+    const cacheDb = cacheDbPath();
+    return [
+        configPath(),
+        cacheDb,
+        `${cacheDb}-journal`,
+        appDb,
+        `${appDb}-wal`,
+        `${appDb}-shm`,
+        appDbLockPath(),
+        backupPaths().version,
+        reposDir(),
+        clonesDir(),
+        worktreesDir(),
+        locksDir(),
+        toolsDir(),
+        backupPaths().root,
+    ];
+}
+/** Removes every co-maintainer data file. The npm package itself cannot be
+ * removed from inside the running CLI, so the command prints how to do that
+ * instead. Refuses nothing here; the caller checks for a running `serve`. */
+export async function uninstallData() {
+    // On Windows an open handle blocks the delete, and leaving wal/shm behind
+    // would be worse than the file itself.
+    if (isAppDbOpen())
+        await closeAppDb();
+    const removed = [];
+    for (const target of uninstallTargets()) {
+        if (await removeIfExists(target, { recursive: true })) {
+            removed.push(target);
+        }
+    }
+    // The containing `co-maintainer` directories only survive if something
+    // else put files there. `rmdir` refuses a non-empty directory, which is
+    // what we want.
+    for (const dir of [
+        `${getConfigDir()}/co-maintainer`,
+        `${getCacheDir()}/co-maintainer`,
+    ]) {
+        await rmdir(dir).catch(() => { });
+    }
+    return { paths: removed };
+}

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

@@ -3,6 +3,9 @@ import { type BackupPaths } from "./backup.ts";
 export declare function appDbDir(): string;
 /** `CM_APP_DB` overrides the path — tests point it at a temp file. */
 export declare function appDbPath(): string;
+/** The lock file on its own, so `uninstall` deletes it with the database
+ * instead of leaving a pid file that names a process that no longer exists. */
+export declare function appDbLockPath(): string;
 /** Where the backup taken before a migration lives, and what it covers. */
 export declare function backupPaths(): BackupPaths;
 /** The pid holding the database lock, or `undefined` when nothing live does. */

package/dist/src/store/app_db.js

@@ -17,6 +17,11 @@ export function appDbPath() {
 function lockPath() {
     return `${appDbPath()}.lock`;
 }
+/** The lock file on its own, so `uninstall` deletes it with the database
+ * instead of leaving a pid file that names a process that no longer exists. */
+export function appDbLockPath() {
+    return lockPath();
+}
 /** Where the backup taken before a migration lives, and what it covers. */
 export function backupPaths() {
     return {

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

@@ -2,6 +2,17 @@ export declare function cacheGet(namespace: string, key: string): Promise<string
 export declare function cacheSet(namespace: string, key: string, value: string): Promise<void>;
 export declare function cacheDelete(namespace: string, key: string): Promise<void>;
 export declare function cacheDeletePrefix(namespace: string, prefix: string): Promise<void>;
+/** Whether cache.db exists, so a `clear` that has nothing to delete does not
+ * create one just to close it again. */
+export declare function cacheDbExists(): Promise<boolean>;
+/** The skill state is the repository's own knowledge, so `clear` always drops
+ * it: without it the next build starts from `init` rather than `sync`. */
+export declare function cacheDeleteRepoKnowledge(repo: string): Promise<number>;
+/** Everything `init` fetched or paid for, kept unless the caller asked for a
+ * cold next build. The global `pricing` cache stays either way. Keys live in
+ * three shapes: an exact repository key, `${repo}:...`, and the local review
+ * carry-over's NUL separated `${repo}\0...`. */
+export declare function cacheDeleteRepoEvidence(repo: string): Promise<number>;
 /** Every value under `namespace` whose key starts with `prefix`, newest first.
  * `recordAiCost` keys each job `${repo}:${uuid}`, so the probe estimate reads
  * a repository's own job history without a second index to keep in sync. */

package/dist/src/store/cache_db.js

@@ -1,6 +1,6 @@
 import { Database } from "./sqlite.js";
 import { cacheDbPath, getCacheDir } from "../config.js";
-import { mkdirSync } from "../util/runtime.js";
+import { isNotFound, mkdirSync, stat } from "../util/runtime.js";
 /** Paths whose schema this process has already created. Keyed by path rather
  * than a single boolean: `cacheDbPath()` reads the environment at call time
  * and tests point it at a temp directory, so a process-level flag would skip
@@ -67,6 +67,65 @@ export async function cacheDeletePrefix(namespace, prefix) {
         db.close();
     }
 }
+/** Whether cache.db exists, so a `clear` that has nothing to delete does not
+ * create one just to close it again. */
+export async function cacheDbExists() {
+    try {
+        await stat(cacheDbPath());
+        return true;
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return false;
+        throw error;
+    }
+}
+/** Escapes LIKE's own wildcards and the escape character. A repository name
+ * may contain `_`, which LIKE would otherwise read as "any character". */
+function likePrefix(prefix) {
+    return `${prefix.replace(/[\\%_]/g, "\\$&")}%`;
+}
+function deleteRows(db, namespace, pattern) {
+    if ("exact" in pattern) {
+        db.prepare("DELETE FROM cache WHERE namespace = ? AND cache_key = ?").run(namespace, pattern.exact);
+    }
+    else {
+        db.prepare("DELETE FROM cache WHERE namespace = ? AND cache_key LIKE ? ESCAPE '\\'").run(namespace, likePrefix(pattern.prefix));
+    }
+    return db.changes;
+}
+/** The skill state is the repository's own knowledge, so `clear` always drops
+ * it: without it the next build starts from `init` rather than `sync`. */
+export async function cacheDeleteRepoKnowledge(repo) {
+    const db = openDatabase();
+    try {
+        return deleteRows(db, "state", { exact: repo });
+    }
+    finally {
+        db.close();
+    }
+}
+/** Everything `init` fetched or paid for, kept unless the caller asked for a
+ * cold next build. The global `pricing` cache stays either way. Keys live in
+ * three shapes: an exact repository key, `${repo}:...`, and the local review
+ * carry-over's NUL separated `${repo}\0...`. */
+export async function cacheDeleteRepoEvidence(repo) {
+    const db = openDatabase();
+    try {
+        let removed = 0;
+        for (const namespace of ["pr-listing", "probe"]) {
+            removed += deleteRows(db, namespace, { exact: repo });
+        }
+        for (const namespace of ["ai-jobs", "cost"]) {
+            removed += deleteRows(db, namespace, { prefix: `${repo}:` });
+        }
+        removed += deleteRows(db, "local-review", { prefix: `${repo}\0` });
+        return removed;
+    }
+    finally {
+        db.close();
+    }
+}
 /** Every value under `namespace` whose key starts with `prefix`, newest first.
  * `recordAiCost` keys each job `${repo}:${uuid}`, so the probe estimate reads
  * a repository's own job history without a second index to keep in sync. */

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

@@ -4,6 +4,9 @@ export declare function deactivateRepo(fullName: string): void;
 export declare function deactivateReposForInstallation(installationId: number): void;
 export declare function updateRepoSettings(fullName: string, patch: Partial<Pick<RepoRow, "auto_review" | "review_scope" | "skip_drafts" | "skip_bots" | "use_codegraph" | "review_policy_json">>): void;
 export declare function markKnowledgeBuilt(fullName: string, baseSha: string): void;
+/** Forgets the built knowledge: the stamp every review and the dashboard read
+ * as "built", and the drift baseline that only meant anything against it. */
+export declare function clearRepoKnowledge(fullName: string): void;
 export declare function setInstallationId(fullName: string, installationId: number): void;
 export declare function getRepo(fullName: string): RepoRow | undefined;
 /** Case-insensitive match on `repos.full_name`. */

package/dist/src/store/repos.js

@@ -36,6 +36,14 @@ export function markKnowledgeBuilt(fullName, baseSha) {
     // baseline, so a rebuild makes them meaningless rather than merely stale.
     deleteDrift(fullName);
 }
+/** Forgets the built knowledge: the stamp every review and the dashboard read
+ * as "built", and the drift baseline that only meant anything against it. */
+export function clearRepoKnowledge(fullName) {
+    getAppDb()
+        .prepare(`UPDATE repos SET knowledge_built_at = NULL, knowledge_base_sha = NULL WHERE full_name = ?`)
+        .run(fullName);
+    deleteDrift(fullName);
+}
 export function setInstallationId(fullName, installationId) {
     getAppDb()
         .prepare(`UPDATE repos SET installation_id = ? WHERE full_name = ?`)

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

@@ -29,6 +29,9 @@ export declare function mkdir(path: string | URL, options?: {
 export declare function remove(path: string | URL, options?: {
     recursive?: boolean;
 }): Promise<void>;
+/** Removes an empty directory only. Unlike `remove`, a non-empty directory
+ * fails, which is what callers that prune parents after deleting files want. */
+export declare function rmdir(path: string | URL): Promise<void>;
 export declare function stat(path: string | URL): Promise<Stats>;
 export declare function lstat(path: string | URL): Promise<Stats>;
 export declare function readLink(path: string | URL): Promise<string>;

package/dist/src/util/runtime.js

@@ -6,7 +6,7 @@
  * two silent-break classes too: `"windows"` vs `"win32"`, and
  * `Deno.errors.NotFound` vs `ENOENT`.
  */
-import { chmod as fsChmod, lstat as fsLstat, mkdir as fsMkdir, mkdtemp as fsMkdtemp, readFile as fsReadFile, readdir, readlink as fsReadLink, rename as fsRename, rm as fsRm, stat as fsStat, writeFile as fsWriteFile, } from "node:fs/promises";
+import { chmod as fsChmod, lstat as fsLstat, mkdir as fsMkdir, mkdtemp as fsMkdtemp, readFile as fsReadFile, readdir, readlink as fsReadLink, rename as fsRename, rmdir as fsRmdir, rm as fsRm, stat as fsStat, writeFile as fsWriteFile, } from "node:fs/promises";
 import { mkdirSync as fsMkdirSync, mkdtempSync as fsMkdtempSync, readFileSync as fsReadFileSync, rmSync as fsRmSync, statSync as fsStatSync, writeFileSync as fsWriteFileSync, } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
@@ -81,6 +81,11 @@ export function mkdir(path, options) {
 export function remove(path, options) {
     return fsRm(path, { recursive: options?.recursive ?? false, force: false });
 }
+/** Removes an empty directory only. Unlike `remove`, a non-empty directory
+ * fails, which is what callers that prune parents after deleting files want. */
+export function rmdir(path) {
+    return fsRmdir(path);
+}
 export function stat(path) {
     return fsStat(path);
 }

package/package.json

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