kaizen-agent 1.18.0 → 1.19.1

package/README.md

@@ -230,6 +230,8 @@ Anthropic, OpenAI and Requesty are supported. Setup, privacy and settings are in
 
 In a terminal: `kaizen` (dashboard), `kaizen web` (board), `kaizen settings`, `kaizen upgrade`.
 
+Stuck on 1.18.0 or older? If `kaizen upgrade` says *could not pull* and stays on the old version, run this once: `bunx kaizen-agent@latest`. Your old install is kept as `~/kaizen.old`; from then on `kaizen upgrade` works by itself.
+
 ## Learn more
 
 - **[The guide](https://github.com/hfadhlullah/kaizen/blob/main/docs/guide.md)**: the board, request sources, notebook, settings, installer flags, uninstall

package/cli/install.test.ts

@@ -4,7 +4,7 @@
 // Skipped on Windows: there uninstall also walks every drive (searchRoots) and
 // strips kaizen links from real projects, whatever HOME says.
 import { test, expect } from "bun:test";
-import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync, symlinkSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync, symlinkSync, cpSync, readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -83,3 +83,58 @@ it.skipIf(!Bun.which("git"))("uninstall removes a clean clone of kaizen and keep
   expect(unpushed.left).toBe(true);
   expect(unpushed.out).toContain("commits not pushed");
 });
