kaizen-agent 1.4.0 → 1.5.0

package/cli/install.ts

@@ -13,6 +13,7 @@ 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");
@@ -101,7 +102,7 @@ async function removeEverything() {
   // 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");
+  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))]
@@ -203,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"]);
+});