kaizen-agent 1.3.10 → 1.5.0

package/cli/install.ts

@@ -13,7 +13,9 @@ const REPO_URL = "https://github.com/hfadhlullah/kaizen.git";
 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 wantWeb = args.has("web");
 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 +70,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("./state.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.
@@ -121,6 +204,14 @@ if (wantSettings) {
   process.exit(0);
 }
 
+if (wantWeb) {
+  const { web } = await import("./web.ts");
+  const at = Bun.argv.indexOf("--port");
+  const port = at !== -1 ? Number(Bun.argv[at + 1]) || undefined : undefined;
+  await web(await resolveRepoQuietly(), { port, open: !args.has("--no-open") });
+  process.exit(0);
+}
+
 // Bare `kaizen` on a machine where it is already installed is not an install --
 // show what the project is doing instead, and offer the things you would have
 // opened a terminal for.

package/cli/publish-gh.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+# Publish the same tarball to GitHub Packages, so the repo's "Packages" box lists
+# it. GitHub only accepts names scoped to the repo owner, so the package goes there
+# as @hfadhlullah/kaizen-agent while npm keeps kaizen-agent. Run after `bun publish`.
+set -eu
+cd "$(dirname "$0")/.."
+token="${GITHUB_TOKEN:-$(gh auth token 2>/dev/null || true)}"
+[ -n "$token" ] || { echo "publish-gh: no GitHub token (gh auth login, scope write:packages)"; exit 1; }
+
+tmp="$(mktemp -d)"
+trap 'rm -rf "$tmp"' EXIT
+cp package.json "$tmp/package.json.orig"
+bun -e '
+  const p = JSON.parse(await Bun.file("package.json").text());
+  p.name = "@hfadhlullah/kaizen-agent";
+  p.publishConfig = { registry: "https://npm.pkg.github.com" };
+  await Bun.write("package.json", JSON.stringify(p, null, 2) + "\n");
+'
+# Bun reads the project's own .npmrc; a temporary one carries the token and never
+# lands in git (it is removed on exit, and .gitignore refuses it besides).
+[ -e .npmrc ] && cp .npmrc "$tmp/npmrc.orig"
+printf '//npm.pkg.github.com/:_authToken=%s\n@hfadhlullah:registry=https://npm.pkg.github.com\n' "$token" > .npmrc
+# The scoped copy must not run postpublish: the tag and release already exist.
+bun publish --ignore-scripts "$@" || status=$?
+cp "$tmp/package.json.orig" package.json
+if [ -e "$tmp/npmrc.orig" ]; then cp "$tmp/npmrc.orig" .npmrc; else rm -f .npmrc; fi
+exit "${status:-0}"

package/cli/release.sh

@@ -1,11 +1,11 @@
 #!/bin/sh
-# Runs after `npm publish`: tag the published version and open a GitHub release
+# Runs after `bun publish`: tag the published version and open a GitHub release
 # for it, so a version can never exist on npm with nothing to read on GitHub.
 #
 # Never fails the publish. The package is already public by the time this runs;
 # exiting non-zero here would report a failure that did not happen.
 set -u
-v="${npm_package_version:-$(node -p "require('./package.json').version" 2>/dev/null)}"
+v="${npm_package_version:-$(bun -p "require('./package.json').version" 2>/dev/null)}"
 [ -n "$v" ] || { echo "release: no version, skipping"; exit 0; }
 tag="v$v"
 

package/cli/state.test.ts

@@ -0,0 +1,106 @@
+// State module against a throwaway .kaizen/. Nothing here spawns a terminal: the
+// launch path is covered only up to the command it would run.
+import { test, expect, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  readRuns, readInbox, writeInbox, replaceIdea, abandonRun, allBacklog, backlog,
+  statusOf, columnOf, parseItem, startedRuns, boardCards,
+} from "./state.ts";
+
+let state: string;
+const run = (id: string, s: object, request = "") => {
+  const dir = join(state, "runs", id);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "state.json"), JSON.stringify(s));
+  if (request) writeFileSync(join(dir, "00-request.md"), request);
+  return dir;
+};
+
+beforeAll(() => {
+  state = join(mkdtempSync(join(tmpdir(), "kaizen-")), ".kaizen");
+  mkdirSync(state, { recursive: true });
+  run("2026-09-01-waiting", { stage: "plan", awaiting: "approvals.plan" }, "# Request\n\nAdd OAuth login\n");
+  run("2026-09-02-done", { stage: "done", awaiting: null }, "# Request\n\nRename cli flags\n");
+  const old = run("2026-09-03-stale", { stage: "build", awaiting: null });
+  const then = new Date(Date.now() - 2 * 3600_000);
+  utimesSync(join(old, "state.json"), then, then);
+  writeFileSync(join(state, "runs", "2026-09-02-done", "06-backlog.md"),
+    "# Backlog\n\n- open: `cli/x.ts:12`: low: first thing. Fix: do it.\n- done: closed one | run y\n- open: plain item\n");
+  writeFileSync(join(state, "backlog.md"), "- open: orphaned item\n");
+  writeInbox(state, [
+    { status: "open", text: "add oauth login" },
+    { status: "open", text: "retry failed webhooks" },
+    { status: "started", text: "nightly digest" },
+    { status: "rejected", text: "gantt view | not this product" },
+  ]);
+});
+afterAll(() => rmSync(join(state, ".."), { recursive: true, force: true }));
+
+test("readRuns: newest first, mtime as moved", () => {
+  const runs = readRuns(state);
+  expect(runs.map((r) => r.id)).toEqual(["2026-09-03-stale", "2026-09-02-done", "2026-09-01-waiting"]);
+  expect(runs[2]!.awaiting).toBe("approvals.plan");
+  expect(runs[0]!.moved).toBeLessThan(Date.now() - 3600_000);
+});
+
+test("statusOf: waiting beats stage, mtime decides running vs stalled", () => {
+  const now = Date.now();
+  const [stale, done, waiting] = readRuns(state);
+  expect(statusOf(waiting!, now)).toBe("waiting");
+  expect(statusOf(done!, now)).toBe("done");
+  expect(statusOf(stale!, now)).toBe("stalled");
+  expect(statusOf({ ...stale!, moved: now }, now)).toBe("running");
+  expect(statusOf({ ...stale!, stage: "abandoned", awaiting: "x" }, now)).toBe("abandoned");
+});
+
+test("columnOf: every stage word lands somewhere", () => {
+  expect(["plan", "build", "review", "done", "abandoned", "weird"].map(columnOf)).toEqual([1, 2, 3, 4, 4, 1]);
+});
+
+test("inbox round-trips and ignores malformed lines", () => {
+  writeFileSync(join(state, "inbox.md"), readFileSync(join(state, "inbox.md"), "utf8") + "not an item\n");
+  expect(readInbox(state).map((l) => l.status)).toEqual(["open", "open", "started", "rejected"]);
+});
+
+test("boardCards: idea retired once a run's request contains it; started idea sits in planning", () => {
+  const cards = boardCards([state], Date.now());
+  const ideas = cards.filter((k) => k.kind === "idea").map((k) => [k.text, k.column, k.status]);
+  expect(ideas).toEqual([["retry failed webhooks", 0, "idea"], ["nightly digest", 1, "starting"]]);
+  const runs = cards.filter((k) => k.kind === "run").map((k) => [k.id, k.column, k.status]);
+  expect(runs).toEqual([["2026-09-03-stale", 2, "stalled"], ["2026-09-02-done", 4, "done"], ["2026-09-01-waiting", 1, "waiting"]]);
+});
+
+test("replaceIdea edits, rejects, deletes by text", () => {
+  replaceIdea(state, "retry failed webhooks", { status: "open", text: "retry failed webhooks twice" });
+  expect(readInbox(state).some((l) => l.text === "retry failed webhooks twice")).toBe(true);
+  replaceIdea(state, "retry failed webhooks twice", { status: "rejected", text: "retry failed webhooks twice | no" });
+  replaceIdea(state, "nightly digest", null);
+  expect(readInbox(state).map((l) => l.status)).toEqual(["open", "rejected", "rejected"]);
+});
+
+test("abandonRun: flips stage, clears awaiting, records the reason, refuses twice", () => {
+  expect(abandonRun(state, "2026-09-01-waiting", "changed my mind")).toBeNull();
+  const s = JSON.parse(readFileSync(join(state, "runs", "2026-09-01-waiting", "state.json"), "utf8"));
+  expect([s.stage, s.awaiting]).toEqual(["abandoned", null]);
+  expect(readFileSync(join(state, "runs", "2026-09-01-waiting", "02-approval.md"), "utf8")).toContain("changed my mind");
+  expect(abandonRun(state, "2026-09-01-waiting", "again")).toMatch(/already/);
+});
+
+test("backlog: open items only, orphanage last, count matches", () => {
+  const groups = allBacklog(state);
+  expect(groups.map((g) => g.run)).toEqual(["2026-09-02-done", "Orphaned"]);
+  expect(groups[0]!.items.length).toBe(2);
+  expect(backlog(state)).toBe(3);
+});
+
+test("parseItem: finding line splits into where, severity, text", () => {
+  const it = parseItem("`cli/x.ts:12`: low: first thing. Fix: do it.");
+  expect([it.where, it.severity, it.text]).toEqual(["x.ts:12", "low", "first thing."]);
+  expect(parseItem("plain item").severity).toBeNull();
+});
+
+test("startedRuns: normalised request bodies", () => {
+  expect(startedRuns(state).sort()).toEqual(["# request add oauth login", "# request rename cli flags"]);
+});