kaizen-agent 1.3.10 → 1.4.0

package/README.md

@@ -574,11 +574,20 @@ with a comment on each key, if you would rather edit the file.
 | `--yes` | Take every default, ask nothing |
 | `--verbose` | List every link instead of a one-line summary |
 | `upgrade` | Pull, relink, and clear the installer cache. No prompts. |
+| `uninstall` | Remove the links, the clone, and the launcher. Asks whether to keep your runs and settings. |
+| `uninstall --purge` | The same, and delete `~/.kaizen` and this project's `.kaizen/` too. |
 | `settings` | Open the settings browser for the nearest `.kaizen/`. Also `config`. |
 
-A global install also writes `~/.local/bin/kaizen`, a two-line launcher pointing at
+Uninstalling works the same on Linux, macOS and Windows — `kaizen uninstall`, or
+`bunx kaizen-agent uninstall` when the command itself is already gone. It offers three
+answers — keep your runs and settings, remove everything, or cancel — and takes the
+first without asking when the output is not a terminal. It lists what it removed; the `## Kaizen workflow` line in each project's `CLAUDE.md` is left for
+you to delete, since you may have edited around it.
+
+A global install also writes `~/.local/bin/kaizen` (`kaizen.cmd` in bun's bin
+directory on Windows), a two-line launcher pointing at
 the clone, so `kaizen upgrade` works from anywhere. It tells you if that directory is
-not on your PATH. Delete the file to remove it; `--project` installs skip it.
+not on your PATH. `uninstall` removes it; `--project` installs skip it.
 
 Re-running is safe: correct links are left alone.
 

package/cli/dashboard.ts

