kaizen-agent 1.2.1 → 1.3.0

package/README.md

@@ -226,6 +226,62 @@ kaizen Done, and reviewed. Two things found:
 
 </details>
 
+## The board
+
+`kaizen` opens a dashboard; **Board** is the screen where your work lives. Ideas you have
+not started sit on the left, runs sit under the stage they are actually in, and it redraws
+itself as your agents write to disk — a run that moves while you are looking at it moves on
+screen.
+
+```
+  Board   ~/code/acme-api
+
+  IDEA                     PLANNING              BUILDING           REVIEW          DONE
+  ──────────────────────   ───────────────────   ────────────────   ─────────────   ──────────────
+  › · rate limit the       ◌ nightly digest      ● payroll export   ● oauth login   ○ rename cli
+      public API                                                                      flags
+                           ● landing page                                           ○ csv import
+    · retry failed
+      webhooks
+
+  ↑↓←→ move     n new  e edit  x reject  d delete  r run     a all projects  q back
+  ● running    ◐ stalled    ◌ starting    ● waiting on you    ○ done    · idea
+```
+
+**Throw an idea in with `n`** and it lands in `<state.dir>/inbox.md`, one line each, in the
+same format a run's backlog already uses. `e` edits, `x` rejects with a reason, `d` deletes.
+
+**`r` starts a run from an idea** — it asks `full` or `lite`, then opens your configured
+agent with the request already typed. The idea retires from the board once a run exists
+that was started from its text, whoever started it, so the same work never appears twice.
+That check spans every project you have opened, because an idea thrown into the global
+inbox becomes a run inside whichever project you launched the agent in.
+
+**The dot is what the run is doing.** `●` cyan is running and `◐` is stalled — kaizen
+records no liveness signal anywhere, so "running" means the run's `state.json` has changed
+in the last half hour. A run whose terminal you closed three days ago shows as stalled,
+which is the distinction the board exists to make. `●` amber, with the name in red, is a
+run that cannot move until you decide something; the legend lists only the states actually
+on screen.
+
+**A run's stage is kaizen's, not yours.** You cannot drag a card between columns — a board
+that could do that would be lying about what happened. The one exception is `x` on a run
+card, which abandons it: the same transition `/kaizen abort` makes, with your reason
+recorded in the run's approval file.
+
+`a` switches between this project and every project kaizen knows about. Below a hundred
+columns the board stacks into a list rather than squeezing five columns into sixty.
+
+### Mouse
+
+Off by default. Turn it on in `kaizen settings` under `ui.mouse`, and clicking a row or
+card selects it, clicking it again opens or runs it, and the wheel scrolls — on the board,
+the menu, runs, backlog, projects and settings.
+
+It ships off because the trade is real: while the TUI holds the mouse, your terminal cannot
+select text with it, so copying a run id out of the dashboard stops working until you
+leave. Hold **Shift** and drag to select text anyway.
+
 ## Install
 
 ### Prerequisites: Bun
@@ -433,6 +489,7 @@ in one can be finished in another. See [adapters.md](https://github.com/hfadhlul
 | `build.executor` | `subagent` | Who does the work: a separate agent, `inline` in the current one, or `ask` each time |
 | `auto_fix.min_severity` | `high` | Findings this bad or worse get fixed without asking |
 | `approvals.plan` | `true` | Stop and show the plan before anything is built |
+| `ui.mouse` | `false` | Click to select, click again to act; while on, the terminal cannot select text |
 
 ```bash
 kaizen settings

package/cli/install.ts

@@ -2,9 +2,10 @@
 import {
   symlinkSync, mkdirSync, readdirSync, lstatSync, readlinkSync, unlinkSync,
   existsSync, copyFileSync, readFileSync, appendFileSync, rmSync, writeFileSync,
+  statSync, cpSync,
 } from "node:fs";
 import { join, dirname, basename } from "node:path";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { applyPreset, detectPreset, PRESETS, type PresetName } from "./settings.ts";
 
 const home = homedir();
@@ -319,8 +320,18 @@ async function resolveRepo() {
     }
     return dest;
   }
-  step(`cloning into ${tilde(dest)}`);
-  await Bun.$`git clone --quiet ${REPO_URL} ${dest}`;
+  if (Bun.which("git")) {
+    step(`cloning into ${tilde(dest)}`);
+    await Bun.$`git clone --quiet ${REPO_URL} ${dest}`;
+    return dest;
+  }
+  // No git: the bunx download already holds everything a clone would, so copy it
+  // in place. Upgrades then come from re-running bunx rather than a pull.
+  step(`copying into ${tilde(dest)} ${c.dim("(no git)")}`);
+  cpSync(here, dest, {
+    recursive: true, dereference: true,
+    filter: (src) => basename(src) !== "node_modules",
+  });
   return dest;
 }
 
@@ -356,10 +367,30 @@ const links = targets.flatMap((a) => [
   ] : []),
 ]);
 
+const isWindows = process.platform === "win32";
+
+// Windows only hands out file symlinks to an admin or a Developer Mode box, so
+// there the link is a directory junction (allowed for everyone) or, for a plain
+// file, a copy that is refreshed whenever the source moves ahead.
+function makeLink(src: string, dest: string) {
+  if (!isWindows) { symlinkSync(src, dest); return; }
+  if (statSync(src).isDirectory()) { symlinkSync(src, dest, "junction"); return; }
+  copyFileSync(src, dest);
+}
+
+function sameFile(a: string, b: string) {
+  try { return readFileSync(a).equals(readFileSync(b)); } catch { return false; }
+}
+
 function linkState(src: string, dest: string) {
   try {
     const st = lstatSync(dest);
-    if (!st.isSymbolicLink()) return "occupied";
+    if (!st.isSymbolicLink()) {
+      // A copied link on Windows is a real file; it is ours as long as it still
+      // matches the source, and stale once the source changes.
+      if (isWindows && st.isFile()) return sameFile(src, dest) ? "linked" : "stale";
+      return "occupied";
+    }
     return readlinkSync(dest) === src ? "linked" : "stale";
   } catch {
     return "missing";
@@ -385,8 +416,8 @@ for (const [src, sub] of links) {
     continue;
   }
   mkdirSync(dir, { recursive: true });
-  if (state !== "missing") unlinkSync(dest);
-  symlinkSync(src, dest);
+  if (state !== "missing") rmSync(dest, { recursive: true, force: true });
+  makeLink(src, dest);
   wrote++;
   if (verbose) console.log(c.dim(`  link  ${name}`));
 }
@@ -603,7 +634,7 @@ function clean(out: string) {
 // without re-resolving, so an upgrade that only pulls the clone still leaves the
 // next `bunx kaizen-agent` running whatever was cached the first time.
 async function clearBunxCache() {
-  const tmp = process.env.TMPDIR ?? "/tmp";
+  const tmp = process.env.TMPDIR ?? tmpdir();
   let removed = 0;
   try {
     for (const name of readdirSync(tmp)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kaizen-agent",
-  "version": "1.2.1",
-  "description": "Staged workflow for AI agents \u2014 code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
+  "version": "1.3.0",
+  "description": "Staged workflow for AI agents — code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
   "type": "module",
   "bin": {
     "kaizen-agent": "./cli/install.ts",