kaizen-agent 0.3.0 → 0.4.0

package/README.md

@@ -29,8 +29,12 @@ cd ~/kaizen && bun run cli/install.ts
 
 Flags, either way:
 
-Run interactively with no flags and it asks where to install, as an arrow-key
-choice; piped or scripted runs take the global install without asking.
+Run interactively and it walks you through it: where to install, and whether to set
+up the repository you are standing in. Piped or scripted runs take the global
+install and ask nothing.
+
+If `bunx` gives you an older version, it is serving its cache — clear it with
+`rm -rf /tmp/bunx-*-kaizen-agent*`.
 
 | Flag | Effect |
 |---|---|
@@ -39,6 +43,8 @@ choice; piped or scripted runs take the global install without asking.
 | `--project` | Install into `.claude/` in the current directory only |
 | `--check` | Report what is linked and exit non-zero if anything is missing |
 | `--force` | Replace a real file sitting where a link belongs |
+| `--yes` | Take every default, ask nothing |
+| `--verbose` | List every link instead of a one-line summary |
 
 It is idempotent — an already-correct link is left alone, so re-running after a
 `git pull` is safe and reports what changed.

package/cli/install.ts

@@ -1,15 +1,38 @@
 #!/usr/bin/env bun
-import { symlinkSync, mkdirSync, readdirSync, lstatSync, readlinkSync, unlinkSync, existsSync } from "node:fs";
+import {
+  symlinkSync, mkdirSync, readdirSync, lstatSync, readlinkSync, unlinkSync,
+  existsSync, copyFileSync, readFileSync, appendFileSync,
+} from "node:fs";
 import { join, dirname, basename } from "node:path";
 import { homedir } from "node:os";
 
 const home = homedir();
 const REPO_URL = "https://github.com/hfadhlullah/kaizen.git";
+const args = new Set(Bun.argv.slice(2));
+const check = args.has("--check");
+const force = args.has("--force");
+const verbose = args.has("--verbose");
+const interactive = process.stdin.isTTY && !check && !args.has("--yes");
+
+const c = {
+  dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s: string) => `\x1b[1m${s}\x1b[0m`,
+  cyan: (s: string) => `\x1b[36m${s}\x1b[0m`,
+  green: (s: string) => `\x1b[32m${s}\x1b[0m`,
+};
+
+if (!check) {
+  console.log(`
+  ${c.bold("kaizen")} ${c.dim("改善")}
+  ${c.dim("plan  ->  approve  ->  build  ->  review  ->  fix")}
+`);
+}
 
-// Links point back at the clone, so the clone has to be somewhere permanent. Run
-// from a git checkout and that checkout is it; run through `bunx`, and the package
-// lives in a temp cache that gets evicted, so clone to KAIZEN_HOME first.
 const repo = await resolveRepo();
+const root = await chooseRoot();
+const base = join(root, ".claude");
+
+// ---------------------------------------------------------------- repo
 
 async function resolveRepo() {
   const here = dirname(import.meta.dir);
@@ -17,29 +40,32 @@ async function resolveRepo() {
 
   const dest = process.env.KAIZEN_HOME ?? join(home, "kaizen");
   if (existsSync(join(dest, ".git"))) {
-    // A pull can refuse for reasons that have nothing to do with linking — local
-    // edits, a detached head, no network. Linking the checkout that is already
-    // there still works, so say what happened and carry on rather than failing
-    // the install over it.
+    // 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 ${dest} pull --ff-only`.quiet();
-      console.log(`update ${dest}`);
+      step(`updated ${tilde(dest)}`);
     } catch {
-      console.log(`skip   ${dest} — could not pull, linking what is there`);
+      step(`kept ${tilde(dest)} ${c.dim("(could not pull)")}`);
     }
     return dest;
   }
-  console.log(`clone  ${REPO_URL} -> ${dest}`);
+  step(`cloning into ${tilde(dest)}`);
   await Bun.$`git clone --quiet ${REPO_URL} ${dest}`;
   return dest;
 }
 
