co-maintainer 0.5.1 → 0.5.3

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

@@ -0,0 +1,68 @@
+/** The dashboard's clear routes.
+ *
+ * `DELETE /api/repos/:owner/:repo/knowledge` forgets one repository,
+ * `DELETE /api/knowledge` forgets every stored repository. Both share the job
+ * negotiation here: a queued job can be canceled and a running review can be
+ * aborted (`?onRunning=abort`), but a running `init`/`remake` cannot be
+ * stopped, so the route answers 409 and the page waits for it instead. */
+import { errorResponse } from "../errors.js";
+import { abortRunningReviews, cancelQueuedJobs, clearRepos, clearRepo, listStoredRepos, repoJobs, } from "../../services/clear.js";
+function readClearParams(url) {
+    return {
+        includeCache: url.searchParams.get("includeCache") === "1",
+        abort: url.searchParams.get("onRunning") === "abort",
+    };
+}
+/** A running setup job ignores the abort signal and would write the guides
+ * again after the clear, so it is the one thing the caller cannot skip. */
+function isSetupType(type) {
+    return type !== "review" && type !== "remote_review";
+}
+/** `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 function negotiateJobs(repos, abort) {
+    const jobs = repoJobs(repos);
+    if (jobs.queued.length === 0 && jobs.running.length === 0)
+        return undefined;
+    if (!abort) {
+        return errorResponse(409, "jobs_running", "Jobs are pending for this target.", {
+            queued: jobs.queued.length,
+            running: jobs.running.map((job) => ({
+                id: job.id,
+                type: job.type,
+                abortable: !isSetupType(job.type),
+            })),
+        });
+    }
+    const setup = jobs.running.find((job) => isSetupType(job.type));
+    if (setup) {
+        return errorResponse(409, "job_not_abortable", "A sync is running and cannot be stopped.", { id: setup.id, type: setup.type });
+    }
+    cancelQueuedJobs(repos);
+    abortRunningReviews(repos);
+    return undefined;
+}
+export async function handleKnowledgeRoute(request, url) {
+    if (url.pathname !== "/api/knowledge" || request.method !== "DELETE") {
+        return errorResponse(404, "not_found", `no route for ${url.pathname}`);
+    }
+    const { includeCache, abort } = readClearParams(url);
+    // The same snapshot is negotiated and cleared, so a repository added in
+    // between cannot slip past the job check.
+    const repos = await listStoredRepos();
+    const conflict = negotiateJobs(repos, abort);
+    if (conflict)
+        return conflict;
+    const result = await clearRepos(repos, { includeCache });
+    return Response.json({ ok: true, ...result });
+}
+/** Shared by the per-repo route, which knows exactly one repository. */
+export async function clearOneRepo(fullName, url) {
+    const { includeCache, abort } = readClearParams(url);
+    const conflict = negotiateJobs([fullName], abort);
+    if (conflict)
+        return conflict;
+    const result = await clearRepo(fullName, { includeCache });
+    return Response.json({ ok: true, ...result });
+}

package/dist/src/server/api/repos.js

@@ -10,6 +10,7 @@ import { probePlan, recommendationPatch } from "../../services/probe.js";
 import { estimateInit, readJobHistory } from "../../ai/estimate.js";
 import { loadPrices } from "../../ai/pricing.js";
 import { prDetail, repoKnowledge, RepoNotFound, repoOverview, repoPulls, requireActiveRepo, } from "../../services/dashboard.js";