@@ -440,8 +440,7 @@ export async function dashboard(
     // Only searching under $HOME misses every project on another drive or mount,
     // which on Windows is most of them. The folder the dashboard was opened in is
     // searched too, and it is where the projects being worked on actually are.
-    const roots = [home, dirname(state ?? process.cwd()), process.cwd()]
-      .filter((d, i, all) => all.indexOf(d) === i);
+    const roots = searchRoots([dirname(state ?? process.cwd()), process.cwd()]);
     const found = [...new Set(roots.flatMap((r) => findProjects(r)))];
     for (const dir of found) remember(dir);
     const added = knownProjects().length - before;
@@ -1289,6 +1288,21 @@ export async function dashboard(
 // read and corrected in an editor; blanks and # lines ignored.
 const REGISTRY = join(home, ".kaizen", "projects");
 
+// Windows spreads work across drives -- the profile on C:, the projects on D: or E: --
+// and a search that only knows $HOME finds none of them. Every letter that answers is
+// a root worth walking; elsewhere there is one filesystem and $HOME is where work
+// lives, so walking / would cost minutes to find nothing.
+export function searchRoots(extra: string[] = []): string[] {
+  const roots = [home, ...extra];
+  if (process.platform === "win32") {
+    for (const letter of "ABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+      const drive = `${letter}:\\`;
+      try { readdirSync(drive); roots.push(drive); } catch { /* no such drive */ }
+    }
+  }
+  return roots.filter((d, i, all) => d && all.indexOf(d) === i);
+}
+
 export function knownProjects(): string[] {
   if (!existsSync(REGISTRY)) return [];
   return readFileSync(REGISTRY, "utf8").split("\n")
@@ -1306,10 +1320,16 @@ export function remember(projectDir: string) {
   } catch { /* nothing here is worth an error */ }
 }
 
+const SKIP = new Set([
+  "windows", "program files", "program files (x86)", "programdata", "$recycle.bin",
+  "system volume information", "appdata", "node_modules", "recovery", "perflogs",
+  "library", "applications", "onedrive", "onedrivetemp",
+]);
+
 // Bounded on purpose. Depth is what keeps this from becoming a filesystem walk, and
 // the skips are the directories that make one slow: node_modules, and anything dotted
 // (which includes .git, and every state directory that is not a project of its own).
-function findProjects(root: string, depth = 4): string[] {
+export function findProjects(root: string, depth = 4): string[] {
   const found: string[] = [];
   const walk = (dir: string, left: number) => {
     let entries: string[];
@@ -1322,6 +1342,9 @@ function findProjects(root: string, depth = 4): string[] {
     if (left === 0) return;
     for (const name of entries) {
       if (name.startsWith(".") || name === "node_modules") continue;
+      // Walking a whole drive means walking Windows itself otherwise: tens of
+      // thousands of directories that have never held a project.
+      if (SKIP.has(name.toLowerCase())) continue;
       try { if (statSync(join(dir, name)).isDirectory()) walk(join(dir, name), left - 1); }
       catch { /* unreadable or vanished mid-walk */ }
     }

package/cli/install.ts

@@ -14,6 +14,7 @@ const args = new Set(Bun.argv.slice(2));
 const upgrade = args.has("upgrade") || args.has("--upgrade");
 const wantSettings = args.has("settings") || args.has("config");
 const check = args.has("--check");
+const uninstall = args.has("uninstall") || args.has("--uninstall");
 const force = args.has("--force");
 const verbose = args.has("--verbose");
 const interactive = process.stdin.isTTY && !check && !upgrade && !args.has("--yes");
@@ -68,6 +69,87 @@ const onPath = new Set(
 const found = (r: string) =>
   AGENTS.filter((a) => existsSync(join(r, a.dir)) || onPath.has(a.dir));
 
+if (uninstall) { await removeEverything(); process.exit(0); }
+
+// Everything kaizen put on this machine, in one place, so uninstalling needs no
+// clone to read: the links are known by name, the rest by path. State (~/.kaizen
+// and any project's .kaizen) is left alone unless --purge says otherwise, because
+// it holds runs and decisions this program did not write.
+async function removeEverything() {
+  let purge = args.has("--purge") || args.has("--all");
+  // Deleting someone's runs is not a thing to do on a typo, so ask unless the
+  // answer already arrived as a flag.
+  if (interactive && !purge) {
+    const choice = await select("Uninstall kaizen", [
+      { label: "Keep my runs and settings", hint: "removes the app, keeps ~/.kaizen and each project's .kaizen/", value: "keep" },
+      { label: "Remove everything", hint: "also deletes runs, backlog, memory and settings", value: "all" },
+      { label: "Cancel", hint: "change nothing", value: "cancel" },
+    ]);
+    if (choice === "cancel") { console.log(`\n  ${c.dim("Nothing removed.")}\n`); return; }
+    purge = choice === "all";
+  }
+  const gone: string[] = [];
+  const stuck: string[] = [];
+  const drop = (p: string) => {
+    if (!existsSync(p) && !isLink(p)) return;
+    // Windows refuses to delete a file another process holds open, and a silent
+    // failure here would read as a clean uninstall that removed nothing.
+    try { rmSync(p, { recursive: true, force: true }); gone.push(tilde(p)); }
+    catch { stuck.push(tilde(p)); }
+  };
+
+  // A --project install puts links in the project folder, and on Windows those
+  // projects live on other drives entirely. Every project kaizen knows about is
+  // checked, plus whatever a drive-wide scan turns up.
+  const { knownProjects, searchRoots, findProjects } = await import("./dashboard.ts");
+  step("looking for project installs");
+  const roots = [home, process.cwd(), ...knownProjects(),
+    ...searchRoots([process.cwd()]).flatMap((r) => findProjects(r))]
+    .filter((d, i, all) => all.indexOf(d) === i);
+
+  for (const root of roots) {
+    for (const a of AGENTS) {
+      for (const n of ["kaizen", "kaizen-help"]) drop(join(root, a.dir, "skills", n));
+      for (const sub of ["agents", "commands"]) {
+        const dir = join(root, a.dir, sub);
+        try {
+          for (const f of readdirSync(dir)) {
+            if (f.startsWith("kaizen-") && f.endsWith(".md")) drop(join(dir, f));
+          }
+        } catch { /* no such directory */ }
+      }
+    }
+  }
+
+  drop(process.env.KAIZEN_HOME ?? join(home, "kaizen"));
+  drop(join(process.env.BUN_INSTALL ?? join(home, ".bun"), "bin", "kaizen.cmd"));
+  drop(join(home, ".local", "bin", "kaizen"));
+  await clearBunxCache();
+
+  if (purge) {
+    drop(join(home, ".kaizen"));
+    drop(join(process.cwd(), ".kaizen"));
+  }
+
+  console.log(`\n  ${c.bold("Uninstalled")}`);
+  for (const p of gone) console.log(`  ${c.dim("removed  " + p)}`);
+  if (!gone.length && !stuck.length) console.log(`  ${c.dim("nothing left to remove")}`);
+  if (stuck.length) {
+    console.log(`\n  ${c.bold("could not remove")} ${c.dim("— close any dashboard or agent still using these, then run it again")}`);
+    for (const p of stuck) console.log(`  ${c.dim(p)}`);
+  }
+  console.log(purge
+    ? `\n  ${c.dim("Runs and settings deleted too.")}\n`
+    : `\n  ${c.dim("Runs and settings kept in")} ${c.cyan(tilde(join(home, ".kaizen")))}${c.dim(" — add --purge to delete them.")}\n`);
+  console.log(`  ${c.dim("The CLAUDE.md / AGENTS.md line in each project is left for you to remove.")}\n`);
+}
+
+// A dangling symlink fails existsSync, and a stale link is exactly what wants
+// removing here.
+function isLink(p: string) {
+  try { return lstatSync(p).isSymbolicLink(); } catch { return false; }
+}
+
 // Nothing to install into. kaizen is a workflow an agent runs; on its own it does
 // nothing, so send them to the agent first rather than laying out files no reader
 // will ever load.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "1.3.10",
+  "version": "1.4.0",
   "description": "Staged workflow for AI agents — code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
   "type": "module",
   "bin": {