-// Each entry: source path in the repo -> directory it is linked into.
-const links = [
-  ...["kaizen", "kaizen-help"].map((n) => [join(repo, "skills", n), "skills"] as const),
-  ...dirEntries("agents").map((f) => [f, "agents"] as const),
-  ...dirEntries("commands").map((f) => [f, "commands"] as const),
-];
+async function chooseRoot() {
+  if (args.has("--project")) return process.cwd();
+  if (args.has("--global") || !interactive) return home;
+  return select("Install kaizen for", [
+    { label: "Every project", hint: tilde(join(home, ".claude")), value: home },
+    { label: "This project only", hint: join(".claude"), value: process.cwd() },
+  ]);
+}
+
+// ---------------------------------------------------------------- linking
 
 function dirEntries(sub: string) {
   return readdirSync(join(repo, sub))
@@ -47,6 +73,12 @@ function dirEntries(sub: string) {
     .map((f) => join(repo, sub, f));
 }
 
+const links = [
+  ...["kaizen", "kaizen-help"].map((n) => [join(repo, "skills", n), "skills"] as const),
+  ...dirEntries("agents").map((f) => [f, "agents"] as const),
+  ...dirEntries("commands").map((f) => [f, "commands"] as const),
+];
+
 function linkState(src: string, dest: string) {
   try {
     const st = lstatSync(dest);
@@ -57,62 +89,131 @@ function linkState(src: string, dest: string) {
   }
 }
 
-const args = new Set(Bun.argv.slice(2));
-const check = args.has("--check");
-const force = args.has("--force");
-const base = join(await chooseRoot(), ".claude");
+let blocked = 0, wrote = 0, already = 0;
+for (const [src, sub] of links) {
+  const dir = join(base, sub);
+  const dest = join(dir, basename(src));
+  const state = linkState(src, dest);
+  const name = `${sub}/${basename(src)}`;
 
-async function chooseRoot() {
-  if (args.has("--project")) return process.cwd();
-  if (args.has("--global") || check) return home;
+  if (check) {
+    if (state !== "linked") blocked++;
+    console.log(`${state === "linked" ? "ok  " : "MISS"} ${name}${state === "linked" ? "" : ` (${state})`}`);
+    continue;
+  }
+  if (state === "linked") { already++; if (verbose) console.log(c.dim(`  ok    ${name}`)); continue; }
+  if (state === "occupied" && !force) {
+    console.log(`  ${c.bold("skip")}  ${name} — real file present, use --force`);
+    blocked++;
+    continue;
+  }
+  mkdirSync(dir, { recursive: true });
+  if (state !== "missing") unlinkSync(dest);
+  symlinkSync(src, dest);
+  wrote++;
+  if (verbose) console.log(c.dim(`  link  ${name}`));
+}
 
-  // Only ask when there is someone to answer. Piped, scripted, or CI runs take the
-  // global install silently rather than hanging on a prompt nobody sees.
-  if (!process.stdin.isTTY) return home;
+if (check) {
+  console.log(blocked ? `\n${blocked} link(s) missing — run: bunx kaizen-agent` : "\nall linked");
+  process.exit(blocked ? 1 : 0);
+}
 
-  const choice = await select("Install where?", [
-    { label: "Every project", hint: join(home, ".claude"), value: home },
-    { label: "This one only", hint: join(process.cwd(), ".claude"), value: process.cwd() },
-  ]);
-  return choice;
+step(
+  wrote && already ? `linked ${wrote} new, ${already} already in place`
+  : wrote ? `linked ${wrote} skills, agents, and commands into ${tilde(base)}`
+  : `already installed in ${tilde(base)} ${c.dim("(nothing to change)")}`,
+);
+
+// ---------------------------------------------------------------- repo setup
+
+const inGitRepo = existsSync(join(process.cwd(), ".git"));
+const kaizenDir = join(process.cwd(), ".kaizen");
+
+if (inGitRepo && !existsSync(kaizenDir)) {
+  const now = interactive
+    ? await select(`Set up ${basename(process.cwd())}/ for kaizen now`, [
+        { label: "Yes", hint: "writes .kaizen/ — spec, config, gitignore entry", value: true },
+        { label: "Not now", hint: "run /kaizen-init in the repo later", value: false },
+      ])
+    : false;
+  if (now) initRepo();
+} else if (existsSync(kaizenDir)) {
+  step(`${basename(process.cwd())}/.kaizen already set up`);
 }
 
-// Arrow-key picker. Raw mode delivers keys unbuffered, one escape sequence at a
-// time; the alternative is a dependency for forty lines of escape codes.
+function initRepo() {
+  mkdirSync(kaizenDir, { recursive: true });
+  for (const f of readdirSync(join(repo, "skills/kaizen")).filter((f) => f.startsWith("spec"))) {
+    copyFileSync(join(repo, "skills/kaizen", f), join(kaizenDir, f));
+  }
+  copyFileSync(join(repo, "skills/kaizen/config.default.yml"), join(kaizenDir, "config.yml"));
+
+  // Run state is local; the workflow itself is shared, so those files stay tracked.
+  const rules = ".kaizen/*\n!.kaizen/spec*.md\n!.kaizen/config.yml\n";
+  const gi = join(process.cwd(), ".gitignore");
+  const current = existsSync(gi) ? readFileSync(gi, "utf8") : "";
+  if (!current.includes(".kaizen/*")) {
+    appendFileSync(gi, (current && !current.endsWith("\n") ? "\n" : "") + "\n# kaizen run state\n" + rules);
+  }
+  step("wrote .kaizen/ and the gitignore entry");
+}
+
+// ---------------------------------------------------------------- done
+
+console.log(`
+  ${c.bold("Next")}
+    1  restart Claude Code ${c.dim("— skills load live, slash commands only at session start")}
+    2  ${c.cyan("/kaizen-init")} ${c.dim("in any repo you want to use it on")}
+    3  ${c.cyan("/kaizen-plan <what you want built>")}
+
+  ${c.dim("/kaizen-help lists every command.")}
+`);
+if (blocked) process.exit(1);
+
+// ---------------------------------------------------------------- helpers
+
+function step(msg: string) { console.log(`  ${c.green("+")} ${msg}`); }
+function tilde(p: string) { return p.startsWith(home) ? "~" + p.slice(home.length) : p; }
+
+// Arrow-key picker. Raw mode delivers keys unbuffered; the alternative is a
+// dependency for two options and forty lines of escape codes.
 async function select<T>(question: string, options: { label: string; hint: string; value: T }[]) {
   const { stdin, stdout } = process;
   let active = 0;
 
   const draw = (first: boolean) => {
-    if (!first) stdout.write(`\x1b[${options.length}A`); // back up over the list
+    if (!first) stdout.write(`\x1b[${options.length}A`);
     for (const [i, o] of options.entries()) {
       const on = i === active;
       stdout.write(
-        `\x1b[2K  ${on ? "\x1b[36m>\x1b[0m" : " "} ${on ? "\x1b[1m" : "\x1b[2m"}${o.label}\x1b[0m` +
-          `  \x1b[2m${o.hint}\x1b[0m\n`,
+        `\x1b[2K    ${on ? c.cyan(">") : " "} ${on ? c.bold(o.label) : c.dim(o.label)}` +
+          `  ${c.dim(o.hint)}\n`,
       );
     }
   };
 
-  stdout.write(`\n\x1b[1m${question}\x1b[0m  \x1b[2m(arrows, enter)\x1b[0m\n`);
-  stdout.write("\x1b[?25l"); // hide cursor
+  stdout.write(`\n  ${c.bold(question)}  ${c.dim("(arrows, enter)")}\n`);
+  stdout.write("\x1b[?25l");
   draw(true);
   stdin.setRawMode(true);
   stdin.resume();
 
-  try {
-    outer: for await (const chunk of stdin) {
+  // Read via events rather than `for await`: breaking out of an async iterator
+  // destroys stdin, and a second prompt would then have no stream to read.
+  await new Promise<void>((resolve) => {
+    const onData = (chunk: Buffer) => {
       // A chunk can hold more than one keypress -- an arrow and the enter behind
       // it arrive together when input is piped -- so walk it rather than
       // comparing the whole thing to one key.
       const keys = chunk.toString();
       for (let i = 0; i < keys.length; i++) {
         const rest = keys.slice(i);
-        if (rest.startsWith("\x03")) {                  // ctrl-c
-          stdout.write("\ncancelled\n");
-          process.exit(130);
+        if (rest.startsWith("\x03")) { stdout.write("\ncancelled\n"); process.exit(130); }
+        if (rest.startsWith("\r") || rest.startsWith("\n")) {
+          stdin.off("data", onData);
+          return resolve();
         }
-        if (rest.startsWith("\r") || rest.startsWith("\n")) break outer;
         if (rest.startsWith("\x1b[A") || rest.startsWith("\x1b[B")) {
           active = rest[2] === "A"
             ? (active - 1 + options.length) % options.length
@@ -123,42 +224,12 @@ async function select<T>(question: string, options: { label: string; hint: strin
         else continue;
         draw(false);
       }
-    }
-  } finally {
-    stdin.setRawMode(false);
-    stdin.pause();
-    stdout.write("\x1b[?25h\n"); // show cursor again
-  }
-  return options[active]!.value;
-}
+    };
+    stdin.on("data", onData);
+  });
 
-let bad = 0;
-for (const [src, sub] of links) {
-  const dir = join(base, sub);
-  const dest = join(dir, basename(src));
-  const state = linkState(src, dest);
-
-  if (check) {
-    if (state !== "linked") bad++;
-    console.log(`${state === "linked" ? "ok  " : "MISS"} ${sub}/${basename(src)}${state === "linked" ? "" : ` (${state})`}`);
-    continue;
-  }
-  if (state === "linked") { console.log(`ok   ${sub}/${basename(src)}`); continue; }
-  if (state === "occupied" && !force) {
-    console.log(`skip ${sub}/${basename(src)} — real file present, use --force`);
-    bad++;
-    continue;
-  }
-  mkdirSync(dir, { recursive: true });
-  if (state !== "missing") unlinkSync(dest);
-  symlinkSync(src, dest);
-  console.log(`link ${sub}/${basename(src)}`);
-}
-
-if (check) {
-  console.log(bad ? `\n${bad} link(s) missing — run: bun run ${repo}/cli/install.ts` : "\nall linked");
-  process.exit(bad ? 1 : 0);
+  stdin.setRawMode(false);
+  stdin.pause();
+  stdout.write("\x1b[?25h");
+  return options[active]!.value;
 }
-console.log(`\nInstalled into ${base}. Restart Claude Code: skills load live, slash commands only on session start.`);
-console.log(`Then, in a repository you want to use it on: /kaizen-init`);
-if (bad) process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Staged AI development workflow: plan, human approval, implement, independent review, bounded fix loop.",
   "type": "module",
   "bin": {