+import { clearOneRepo } from "./knowledge.js";
 const REPO = /^\/api\/repos\/([^/]+)\/([^/]+)(?:\/(remake|knowledge|pulls)(?:\/(\d+)(?:\/(review))?)?)?$/;
 export async function handleReposRoute(request, url, githubApp) {
     if (url.pathname === "/api/repos" && request.method === "GET") {
@@ -264,6 +265,10 @@ export async function handleReposRoute(request, url, githubApp) {
         if (sub === "knowledge" && request.method === "GET") {
             return Response.json(await repoKnowledge(fullName));
         }
+        if (sub === "knowledge" && request.method === "DELETE") {
+            requireActiveRepo(fullName);
+            return await clearOneRepo(fullName, url);
+        }
         if (sub === "pulls" &&
             pr &&
             action === "review" &&

package/dist/src/server/app.js

@@ -9,6 +9,7 @@ import { aiConfigured, readConfig, resolveAppPrivateKey } from "../config.js";
 import { listJobs } from "../store/jobs.js";
 import { handleJobsRoute } from "./api/jobs.js";
 import { handleReposRoute } from "./api/repos.js";
+import { handleKnowledgeRoute } from "./api/knowledge.js";
 import { handleInstallationsRoute } from "./api/installations.js";
 import { handleSettingsRoute } from "./api/settings.js";
 import { handleActivityRoute } from "./api/activity.js";
@@ -154,6 +155,9 @@ export function createApp(deps) {
                 if (url.pathname.startsWith("/api/repos")) {
                     return await handleReposRoute(request, url, githubApp);
                 }
+                if (url.pathname === "/api/knowledge") {
+                    return await handleKnowledgeRoute(request, url);
+                }
                 if (url.pathname === "/api/installations") {
                     return await handleInstallationsRoute(request, githubApp);
                 }

package/dist/src/server/pages/client.d.ts

@@ -1,2 +1,2 @@
 /** Generated from src/server/pages/client.js by scripts/embed_assets.mjs — do not edit. */
-export declare const client = "function toast(message) {\n  const host = document.getElementById(\"toasts\");\n  if (!host) return;\n  const el = document.createElement(\"div\");\n  el.className = \"toast\";\n  el.setAttribute(\"role\", \"status\");\n  el.textContent = message;\n  host.appendChild(el);\n  setTimeout(function () {\n    el.remove();\n  }, 5000);\n}\n\nfunction fail(card, message, retry) {\n  toast(message);\n  if (!card) return;\n  let box = card.querySelector(\"[data-fail]\");\n  if (!box) {\n    box = document.createElement(\"div\");\n    box.setAttribute(\"data-fail\", \"1\");\n    box.className = \"fail\";\n    card.appendChild(box);\n  }\n  box.replaceChildren();\n  const p = document.createElement(\"p\");\n  p.textContent = message;\n  const btn = document.createElement(\"button\");\n  btn.className = \"btn sm\";\n  btn.type = \"button\";\n  btn.textContent = \"Retry\";\n  btn.addEventListener(\"click\", retry);\n  box.appendChild(p);\n  box.appendChild(btn);\n}\n\nfunction clearFail(card) {\n  const box = card && card.querySelector(\"[data-fail]\");\n  if (box) box.remove();\n}\n\nfunction skeleton(card, on) {\n  if (!card) return;\n  card.classList.toggle(\"busy\", on);\n}\n\nasync function api(method, url, body) {\n  const res = await fetch(url, {\n    method: method,\n    headers: {\n      \"content-type\": \"application/json\",\n      \"x-requested-with\": \"co-maintainer\",\n    },\n    body: body === undefined ? undefined : JSON.stringify(body),\n  });\n  if (!res.ok) {\n    let message = \"Request failed\";\n    try {\n      const data = await res.json();\n      if (data.error && data.error.message) message = data.error.message;\n    } catch {\n      // body was not JSON; keep the generic message\n    }\n    throw new Error(message);\n  }\n  if (res.status === 204) return null;\n  return await res.json();\n}\n\nasync function run(btn, card, fn) {\n  if (btn) btn.disabled = true;\n  skeleton(card, true);\n  clearFail(card);\n  try {\n    await fn();\n  } catch (err) {\n    fail(card, err.message, function () {\n      run(btn, card, fn);\n    });\n  } finally {\n    if (btn) btn.disabled = false;\n    skeleton(card, false);\n  }\n}\n\nasync function postAndGo(url, body, next, btn) {\n  const card = btn && btn.closest(\"[data-async]\");\n  await run(btn, card, async function () {\n    await api(\"POST\", url, body);\n    location.href = next;\n  });\n}\n\n// Called from the inline scripts on the repo list and repo pages, which deno lint\n// cannot see, so it looks unused from inside this file.\n// deno-lint-ignore no-unused-vars\nfunction bindToggle(btn, url, field) {\n  btn.addEventListener(\"click\", async function () {\n    if (btn.disabled) return;\n    const on = !btn.classList.contains(\"on\");\n    btn.classList.toggle(\"on\", on);\n    btn.setAttribute(\"data-on\", on ? \"1\" : \"0\");\n    btn.disabled = true;\n    const card = btn.closest(\"[data-async]\");\n    try {\n      const payload = {};\n      payload[field] = on;\n      await api(\"PATCH\", url, payload);\n    } catch (err) {\n      btn.classList.toggle(\"on\", !on);\n      btn.setAttribute(\"data-on\", on ? \"0\" : \"1\");\n      fail(card, err.message, function () {\n        btn.click();\n      });\n    } finally {\n      btn.disabled = false;\n    }\n  });\n}\n\n// The helper is inlined into `<head>` by `layout.ts`, before any page script\n// runs, so this is the one place that can close over both `toast()` and\n// `bindToggle` without depending on point-in-time globals.\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  // Client errors bubble to `window` from `document`.\n  addEventListener(\"error\", function (ev) {\n    toast((ev.error && ev.error.message) || \"Something broke\");\n  });\n  addEventListener(\"unhandledrejection\", function (ev) {\n    toast((ev.reason && ev.reason.message) || \"Something broke\");\n  });\n\n  document.addEventListener(\"click\", function (ev) {\n    const btn =\n      ev.target && ev.target.closest\n        ? ev.target.closest(\"[data-cancel], [data-post]\")\n        : null;\n    if (!btn) return;\n    ev.preventDefault();\n    if (btn.hasAttribute(\"data-cancel\")) {\n      postAndGo(\n        \"/api/jobs/\" + btn.getAttribute(\"data-cancel\") + \"/cancel\",\n        {},\n        \"/activity\",\n        btn,\n      );\n      return;\n    }\n    const body = btn.getAttribute(\"data-body\");\n    postAndGo(\n      btn.getAttribute(\"data-post\"),\n      body ? JSON.parse(body) : {},\n      \"/activity\",\n      btn,\n    );\n  });\n\n  // Reads `activity-root` at call time, so it has to wait for the body even\n  // though this file itself is already parsed.\n  if (!document.getElementById(\"activity-root\")) return;\n  setInterval(async function () {\n    if (document.hidden) return;\n    if (document.querySelector(\"[data-async].busy\")) return;\n    const root = document.getElementById(\"activity-root\");\n    if (!root) return;\n    try {\n      const res = await fetch(location.pathname + location.search, {\n        headers: { accept: \"text/html\" },\n      });\n      if (!res.ok) return;\n      const doc = new DOMParser().parseFromString(\n        await res.text(),\n        \"text/html\",\n      );\n      const next = doc.getElementById(\"activity-root\");\n      if (!next || next.innerHTML === root.innerHTML) return;\n      root.replaceWith(next);\n    } catch {\n      // a failed poll just waits for the next tick\n    }\n  }, 5000);\n});\n";
+export declare const client = "function toast(message) {\n  const host = document.getElementById(\"toasts\");\n  if (!host) return;\n  const el = document.createElement(\"div\");\n  el.className = \"toast\";\n  el.setAttribute(\"role\", \"status\");\n  el.textContent = message;\n  host.appendChild(el);\n  setTimeout(function () {\n    el.remove();\n  }, 5000);\n}\n\nfunction fail(card, message, retry) {\n  toast(message);\n  if (!card) return;\n  let box = card.querySelector(\"[data-fail]\");\n  if (!box) {\n    box = document.createElement(\"div\");\n    box.setAttribute(\"data-fail\", \"1\");\n    box.className = \"fail\";\n    card.appendChild(box);\n  }\n  box.replaceChildren();\n  const p = document.createElement(\"p\");\n  p.textContent = message;\n  const btn = document.createElement(\"button\");\n  btn.className = \"btn sm\";\n  btn.type = \"button\";\n  btn.textContent = \"Retry\";\n  btn.addEventListener(\"click\", retry);\n  box.appendChild(p);\n  box.appendChild(btn);\n}\n\nfunction clearFail(card) {\n  const box = card && card.querySelector(\"[data-fail]\");\n  if (box) box.remove();\n}\n\nfunction skeleton(card, on) {\n  if (!card) return;\n  card.classList.toggle(\"busy\", on);\n}\n\nasync function api(method, url, body) {\n  const res = await fetch(url, {\n    method: method,\n    headers: {\n      \"content-type\": \"application/json\",\n      \"x-requested-with\": \"co-maintainer\",\n    },\n    body: body === undefined ? undefined : JSON.stringify(body),\n  });\n  if (!res.ok) {\n    let message = \"Request failed\";\n    let code = \"\";\n    let detail;\n    try {\n      const data = await res.json();\n      if (data.error && data.error.message) message = data.error.message;\n      if (data.error && data.error.code) code = data.error.code;\n      if (data.error) detail = data.error.detail;\n    } catch {\n      // body was not JSON; keep the generic message\n    }\n    const error = new Error(message);\n    if (code) error.code = code;\n    error.detail = detail;\n    throw error;\n  }\n  if (res.status === 204) return null;\n  return await res.json();\n}\n\nasync function run(btn, card, fn) {\n  if (btn) btn.disabled = true;\n  skeleton(card, true);\n  clearFail(card);\n  try {\n    await fn();\n  } catch (err) {\n    fail(card, err.message, function () {\n      run(btn, card, fn);\n    });\n  } finally {\n    if (btn) btn.disabled = false;\n    skeleton(card, false);\n  }\n}\n\n/** Polls one job until it reaches a terminal status. A running `init`/`remake`\n * ignores the abort signal, so \"wait for the sync\" is the only honest option\n * the clear pages can offer for it. */\nfunction waitForJob(id) {\n  return new Promise(function (resolve, reject) {\n    let attempts = 0;\n    async function tick() {\n      attempts++;\n      try {\n        const res = await fetch(\"/api/jobs/\" + encodeURIComponent(id), {\n          headers: { \"x-requested-with\": \"co-maintainer\" },\n        });\n        if (!res.ok) throw new Error(\"Could not check the running job.\");\n        const job = await res.json();\n        if (job.status !== \"running\" && job.status !== \"queued\") {\n          resolve();\n          return;\n        }\n        if (attempts > 1200) {\n          reject(new Error(\"The sync did not finish.\"));\n          return;\n        }\n        setTimeout(tick, 3000);\n      } catch (err) {\n        reject(err);\n      }\n    }\n    tick();\n  });\n}\n\n/** Clears knowledge, asking about pending jobs when the server refuses.\n * Returns false when the user backed out, so the caller does not reload.\n * A running review is abortable and a running setup is not, which is the\n * difference between the two questions. */\nasync function clearKnowledge(url, includeCache) {\n  const target = includeCache ? url + \"?includeCache=1\" : url;\n  const retry = target.indexOf(\"?\") >= 0 ? \"&\" : \"?\";\n  try {\n    await api(\"DELETE\", target);\n  } catch (err) {\n    if (err.code !== \"jobs_running\") throw err;\n    const detail = err.detail || { queued: 0, running: [] };\n    const running = detail.running || [];\n    const setup = running.find(function (job) {\n      return job.abortable === false;\n    });\n    if (setup) {\n      if (\n        !confirm(\n          \"A sync is running and cannot be stopped. Wait for it to finish and then clear?\",\n        )\n      ) {\n        return false;\n      }\n      await waitForJob(setup.id);\n      await api(\"DELETE\", target);\n      return;\n    }\n    const parts = [];\n    if (running.length) parts.push(running.length + \" running review(s)\");\n    if (detail.queued) parts.push(detail.queued + \" queued job(s)\");\n    if (!confirm(\"Stop \" + parts.join(\" and \") + \" and clear?\")) return false;\n    try {\n      await api(\"DELETE\", target + retry + \"onRunning=abort\");\n    } catch (retryError) {\n      // A setup job was claimed between the first 409 and this retry. It\n      // cannot be aborted, so wait it out like the branch above.\n      if (retryError.code !== \"job_not_abortable\") throw retryError;\n      const jobId = retryError.detail && retryError.detail.id;\n      if (jobId) await waitForJob(jobId);\n      await api(\"DELETE\", target);\n    }\n  }\n}\n\nasync function postAndGo(url, body, next, btn) {\n  const card = btn && btn.closest(\"[data-async]\");\n  await run(btn, card, async function () {\n    await api(\"POST\", url, body);\n    location.href = next;\n  });\n}\n\n// Called from the inline scripts on the repo list and repo pages, which deno lint\n// cannot see, so it looks unused from inside this file.\n// deno-lint-ignore no-unused-vars\nfunction bindToggle(btn, url, field) {\n  btn.addEventListener(\"click\", async function () {\n    if (btn.disabled) return;\n    const on = !btn.classList.contains(\"on\");\n    btn.classList.toggle(\"on\", on);\n    btn.setAttribute(\"data-on\", on ? \"1\" : \"0\");\n    btn.disabled = true;\n    const card = btn.closest(\"[data-async]\");\n    try {\n      const payload = {};\n      payload[field] = on;\n      await api(\"PATCH\", url, payload);\n    } catch (err) {\n      btn.classList.toggle(\"on\", !on);\n      btn.setAttribute(\"data-on\", on ? \"0\" : \"1\");\n      fail(card, err.message, function () {\n        btn.click();\n      });\n    } finally {\n      btn.disabled = false;\n    }\n  });\n}\n\n// The helper is inlined into `<head>` by `layout.ts`, before any page script\n// runs, so this is the one place that can close over both `toast()` and\n// `bindToggle` without depending on point-in-time globals.\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  // Client errors bubble to `window` from `document`.\n  addEventListener(\"error\", function (ev) {\n    toast((ev.error && ev.error.message) || \"Something broke\");\n  });\n  addEventListener(\"unhandledrejection\", function (ev) {\n    toast((ev.reason && ev.reason.message) || \"Something broke\");\n  });\n\n  document.addEventListener(\"click\", function (ev) {\n    const btn =\n      ev.target && ev.target.closest\n        ? ev.target.closest(\"[data-cancel], [data-post]\")\n        : null;\n    if (!btn) return;\n    ev.preventDefault();\n    if (btn.hasAttribute(\"data-cancel\")) {\n      postAndGo(\n        \"/api/jobs/\" + btn.getAttribute(\"data-cancel\") + \"/cancel\",\n        {},\n        \"/activity\",\n        btn,\n      );\n      return;\n    }\n    const body = btn.getAttribute(\"data-body\");\n    postAndGo(\n      btn.getAttribute(\"data-post\"),\n      body ? JSON.parse(body) : {},\n      \"/activity\",\n      btn,\n    );\n  });\n\n  // Reads `activity-root` at call time, so it has to wait for the body even\n  // though this file itself is already parsed.\n  if (!document.getElementById(\"activity-root\")) return;\n  setInterval(async function () {\n    if (document.hidden) return;\n    if (document.querySelector(\"[data-async].busy\")) return;\n    const root = document.getElementById(\"activity-root\");\n    if (!root) return;\n    try {\n      const res = await fetch(location.pathname + location.search, {\n        headers: { accept: \"text/html\" },\n      });\n      if (!res.ok) return;\n      const doc = new DOMParser().parseFromString(\n        await res.text(),\n        \"text/html\",\n      );\n      const next = doc.getElementById(\"activity-root\");\n      if (!next || next.innerHTML === root.innerHTML) return;\n      root.replaceWith(next);\n    } catch {\n      // a failed poll just waits for the next tick\n    }\n  }, 5000);\n});\n";

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

@@ -1,2 +1,2 @@
 /** Generated from src/server/pages/client.js by scripts/embed_assets.mjs — do not edit. */
-export const client = "function toast(message) {\n  const host = document.getElementById(\"toasts\");\n  if (!host) return;\n  const el = document.createElement(\"div\");\n  el.className = \"toast\";\n  el.setAttribute(\"role\", \"status\");\n  el.textContent = message;\n  host.appendChild(el);\n  setTimeout(function () {\n    el.remove();\n  }, 5000);\n}\n\nfunction fail(card, message, retry) {\n  toast(message);\n  if (!card) return;\n  let box = card.querySelector(\"[data-fail]\");\n  if (!box) {\n    box = document.createElement(\"div\");\n    box.setAttribute(\"data-fail\", \"1\");\n    box.className = \"fail\";\n    card.appendChild(box);\n  }\n  box.replaceChildren();\n  const p = document.createElement(\"p\");\n  p.textContent = message;\n  const btn = document.createElement(\"button\");\n  btn.className = \"btn sm\";\n  btn.type = \"button\";\n  btn.textContent = \"Retry\";\n  btn.addEventListener(\"click\", retry);\n  box.appendChild(p);\n  box.appendChild(btn);\n}\n\nfunction clearFail(card) {\n  const box = card && card.querySelector(\"[data-fail]\");\n  if (box) box.remove();\n}\n\nfunction skeleton(card, on) {\n  if (!card) return;\n  card.classList.toggle(\"busy\", on);\n}\n\nasync function api(method, url, body) {\n  const res = await fetch(url, {\n    method: method,\n    headers: {\n      \"content-type\": \"application/json\",\n      \"x-requested-with\": \"co-maintainer\",\n    },\n    body: body === undefined ? undefined : JSON.stringify(body),\n  });\n  if (!res.ok) {\n    let message = \"Request failed\";\n    try {\n      const data = await res.json();\n      if (data.error && data.error.message) message = data.error.message;\n    } catch {\n      // body was not JSON; keep the generic message\n    }\n    throw new Error(message);\n  }\n  if (res.status === 204) return null;\n  return await res.json();\n}\n\nasync function run(btn, card, fn) {\n  if (btn) btn.disabled = true;\n  skeleton(card, true);\n  clearFail(card);\n  try {\n    await fn();\n  } catch (err) {\n    fail(card, err.message, function () {\n      run(btn, card, fn);\n    });\n  } finally {\n    if (btn) btn.disabled = false;\n    skeleton(card, false);\n  }\n}\n\nasync function postAndGo(url, body, next, btn) {\n  const card = btn && btn.closest(\"[data-async]\");\n  await run(btn, card, async function () {\n    await api(\"POST\", url, body);\n    location.href = next;\n  });\n}\n\n// Called from the inline scripts on the repo list and repo pages, which deno lint\n// cannot see, so it looks unused from inside this file.\n// deno-lint-ignore no-unused-vars\nfunction bindToggle(btn, url, field) {\n  btn.addEventListener(\"click\", async function () {\n    if (btn.disabled) return;\n    const on = !btn.classList.contains(\"on\");\n    btn.classList.toggle(\"on\", on);\n    btn.setAttribute(\"data-on\", on ? \"1\" : \"0\");\n    btn.disabled = true;\n    const card = btn.closest(\"[data-async]\");\n    try {\n      const payload = {};\n      payload[field] = on;\n      await api(\"PATCH\", url, payload);\n    } catch (err) {\n      btn.classList.toggle(\"on\", !on);\n      btn.setAttribute(\"data-on\", on ? \"0\" : \"1\");\n      fail(card, err.message, function () {\n        btn.click();\n      });\n    } finally {\n      btn.disabled = false;\n    }\n  });\n}\n\n// The helper is inlined into `<head>` by `layout.ts`, before any page script\n// runs, so this is the one place that can close over both `toast()` and\n// `bindToggle` without depending on point-in-time globals.\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  // Client errors bubble to `window` from `document`.\n  addEventListener(\"error\", function (ev) {\n    toast((ev.error && ev.error.message) || \"Something broke\");\n  });\n  addEventListener(\"unhandledrejection\", function (ev) {\n    toast((ev.reason && ev.reason.message) || \"Something broke\");\n  });\n\n  document.addEventListener(\"click\", function (ev) {\n    const btn =\n      ev.target && ev.target.closest\n        ? ev.target.closest(\"[data-cancel], [data-post]\")\n        : null;\n    if (!btn) return;\n    ev.preventDefault();\n    if (btn.hasAttribute(\"data-cancel\")) {\n      postAndGo(\n        \"/api/jobs/\" + btn.getAttribute(\"data-cancel\") + \"/cancel\",\n        {},\n        \"/activity\",\n        btn,\n      );\n      return;\n    }\n    const body = btn.getAttribute(\"data-body\");\n    postAndGo(\n      btn.getAttribute(\"data-post\"),\n      body ? JSON.parse(body) : {},\n      \"/activity\",\n      btn,\n    );\n  });\n\n  // Reads `activity-root` at call time, so it has to wait for the body even\n  // though this file itself is already parsed.\n  if (!document.getElementById(\"activity-root\")) return;\n  setInterval(async function () {\n    if (document.hidden) return;\n    if (document.querySelector(\"[data-async].busy\")) return;\n    const root = document.getElementById(\"activity-root\");\n    if (!root) return;\n    try {\n      const res = await fetch(location.pathname + location.search, {\n        headers: { accept: \"text/html\" },\n      });\n      if (!res.ok) return;\n      const doc = new DOMParser().parseFromString(\n        await res.text(),\n        \"text/html\",\n      );\n      const next = doc.getElementById(\"activity-root\");\n      if (!next || next.innerHTML === root.innerHTML) return;\n      root.replaceWith(next);\n    } catch {\n      // a failed poll just waits for the next tick\n    }\n  }, 5000);\n});\n";
+export const client = "function toast(message) {\n  const host = document.getElementById(\"toasts\");\n  if (!host) return;\n  const el = document.createElement(\"div\");\n  el.className = \"toast\";\n  el.setAttribute(\"role\", \"status\");\n  el.textContent = message;\n  host.appendChild(el);\n  setTimeout(function () {\n    el.remove();\n  }, 5000);\n}\n\nfunction fail(card, message, retry) {\n  toast(message);\n  if (!card) return;\n  let box = card.querySelector(\"[data-fail]\");\n  if (!box) {\n    box = document.createElement(\"div\");\n    box.setAttribute(\"data-fail\", \"1\");\n    box.className = \"fail\";\n    card.appendChild(box);\n  }\n  box.replaceChildren();\n  const p = document.createElement(\"p\");\n  p.textContent = message;\n  const btn = document.createElement(\"button\");\n  btn.className = \"btn sm\";\n  btn.type = \"button\";\n  btn.textContent = \"Retry\";\n  btn.addEventListener(\"click\", retry);\n  box.appendChild(p);\n  box.appendChild(btn);\n}\n\nfunction clearFail(card) {\n  const box = card && card.querySelector(\"[data-fail]\");\n  if (box) box.remove();\n}\n\nfunction skeleton(card, on) {\n  if (!card) return;\n  card.classList.toggle(\"busy\", on);\n}\n\nasync function api(method, url, body) {\n  const res = await fetch(url, {\n    method: method,\n    headers: {\n      \"content-type\": \"application/json\",\n      \"x-requested-with\": \"co-maintainer\",\n    },\n    body: body === undefined ? undefined : JSON.stringify(body),\n  });\n  if (!res.ok) {\n    let message = \"Request failed\";\n    let code = \"\";\n    let detail;\n    try {\n      const data = await res.json();\n      if (data.error && data.error.message) message = data.error.message;\n      if (data.error && data.error.code) code = data.error.code;\n      if (data.error) detail = data.error.detail;\n    } catch {\n      // body was not JSON; keep the generic message\n    }\n    const error = new Error(message);\n    if (code) error.code = code;\n    error.detail = detail;\n    throw error;\n  }\n  if (res.status === 204) return null;\n  return await res.json();\n}\n\nasync function run(btn, card, fn) {\n  if (btn) btn.disabled = true;\n  skeleton(card, true);\n  clearFail(card);\n  try {\n    await fn();\n  } catch (err) {\n    fail(card, err.message, function () {\n      run(btn, card, fn);\n    });\n  } finally {\n    if (btn) btn.disabled = false;\n    skeleton(card, false);\n  }\n}\n\n/** Polls one job until it reaches a terminal status. A running `init`/`remake`\n * ignores the abort signal, so \"wait for the sync\" is the only honest option\n * the clear pages can offer for it. */\nfunction waitForJob(id) {\n  return new Promise(function (resolve, reject) {\n    let attempts = 0;\n    async function tick() {\n      attempts++;\n      try {\n        const res = await fetch(\"/api/jobs/\" + encodeURIComponent(id), {\n          headers: { \"x-requested-with\": \"co-maintainer\" },\n        });\n        if (!res.ok) throw new Error(\"Could not check the running job.\");\n        const job = await res.json();\n        if (job.status !== \"running\" && job.status !== \"queued\") {\n          resolve();\n          return;\n        }\n        if (attempts > 1200) {\n          reject(new Error(\"The sync did not finish.\"));\n          return;\n        }\n        setTimeout(tick, 3000);\n      } catch (err) {\n        reject(err);\n      }\n    }\n    tick();\n  });\n}\n\n/** Clears knowledge, asking about pending jobs when the server refuses.\n * Returns false when the user backed out, so the caller does not reload.\n * A running review is abortable and a running setup is not, which is the\n * difference between the two questions. */\nasync function clearKnowledge(url, includeCache) {\n  const target = includeCache ? url + \"?includeCache=1\" : url;\n  const retry = target.indexOf(\"?\") >= 0 ? \"&\" : \"?\";\n  try {\n    await api(\"DELETE\", target);\n  } catch (err) {\n    if (err.code !== \"jobs_running\") throw err;\n    const detail = err.detail || { queued: 0, running: [] };\n    const running = detail.running || [];\n    const setup = running.find(function (job) {\n      return job.abortable === false;\n    });\n    if (setup) {\n      if (\n        !confirm(\n          \"A sync is running and cannot be stopped. Wait for it to finish and then clear?\",\n        )\n      ) {\n        return false;\n      }\n      await waitForJob(setup.id);\n      await api(\"DELETE\", target);\n      return;\n    }\n    const parts = [];\n    if (running.length) parts.push(running.length + \" running review(s)\");\n    if (detail.queued) parts.push(detail.queued + \" queued job(s)\");\n    if (!confirm(\"Stop \" + parts.join(\" and \") + \" and clear?\")) return false;\n    try {\n      await api(\"DELETE\", target + retry + \"onRunning=abort\");\n    } catch (retryError) {\n      // A setup job was claimed between the first 409 and this retry. It\n      // cannot be aborted, so wait it out like the branch above.\n      if (retryError.code !== \"job_not_abortable\") throw retryError;\n      const jobId = retryError.detail && retryError.detail.id;\n      if (jobId) await waitForJob(jobId);\n      await api(\"DELETE\", target);\n    }\n  }\n}\n\nasync function postAndGo(url, body, next, btn) {\n  const card = btn && btn.closest(\"[data-async]\");\n  await run(btn, card, async function () {\n    await api(\"POST\", url, body);\n    location.href = next;\n  });\n}\n\n// Called from the inline scripts on the repo list and repo pages, which deno lint\n// cannot see, so it looks unused from inside this file.\n// deno-lint-ignore no-unused-vars\nfunction bindToggle(btn, url, field) {\n  btn.addEventListener(\"click\", async function () {\n    if (btn.disabled) return;\n    const on = !btn.classList.contains(\"on\");\n    btn.classList.toggle(\"on\", on);\n    btn.setAttribute(\"data-on\", on ? \"1\" : \"0\");\n    btn.disabled = true;\n    const card = btn.closest(\"[data-async]\");\n    try {\n      const payload = {};\n      payload[field] = on;\n      await api(\"PATCH\", url, payload);\n    } catch (err) {\n      btn.classList.toggle(\"on\", !on);\n      btn.setAttribute(\"data-on\", on ? \"0\" : \"1\");\n      fail(card, err.message, function () {\n        btn.click();\n      });\n    } finally {\n      btn.disabled = false;\n    }\n  });\n}\n\n// The helper is inlined into `<head>` by `layout.ts`, before any page script\n// runs, so this is the one place that can close over both `toast()` and\n// `bindToggle` without depending on point-in-time globals.\ndocument.addEventListener(\"DOMContentLoaded\", function () {\n  // Client errors bubble to `window` from `document`.\n  addEventListener(\"error\", function (ev) {\n    toast((ev.error && ev.error.message) || \"Something broke\");\n  });\n  addEventListener(\"unhandledrejection\", function (ev) {\n    toast((ev.reason && ev.reason.message) || \"Something broke\");\n  });\n\n  document.addEventListener(\"click\", function (ev) {\n    const btn =\n      ev.target && ev.target.closest\n        ? ev.target.closest(\"[data-cancel], [data-post]\")\n        : null;\n    if (!btn) return;\n    ev.preventDefault();\n    if (btn.hasAttribute(\"data-cancel\")) {\n      postAndGo(\n        \"/api/jobs/\" + btn.getAttribute(\"data-cancel\") + \"/cancel\",\n        {},\n        \"/activity\",\n        btn,\n      );\n      return;\n    }\n    const body = btn.getAttribute(\"data-body\");\n    postAndGo(\n      btn.getAttribute(\"data-post\"),\n      body ? JSON.parse(body) : {},\n      \"/activity\",\n      btn,\n    );\n  });\n\n  // Reads `activity-root` at call time, so it has to wait for the body even\n  // though this file itself is already parsed.\n  if (!document.getElementById(\"activity-root\")) return;\n  setInterval(async function () {\n    if (document.hidden) return;\n    if (document.querySelector(\"[data-async].busy\")) return;\n    const root = document.getElementById(\"activity-root\");\n    if (!root) return;\n    try {\n      const res = await fetch(location.pathname + location.search, {\n        headers: { accept: \"text/html\" },\n      });\n      if (!res.ok) return;\n      const doc = new DOMParser().parseFromString(\n        await res.text(),\n        \"text/html\",\n      );\n      const next = doc.getElementById(\"activity-root\");\n      if (!next || next.innerHTML === root.innerHTML) return;\n      root.replaceWith(next);\n    } catch {\n      // a failed poll just waits for the next tick\n    }\n  }, 5000);\n});\n";

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. */