+
+// An npm package of this checkout, at a version no real release has: no .git, so its
+// installer runs as `bunx kaizen-agent` would. Scratch HOME only; ~/kaizen is a fake.
+const fromPackage = (make: (k: string) => void, custom = false) => {
+  const root = mkdtempSync(join(tmpdir(), "kz-replace-"));
+  const home = join(root, "home"), pkg = join(root, "pkg");
+  const k = custom ? join(root, "kaizen") : join(home, "kaizen");
+  mkdirSync(home);
+  const src = dirname(dirname(import.meta.path));
+  for (const d of ["cli", "skills", "agents", "commands", "web", "package.json"]) {
+    cpSync(join(src, d), join(pkg, d), { recursive: true, filter: (p) => !p.includes("node_modules") });
+  }
+  const pj = join(pkg, "package.json");
+  writeFileSync(pj, readFileSync(pj, "utf8").replace(/"version": "[^"]*"/, '"version": "9.9.9"'));
+  make(k);
+  const env: Record<string, string> = { PATH: process.env.PATH ?? "", HOME: home, USERPROFILE: home, TMPDIR: root };
+  if (custom) env.KAIZEN_HOME = k;
+  const p = Bun.spawnSync([process.execPath, join(pkg, "cli", "install.ts"), "--yes", "--global"], { cwd: home, env });
+  const r = {
+    out: p.stdout.toString(),
+    version: existsSync(join(k, "package.json")) ? JSON.parse(readFileSync(join(k, "package.json"), "utf8")).version : null,
+    oldKept: existsSync(join(`${k}.old`, "mine.txt")),
+    mineInPlace: existsSync(join(k, "mine.txt")),
+  };
+  rmSync(root, { recursive: true, force: true });
+  return r;
+};
+
+it.skipIf(!Bun.which("git"))("an npm package replaces a ~/kaizen clone with local edits, keeping it as .old", () => {
+  const r = fromPackage(clone(REPO, true));
+  expect(r.version).toBe("9.9.9");
+  expect(r.mineInPlace).toBe(false);
+  expect(r.oldKept).toBe(true);
+  expect(r.out).toContain("replaced");
+});
+
+it.skipIf(!Bun.which("git"))("an npm package never replaces a development checkout", () => {
+  expect(fromPackage(clone(REPO, true), true).mineInPlace).toBe(true);
+  const unpushed = fromPackage(clone(REPO, true, commit));
+  expect(unpushed.mineInPlace).toBe(true);
+  expect(unpushed.out).toContain("commits not pushed");
+});
+
+it("upgrade with npm unreachable says not upgraded, never up to date", () => {
+  const root = mkdtempSync(join(tmpdir(), "kz-offline-"));
+  const home = join(root, "home");
+  mkdirSync(home);
+  kaizenFiles(join(home, "kaizen"));
+  const env = { PATH: process.env.PATH ?? "", HOME: home, TMPDIR: root, HTTPS_PROXY: "http://127.0.0.1:9", https_proxy: "http://127.0.0.1:9" };
+  const p = Bun.spawnSync([process.execPath, script, "upgrade"], { cwd: home, env });
+  rmSync(root, { recursive: true, force: true });
+  expect(p.exitCode).not.toBe(0);
+  expect(p.stdout.toString()).toContain("Not upgraded");
+  expect(p.stdout.toString()).not.toContain("Up to date");
+});

package/cli/install.ts

@@ -407,35 +407,40 @@ if (interactive && !upgrade && Bun.argv.length === 2) {
 
 if (upgrade) await clearBunxCache();
 
-// An install made without git is a copy, not a clone, so there is nothing to pull:
-// upgrading itself would copy ~/kaizen over ~/kaizen and report "already up to
-// date" forever. The new version comes from npm, and the installer inside it does
-// the copying and relinking, so hand the job over and stop.
-if (upgrade && !existsSync(join(dirname(import.meta.dir), ".git"))) {
+// Upgrade means the newest release on npm, whatever the install on disk is: a clone
+// with local edits used to fail its pull and still report "Up to date". The npm
+// package's own installer replaces the install (see resolveRepo), so hand it over.
+if (upgrade) {
+  const dest = installDir();
+  const now = versionOf(dest);
+  const why = await devCheckout(dest);
+  if (why) {
+    console.log(`\n  ${c.bold("Not upgraded")}  ${c.dim(`${tilde(dest)} is ${why}; update it with git`)}\n`);
+    process.exit(1);
+  }
   const latest = await npmLatest();
-  const now = versionOf(dirname(import.meta.dir));
-  // A copy can only upgrade through npm. When the version lookup fails, bun still
-  // resolves "latest" its own way, so ask for that rather than falling through --
-  // which would copy this install over itself and call it up to date.
-  if (latest !== now) {
-    const want = latest ?? "latest";
-    step(`fetching kaizen ${want} from npm`);
-    // --force so a stale package manifest cannot resolve the version away, and the
-    // failure is printed rather than swallowed: a silent catch here looked exactly
-    // like a successful upgrade that changed nothing.
-    const r = await Bun.$`${process.execPath} x --force kaizen-agent@${want} --yes`
-      .quiet().nothrow();
-    const out = clean(r.stdout.toString() + r.stderr.toString()).filter((l) => l.trim());
-    for (const l of out) console.log(l.startsWith("  ") ? l : `  ${l}`);
-    if (r.exitCode !== 0) {
-      console.log(`\n  ${c.bold(`could not fetch kaizen ${want}`)}`);
-      console.log(`  ${c.dim("try:")} ${c.cyan(`bunx kaizen-agent@${want}`)}\n`);
-      process.exit(1);
-    }
-    const after = versionOf(process.env.KAIZEN_HOME ?? join(home, "kaizen"));
-    if (after === now) console.log(`\n  ${c.bold(`kaizen ${now} is the latest on npm`)}\n`);
+  if (!latest) {
+    console.log(`\n  ${c.bold("Not upgraded")}  ${c.dim(`could not reach npm (kaizen ${now})`)}\n`);
+    process.exit(1);
+  }
+  if (latest === now) {
+    console.log(`\n  ${c.bold("Up to date")}${c.dim(`  —  kaizen ${now}`)}\n`);
     process.exit(0);
   }
+  step(`fetching kaizen ${latest} from npm`);
+  // --force so a stale package manifest cannot resolve the version away, and the
+  // failure is printed rather than swallowed.
+  const r = await Bun.$`${process.execPath} x --force kaizen-agent@${latest} --yes`.quiet().nothrow();
+  const out = clean(r.stdout.toString() + r.stderr.toString()).filter((l) => l.trim());
+  for (const l of out) console.log(l.startsWith("  ") ? l : `  ${l}`);
+  const after = versionOf(dest);
+  if (r.exitCode !== 0 || after !== latest) {
+    console.log(`\n  ${c.bold(`could not install kaizen ${latest}`)}`);
+    console.log(`  ${c.dim("try:")} ${c.cyan(`bunx kaizen-agent@${latest}`)}\n`);
+    process.exit(1);
+  }
+  console.log(`\n  ${c.bold("Upgraded")}  ${c.dim(now)} → ${c.green(after)}\n  ${c.dim("Restart Claude Code to pick up any new slash commands.")}\n`);
+  process.exit(0);
 }
 if (!check && !upgrade) await welcome();
 
@@ -597,41 +602,34 @@ async function resolveRepoQuietly() {
 
 async function resolveRepo() {
   const here = dirname(import.meta.dir);
-  const dest = process.env.KAIZEN_HOME ?? join(home, "kaizen");
-  // The launcher runs the clone itself, so an upgrade from inside it must pull
-  // that clone -- returning it untouched was "Up to date" at whatever was there.
-  for (const dir of [here, dest]) {
-    if (!existsSync(join(dir, ".git"))) continue;
-    if (!upgrade && dir === here) return dir;
-    // A pull can refuse for reasons that have nothing to do with linking -- local
-    // edits, a detached head, no network. Linking the checkout already on disk
-    // still works, so say what happened and carry on.
-    try {
-      await Bun.$`git -C ${dir} pull --ff-only`.quiet();
-      step(`updated ${tilde(dir)}`);
-    } catch {
-      step(`kept ${tilde(dir)} ${c.dim("(could not pull)")}`);
+  const dest = installDir();
+  // Running from a checkout (development, or the launcher's old clone): link it as is.
+  if (existsSync(join(here, ".git"))) return here;
+  // Running from an npm package: that package is the version wanted, so it replaces
+  // whatever ~/kaizen holds -- local edits included -- rather than a pull that any
+  // edit makes fail. The previous install is kept as <dest>.old, one deep.
+  if (here !== dest && existsSync(dest)) {
+    const why = await devCheckout(dest);
+    if (why) {
+      step(`kept ${tilde(dest)} ${c.dim(`(${why}; not replaced)`)}`);
+      return dest;
     }
-    return dir;
-  }
-  // A copy made before git was installed can never be pulled, so it keeps upgrading
-  // through npm and its caches. Once git is here, replace it with a real clone --
-  // into a sibling first, so a clone that fails leaves the working copy alone.
-  if (Bun.which("git") && existsSync(join(dest, "cli", "install.ts"))) {
-    const fresh = `${dest}.new`;
-    try {
+    const fresh = `${dest}.new`, old = `${dest}.old`;
+    rmSync(fresh, { recursive: true, force: true });
+    cpSync(here, fresh, { recursive: true, dereference: true, filter: (src) => basename(src) !== "node_modules" });
+    rmSync(old, { recursive: true, force: true });
+    // Windows refuses to move a folder a running kaizen still holds open. The
+    // install stays as it was; say how to finish rather than throwing.
+    try { renameSync(dest, old); } catch {
       rmSync(fresh, { recursive: true, force: true });
-      await Bun.$`git clone --quiet ${REPO_URL} ${fresh}`;
-      rmSync(dest, { recursive: true, force: true });
-      renameSync(fresh, dest);
-      step(`re-cloned ${tilde(dest)} ${c.dim("(git is available now)")}`);
+      step(`kept ${tilde(dest)} ${c.dim("(in use; close kaizen and any dashboard, then run bunx kaizen-agent@latest)")}`);
       return dest;
-    } catch {
-      rmSync(fresh, { recursive: true, force: true });
-      // Fall through to the copy below: an unreachable network is not a reason to
-      // leave the install untouched.
     }
+    renameSync(fresh, dest);
+    step(`replaced ${tilde(dest)} with kaizen ${versionOf(dest)} ${c.dim(`(previous install kept in ${tilde(old)})`)}`);
+    return dest;
   }
+  if (here === dest) return dest;
 
   // Cloning needs an empty directory, and a copy made on a machine that had no git
   // is anything but: installing git later must not turn every run into a fatal.
@@ -906,14 +904,7 @@ function writePointer() {
 
 // ---------------------------------------------------------------- done
 
-if (upgrade) {
-  let version = "";
-  try { version = JSON.parse(readFileSync(join(repo, "package.json"), "utf8")).version; } catch {}
-  console.log(`
-  ${c.bold("Up to date")}${version ? c.dim(`  —  kaizen ${version}`) : ""}
-  ${c.dim("Restart Claude Code to pick up any new slash commands.")}
-`);
-} else {
+{
   console.log(`
   ${c.bold("Next")}
     1  restart Claude Code ${c.dim("— skills load live, slash commands only at session start")}
@@ -948,14 +939,26 @@ async function runUpgrade(repoDir: string) {
       .map((l) => c.dim(l.trim())),
   ];
   if (latest && latest !== after) {
-    lines.push("", c.dim(existsSync(join(repoDir, ".git"))
-      ? `npm publishes ${latest}; this install follows the git clone.`
-      : `npm publishes ${latest} — run: bunx kaizen-agent@${latest}`));
+    lines.push("", c.dim(`npm publishes ${latest} — run: bunx kaizen-agent@${latest}`));
   }
   lines.push("", c.dim("Restart your agent to pick up new slash commands."));
   return lines;
 }
 
+function installDir() { return process.env.KAIZEN_HOME ?? join(home, "kaizen"); }
+
+// A folder someone develops kaizen in must never be replaced by a release: a git
+// checkout KAIZEN_HOME points at, or any checkout holding commits on no remote.
+// ~/kaizen as the installer cloned it is fair game, edits and all (kept in .old).
+async function devCheckout(dir: string) {
+  if (!existsSync(join(dir, ".git"))) return "";
+  if (resolve(dir) !== join(home, "kaizen")) return "a git checkout named by KAIZEN_HOME";
+  try {
+    const ahead = (await Bun.$`git -C ${dir} rev-list --branches --not --remotes`.quiet().text()).trim();
+    return ahead ? "a git checkout with commits not pushed" : "";
+  } catch { return ""; }
+}
+
 function versionOf(dir: string) {
   try { return JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).version as string; }
   catch { return "?"; }

package/package.json

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

package/web/board.html

@@ -37,11 +37,12 @@ select.sel,button.sel{cursor:pointer;appearance:none;padding-right:30px;max-widt
 .combo .menu-pop{left:0;right:auto;top:calc(100% + 4px);width:320px;max-width:calc(100vw - 32px);gap:6px;z-index:9}
 .combo[hidden],.combo .menu-pop[hidden]{display:none}
 .combo input.sel{width:100%;max-width:none}
-#projs{display:flex;flex-direction:column;max-height:300px;overflow-y:auto}
-#projs button{display:block;flex:none;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-#projs button.on{background:var(--hover)}
+#ndc>.sel{width:100%;max-width:none;text-align:left;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+#projs,#nds{display:flex;flex-direction:column;max-height:300px;overflow-y:auto}
+#projs button,#nds button{display:block;flex:none;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+#projs button.on,#nds button.on{background:var(--hover)}
 #shows{display:flex;flex-direction:column;max-height:300px;overflow-y:auto}#shows label{display:flex;gap:8px;align-items:center;padding:6px 10px;font-size:13px;border-radius:var(--r-s);cursor:pointer;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}#shows label:hover{background:var(--hover)}#shows .grp{padding:8px 10px 4px;font-size:11px;color:var(--dim)}
-#projs .grp{padding:8px 10px 4px;font-size:11px;color:var(--dim)}
+#projs .grp,#nds .grp{padding:8px 10px 4px;font-size:11px;color:var(--dim)}
 .sp{flex:1}
 .ib{width:34px;height:34px;display:grid;place-items:center;color:var(--dim);border-radius:var(--r-s);transition:background .12s,color .12s}
 .ib:hover{color:var(--ink);background:var(--hover)}
@@ -629,9 +630,9 @@ function render(){
    s.querySelectorAll("[data-p]").forEach(bt=>bt.onclick=async e=>{e.stopPropagation();if(bt.dataset.p==="cancel"){picking=false;picked.clear();render();return}
     const set=list.filter(c=>picked.has(key(c)));picking=false;picked.clear();for(const c of set)await post("/archive",{dir:c.state,id:c.id});toast("Archived "+set.length);load()});}
   const ul=document.createElement("ul");
-  if(ci===0&&mode==="new"){const f=document.createElement("li");f.className="inl";f.innerHTML=`<input id="newidea" placeholder="What would you like done?"><textarea id="newnotes" placeholder="Notes: links, paths, background (optional)"></textarea><div class="row"><button class="btn ghost" id="nc">Cancel</button><button class="btn pri" id="ns">Add idea</button></div>`;ul.appendChild(f);
-   const inp=f.querySelector("input");draft(inp,"f:new:0");draft(f.querySelector("textarea"),"f:new:1");const save=async()=>{const text=inp.value.trim();if(!text)return;const notes=f.querySelector("textarea").value.trim();mode=null;const r=await post("/inbox",{op:"add",text,notes});if(r.ok)toast("Idea added");load()};
-   f.querySelector("#ns").onclick=save;f.querySelector("#nc").onclick=()=>{mode=null;render()};{const m=mic([inp,f.querySelector("textarea")]);if(m)f.querySelector(".row").prepend(m)}inp.onkeydown=e=>{if(e.key==="Enter")save();if(e.key==="Escape"){mode=null;render()}};setTimeout(()=>inp.focus())}
+  if(ci===0&&mode==="new"){const f=document.createElement("li");f.className="inl";f.innerHTML=`${all?`<div class="combo" id="ndc"><button class="sel" id="newdir" aria-label="Project for this idea" aria-haspopup="listbox" aria-expanded="false"></button><div class="menu-pop" hidden><input class="sel" aria-label="Search projects" placeholder="Search projects…" spellcheck="false" autocomplete="off"><div id="nds" role="listbox"></div></div></div>`:""}<input id="newidea" placeholder="What would you like done?"><textarea id="newnotes" placeholder="Notes: links, paths, background (optional)"></textarea><div class="row"><button class="btn ghost" id="nc">Cancel</button><button class="btn pri" id="ns">Add idea</button></div>`;ul.appendChild(f);
+   const inp=f.querySelector("#newidea");draft(inp,"f:new:0");draft(f.querySelector("textarea"),"f:new:1");const save=async()=>{const text=inp.value.trim();if(!text)return;const notes=f.querySelector("textarea").value.trim();mode=null;const dir=all?newDir:null;const r=await post("/inbox",dir?{op:"add",dir,text,notes}:{op:"add",text,notes});if(r.ok)toast("Idea added");load()};
+   if(all)ideaCombo(f);f.querySelector("#ns").onclick=save;f.querySelector("#nc").onclick=()=>{mode=null;render()};{const m=mic([inp,f.querySelector("textarea")]);if(m)f.querySelector(".row").prepend(m)}inp.onkeydown=e=>{if(e.key==="Enter")save();if(e.key==="Escape"){mode=null;render()}};setTimeout(()=>inp.focus())}
   const shown=unfolded.has(ci)||list.length<=FOLD+1?list:list.slice(0,FOLD);
   shown.forEach(c=>{if(modeKey===key(c)&&mode){ul.appendChild(inlineForm(c));return}const li=document.createElement("li");li.appendChild(card(c));ul.appendChild(li)});
   if(shown.length<list.length){const li=document.createElement("li");li.innerHTML=`<button class="more-btn">Show ${list.length-shown.length} more</button>`;li.firstChild.onclick=()=>{unfolded.add(ci);render()};ul.appendChild(li)}
@@ -1021,6 +1022,18 @@ async function pick(v){
 // The all-projects filter: tick the projects to show; none ticked shows every one. Kept per browser.
 let shown=new Set((()=>{try{return JSON.parse(localStorage.getItem("kz-show"))||[]}catch(e){return[]}})());
 // Known projects, plus any folder a card comes from that is not one (the global inbox).
+// New idea in All projects: the projects being shown, else every one.
+let newDir=null;
+// Same combo as the header's project picker: a button, then a searchable list.
+function ideaCombo(f){const ps=ideaDirs(),btn=f.querySelector("#newdir"),pp=f.querySelector("#ndc .menu-pop"),q=pp.querySelector("input"),box=f.querySelector("#nds");
+ if(!ps.some(p=>p.dir===newDir))newDir=ps[0]?.dir??null;
+ const name=()=>{btn.textContent=(ps.find(p=>p.dir===newDir)||{label:"Choose project"}).label};
+ const draw=()=>{const t=q.value.trim().toLowerCase();box.innerHTML=ps.filter(p=>p.label.toLowerCase().includes(t)).map(p=>`<button type="button" role="option" data-d="${esc(p.dir)}" title="${esc(p.label)}" class="${p.dir===newDir?"on":""}">${esc(p.label)}</button>`).join("")||`<div class="grp">No match</div>`;
+  box.querySelectorAll("button").forEach(b=>b.onclick=()=>{newDir=b.dataset.d;name();open(false);f.querySelector("#newidea").focus()})};
+ const open=on=>{pp.hidden=!on;btn.setAttribute("aria-expanded",on);if(on){q.value="";draw();q.focus()}};
+ btn.onclick=e=>{e.preventDefault();open(pp.hidden)};q.oninput=draw;q.onkeydown=e=>{if(e.key==="Escape"){e.stopPropagation();open(false)}if(e.key==="Enter"){e.preventDefault();box.querySelector("button")?.click()}};
+ name()}
+function ideaDirs(){const sp=showable(),pick=sp.filter(p=>shown.has(p.dir));return pick.length?pick:sp}
 function showable(){const l=[...S.projects];for(const c of S.cards)if(!l.some(p=>p.dir===c.state))l.push({dir:c.state,label:c.where});return l}
 let SP=[];
 function showList(){const q=$("showq").value.trim().toLowerCase();SP=showable();