@chit-run/cli 0.2.0 → 0.3.0

package/dist/chit.js

@@ -9965,10 +9965,10 @@ var init_dist = __esm(() => {
 // ../studio/src/server/audit.ts
 import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function defaultAuditDir2() {
-  const xdg = process.env.XDG_STATE_HOME || join7(homedir5(), ".local", "state");
-  return join7(xdg, "chit", "audit");
+  const xdg = process.env.XDG_STATE_HOME || join8(homedir5(), ".local", "state");
+  return join8(xdg, "chit", "audit");
 }
 function blobRefs(e) {
   switch (e.type) {
@@ -9987,8 +9987,8 @@ function blobRefs(e) {
 function readAuditRun(auditDir, runId, includeBlobs) {
   if (!SAFE_RUN_ID2.test(runId))
     return { kind: "invalid-id" };
-  const runDir = join7(auditDir, "runs", runId);
-  const eventsPath = join7(runDir, "events.jsonl");
+  const runDir = join8(auditDir, "runs", runId);
+  const eventsPath = join8(runDir, "events.jsonl");
   if (!existsSync8(eventsPath))
     return { kind: "not-found" };
   let events2;
@@ -10001,13 +10001,13 @@ function readAuditRun(auditDir, runId, includeBlobs) {
   }
   if (!includeBlobs)
     return { kind: "ok", events: events2 };
-  const blobsDir = join7(runDir, "blobs");
+  const blobsDir = join8(runDir, "blobs");
   const blobs = {};
   for (const e of events2) {
     for (const ref of blobRefs(e)) {
       if (!SHA256_HEX2.test(ref) || ref in blobs)
         continue;
-      const blobPath = join7(blobsDir, ref);
+      const blobPath = join8(blobsDir, ref);
       if (existsSync8(blobPath))
         blobs[ref] = readFileSync9(blobPath, "utf-8");
     }
@@ -10094,7 +10094,7 @@ var init_paths = __esm(() => {
 
 // ../studio/src/server/discovery.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync10 } from "fs";
-import { basename, join as join8, relative } from "path";
+import { basename, join as join9, relative } from "path";
 function safeParseChit(absolutePath) {
   try {
     const raw2 = JSON.parse(readFileSync10(absolutePath, "utf-8"));
@@ -10124,7 +10124,7 @@ function discover(opts) {
       continue;
     if (!entry.name.endsWith(".json"))
       continue;
-    const absolutePath = join8(opts.cwd, entry.name);
+    const absolutePath = join9(opts.cwd, entry.name);
     if (!safeParseChit(absolutePath))
       continue;
     candidates.push({
@@ -10150,7 +10150,7 @@ var init_discovery = __esm(() => {
 
 // ../studio/src/server/docs.ts
 import { createHash as createHash5 } from "crypto";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
 import { basename as basename2, relative as relative2 } from "path";
 function canonicalize(draft) {
   return JSON.stringify(draft, null, "\t");
@@ -10293,7 +10293,7 @@ class DocStore {
       const manifest = parseManifest(draft);
       const graphModel = buildGraphModel(manifest, this.registry, surface);
       const canonicalRaw = canonicalize(draft);
-      writeFileSync5(entry.absolutePath, canonicalRaw, "utf-8");
+      writeFileSync6(entry.absolutePath, canonicalRaw, "utf-8");
       const newHash = hashRaw(canonicalRaw);
       return {
         kind: "saved",
@@ -10363,9 +10363,9 @@ var init_docs = __esm(() => {
 
 // ../studio/src/server/loops.ts
 import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function loopsDir2(cwd) {
-  return join9(cwd, ".chit", "loops");
+  return join10(cwd, ".chit", "loops");
 }
 function summarize(loopId, records) {
   const header = records[0];
@@ -10402,7 +10402,7 @@ function listLoops(cwd) {
 function readLoop2(cwd, loopId) {
   if (!SAFE_LOOP_ID2.test(loopId))
     return { kind: "invalid-id" };
-  const path = join9(loopsDir2(cwd), `${loopId}.jsonl`);
+  const path = join10(loopsDir2(cwd), `${loopId}.jsonl`);
   if (!existsSync10(path))
     return { kind: "not-found" };
   try {
@@ -10456,7 +10456,7 @@ __export(exports_server, {
   PathError: () => PathError
 });
 import { existsSync as existsSync11 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 async function startStudio(opts) {
   const hostname3 = opts.hostname ?? "127.0.0.1";
   const requestedPort = opts.port ?? 0;
@@ -10508,7 +10508,7 @@ function buildApp(opts) {
     const asset = c.req.param("asset");
     if (!CLIENT_ASSETS.has(asset))
       return c.text("not found", 404);
-    const path = join10(opts.clientDistDir, asset);
+    const path = join11(opts.clientDistDir, asset);
     if (!existsSync11(path)) {
       return c.text(`client bundle missing at ${path}. Run: bun run studio:build`, 503);
     }
@@ -10684,7 +10684,7 @@ var init_server = __esm(() => {
   init_loops();
   init_token();
   init_paths();
-  CLIENT_DIST = join10(import.meta.dir, "..", "..", "dist", "client");
+  CLIENT_DIST = join11(import.meta.dir, "..", "..", "dist", "client");
   CLIENT_ASSETS = new Set(["index.js", "index.css"]);
 });
 
@@ -10692,7 +10692,7 @@ var init_server = __esm(() => {
 init_src();
 import { readFileSync as readFileSync13 } from "fs";
 import { homedir as homedir6 } from "os";
-import { basename as basename3, dirname as dirname2, join as join11 } from "path";
+import { basename as basename3, dirname as dirname2, join as join12 } from "path";
 
 // src/adapters/sanitize.ts
 var SENSITIVE_KEY = /key|token|secret|password|auth/i;
@@ -36680,10 +36680,200 @@ ${AUDIT_HELP}`);
   });
 }
 
+// src/cli/doctor.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { mkdirSync as mkdirSync5, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join7 } from "path";
+var defaultIO3 = {
+  out: (s) => process.stdout.write(s),
+  err: (s) => process.stderr.write(s)
+};
+var PROBE_TIMEOUT_MS = 5000;
+function makeDefaultProbe(timeoutMs) {
+  return (cmd, cwd) => {
+    try {
+      const r = Bun.spawnSync(cmd, {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+        stdin: "ignore",
+        timeout: timeoutMs
+      });
+      const output = `${r.stdout?.toString() ?? ""}${r.stderr?.toString() ?? ""}`.trim();
+      return { ok: r.exitCode === 0, output };
+    } catch {
+      return { ok: false, output: "" };
+    }
+  };
+}
+var defaultProbe = makeDefaultProbe(PROBE_TIMEOUT_MS);
+function defaultDeps() {
+  return {
+    probe: defaultProbe,
+    cwd: process.cwd(),
+    auditDir: defaultAuditDir(),
+    loadReg: () => loadRegistry(),
+    bunVersion: process.versions.bun
+  };
+}
+function checkBun(deps) {
+  if (deps.bunVersion) {
+    return { name: "bun", status: "pass", detail: `Bun ${deps.bunVersion}` };
+  }
+  return {
+    name: "bun",
+    status: "fail",
+    detail: "not running under Bun",
+    hint: "chit is Bun-native; install Bun from https://bun.sh and run chit under bun"
+  };
+}
+function checkChitOnPath(deps) {
+  if (deps.probe(["which", "chit"]).ok) {
+    return { name: "chit", status: "pass", detail: "on PATH" };
+  }
+  return {
+    name: "chit",
+    status: "warn",
+    detail: "not on PATH (running locally or via bunx)",
+    hint: "install globally so `chit mcp` resolves: bun install -g @chit-run/cli"
+  };
+}
+function checkGitRepo(deps) {
+  if (deps.probe(["git", "rev-parse", "--is-inside-work-tree"], deps.cwd).ok) {
+    return { name: "git repo", status: "pass", detail: `cwd is a git repo (${deps.cwd})` };
+  }
+  return {
+    name: "git repo",
+    status: "warn",
+    detail: `cwd is not a git repo (${deps.cwd})`,
+    hint: "converge and worktree-based flows expect a git repo; cd into one or git init"
+  };
+}
+function checkAuditDir(deps) {
+  try {
+    mkdirSync5(deps.auditDir, { recursive: true });
+    const probeFile = join7(deps.auditDir, `.doctor-${randomUUID3()}`);
+    writeFileSync5(probeFile, "ok");
+    rmSync5(probeFile);
+    return { name: "audit dir", status: "pass", detail: `writable (${deps.auditDir})` };
+  } catch (e) {
+    return {
+      name: "audit dir",
+      status: "fail",
+      detail: `not writable (${deps.auditDir}): ${e.message}`,
+      hint: "audited runs need this dir; fix its permissions or set XDG_STATE_HOME"
+    };
+  }
+}
+function checkRegistry(deps) {
+  let registry3;
+  try {
+    registry3 = deps.loadReg();
+  } catch (e) {
+    if (e instanceof RegistryError) {
+      return {
+        name: "agents",
+        status: "fail",
+        detail: `invalid agent config: ${e.message}`,
+        hint: "fix or remove ~/.config/chit/agents.json"
+      };
+    }
+    throw e;
+  }
+  const ids = Object.keys(registry3.agents).sort().join(", ");
+  const source = registry3.configPath ? `from ${registry3.configPath}` : "built-in defaults (no agents.json)";
+  return { name: "agents", status: "pass", detail: `${ids || "none"} (${source})` };
+}
+function checkAgentCli(deps, bin) {
+  if (deps.probe([bin, "--version"]).ok) {
+    return { name: bin, status: "pass", detail: "available (auth confirmed on first run)" };
+  }
+  return {
+    name: bin,
+    status: "warn",
+    detail: `not found on PATH`,
+    hint: `install ${bin} and authenticate it; chit calls it as an agent`
+  };
+}
+function checkMcpRegistration(deps) {
+  if (!deps.probe(["claude", "--version"]).ok) {
+    return {
+      name: "mcp register",
+      status: "warn",
+      detail: "skipped (claude CLI not found)",
+      hint: "with claude installed: claude mcp add chit --scope local -- chit mcp"
+    };
+  }
+  if (deps.probe(["claude", "mcp", "get", "chit"]).ok) {
+    return { name: "mcp register", status: "pass", detail: "chit registered as an MCP server" };
+  }
+  return {
+    name: "mcp register",
+    status: "warn",
+    detail: "chit not registered as an MCP server",
+    hint: "register it: claude mcp add chit --scope local -- chit mcp"
+  };
+}
+function runChecks(deps) {
+  return [
+    checkBun(deps),
+    checkChitOnPath(deps),
+    checkAgentCli(deps, "codex"),
+    checkAgentCli(deps, "claude"),
+    checkRegistry(deps),
+    checkMcpRegistration(deps),
+    checkAuditDir(deps),
+    checkGitRepo(deps)
+  ];
+}
+var SHAPE = { pass: "\u25CF", warn: "\u25CB", fail: "\u25C6" };
+function render(checks4, io) {
+  io.out(`chit doctor
+
+`);
+  const width = Math.max(...checks4.map((c) => c.name.length));
+  for (const c of checks4) {
+    io.out(`${SHAPE[c.status]} ${c.name.padEnd(width)}  ${c.detail}
+`);
+    if (c.hint && c.status !== "pass")
+      io.out(`${" ".repeat(width + 4)}\u21B3 ${c.hint}
+`);
+  }
+  const fails = checks4.filter((c) => c.status === "fail").length;
+  const warns = checks4.filter((c) => c.status === "warn").length;
+  io.out(`
+${fails} failure${fails === 1 ? "" : "s"}, ${warns} warning${warns === 1 ? "" : "s"}. Agent authentication is verified on the first real run.
+`);
+}
+var DOCTOR_HELP = `chit doctor
+
+Preflight check for first-time setup. Runs no agents and changes nothing (it only
+writes and removes a probe file in the audit dir to confirm it is writable).
+
+Checks: Bun, the chit binary on PATH, the codex and claude CLIs, the agent
+registry, MCP registration, the audit dir, and whether the cwd is a git repo.
+Agent authentication is not checked here; it is confirmed on the first real run.
+`;
+function runDoctor(argv, io = defaultIO3, deps = defaultDeps()) {
+  if (argv[0] === "-h" || argv[0] === "--help") {
+    io.out(DOCTOR_HELP);
+    return 0;
+  }
+  if (argv.length > 0) {
+    io.err(`chit doctor: unexpected argument ${JSON.stringify(argv[0])}
+
+${DOCTOR_HELP}`);
+    return 2;
+  }
+  const checks4 = runChecks(deps);
+  render(checks4, io);
+  return checks4.some((c) => c.status === "fail") ? 1 : 0;
+}
+
 // src/cli/loop-log.ts
 init_src();
 import { resolve as resolve4 } from "path";
-var defaultIO3 = {
+var defaultIO4 = {
   out: (s) => process.stdout.write(s),
   err: (s) => process.stderr.write(s)
 };
@@ -36798,7 +36988,7 @@ function renderLoop(records) {
 `)}
 `;
 }
-function runLoopLog(argv, io = defaultIO3) {
+function runLoopLog(argv, io = defaultIO4) {
   const verb = argv[0];
   if (!verb || verb === "-h" || verb === "--help") {
     (verb ? io.out : io.err)(LOOP_LOG_HELP);
@@ -37082,6 +37272,7 @@ var HELP = `Usage:
   chit uninstall <name> [--to <dir>]
   chit studio [path]
   chit mcp                                         (run the stdio MCP server)
+  chit doctor                                      (preflight: check setup)
   chit loop-log <start|append|stop|show> [flags]   (chit loop-log --help)
   chit converge --task <text> --scope <id> [options]   (chit converge --help)
   chit audit <list|show> [options]   (chit audit --help)
@@ -37172,6 +37363,8 @@ async function runMain(argv) {
     return runConverge(argv.slice(1));
   if (argv[0] === "audit")
     return runAudit(argv.slice(1));
+  if (argv[0] === "doctor")
+    return runDoctor(argv.slice(1));
   let args;
   try {
     args = parseArgs(argv);
@@ -37423,7 +37616,7 @@ ${HELP}`);
 `);
     return 2;
   }
-  const outputDir = args.outputDir ?? join11(homedir6(), ".claude", "skills");
+  const outputDir = args.outputDir ?? join12(homedir6(), ".claude", "skills");
   const runtimePath = args.runtimePath ?? defaultRuntimePath();
   try {
     const result = installClaudeSkill({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chit-run/cli",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "A thin runtime for multi-agent workflows. Stop being the glue between your agents.",
 	"type": "module",
 	"license": "MIT",