@bunshin-cc/bunshin 0.1.4 → 0.2.1

package/dist/git-remote-bunshin.js

@@ -0,0 +1,350 @@
+#!/usr/bin/env node
+
+// src/v2/gitremote.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { spawnSync } from "node:child_process";
+
+// src/util.ts
+var STOPWORDS = new Set(
+  "a an the and or but if then else of to in on at for from by with without as is are was were be been being do does did done have has had can could should would will shall may might must this that these those it its i we you they he she them us our your my me not no yes so just also very really please now new use using make get set add fix run change update create write need want like about into over under out up down how what when where why which who whom there here some any all each every more most less least than too own same other".split(" ")
+);
+function homeDir() {
+  return process.env.HOME || process.env.USERPROFILE || "/";
+}
+
+// src/v2/gitremote.ts
+var ZERO_SHA = "0".repeat(40);
+var REMOTE_PATH = "/v1/git/repos/";
+function parseRemoteUrl(url) {
+  const raw = url.replace(/^bunshin::/, "").replace(/\.git$/, "").replace(/\/+$/, "");
+  const i = raw.indexOf(REMOTE_PATH);
+  if (i < 0) throw new Error(`not a Bunshin repository address: ${url}`);
+  const apiUrl = raw.slice(0, i);
+  const repo = decodeURIComponent(raw.slice(i + REMOTE_PATH.length));
+  if (!/^https?:\/\//.test(apiUrl) || repo.split("/").length !== 2) throw new Error(`not a Bunshin repository address: ${url}`);
+  return { apiUrl, repo };
+}
+var gitCredentialFile = () => path.join(homeDir(), ".config/bunshin/git-credentials.json");
+function resolveGitKey(apiUrl) {
+  const base = apiUrl.replace(/\/$/, "");
+  if (process.env.BUNSHIN_API_KEY) return process.env.BUNSHIN_API_KEY;
+  try {
+    const all = JSON.parse(fs.readFileSync(gitCredentialFile(), "utf8"));
+    if (all[base]) return all[base];
+  } catch {
+  }
+  const dir = path.join(homeDir(), ".config/bunshin/credentials");
+  let files = [];
+  try {
+    files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  } catch {
+    return void 0;
+  }
+  for (const f of files.sort()) {
+    try {
+      const c = JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"));
+      if (c.apiKey && c.apiUrl?.replace(/\/$/, "") === base) return c.apiKey;
+    } catch {
+    }
+  }
+  return void 0;
+}
+var GitApiError = class extends Error {
+  constructor(status, message, body = null) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+  status;
+  body;
+};
+var GitClient = class {
+  constructor(apiUrl, key) {
+    this.apiUrl = apiUrl;
+    this.key = key;
+  }
+  apiUrl;
+  key;
+  async call(method, route, body, contentType, timeoutMs = 6e4) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+      const send = () => fetch(`${this.apiUrl.replace(/\/$/, "")}/v1/git${route}`, {
+        method,
+        headers: { authorization: `Bearer ${this.key}`, ...contentType ? { "content-type": contentType } : {} },
+        body,
+        signal: ctrl.signal,
+        redirect: "error"
+      });
+      let res;
+      const started = Date.now();
+      try {
+        res = await send();
+      } catch (err) {
+        const cause = err?.cause?.message ?? (err instanceof Error ? err.message : "");
+        if (Date.now() - started < 200 && /other side closed|ECONNRESET|socket hang up/i.test(cause)) res = await send();
+        else throw err;
+      }
+      return res;
+    } catch (err) {
+      throw new GitApiError(0, `${method} ${route}: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async json(method, route, body, okStatuses = []) {
+    const res = await this.call(method, route, body === void 0 ? void 0 : JSON.stringify(body), body === void 0 ? void 0 : "application/json");
+    const text = await res.text();
+    let parsed = null;
+    try {
+      parsed = text ? JSON.parse(text) : {};
+    } catch {
+    }
+    if (!res.ok && !okStatuses.includes(res.status)) {
+      const e = parsed;
+      throw new GitApiError(res.status, e?.message || e?.error || `${method} ${route} \u2192 ${res.status}`, parsed);
+    }
+    return parsed;
+  }
+  repos = () => this.json("GET", "/repos");
+  create = (body) => this.json("POST", "/repos", body);
+  info = (repo) => this.json("GET", `/repos/${repo}`);
+  bundles = (repo, after = 0, data = false) => this.json("GET", `/repos/${repo}/bundles?after=${after}${data ? "&data=1" : ""}`);
+  async push(repo, updates, bundle) {
+    const header = Buffer.from(JSON.stringify({ updates }));
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(header.length);
+    const body = Buffer.concat([len, header, bundle ? Buffer.from(bundle) : Buffer.alloc(0)]);
+    const res = await this.call("POST", `/repos/${repo}/push`, body, "application/octet-stream", 3e5);
+    const text = await res.text();
+    let parsed = null;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+    }
+    if (res.status === 409 && parsed && typeof parsed === "object" && "results" in parsed) return parsed;
+    if (!res.ok) {
+      const e = parsed;
+      throw new GitApiError(res.status, e?.message || e?.error || `push \u2192 ${res.status}`, parsed);
+    }
+    return parsed;
+  }
+};
+function clientFor(address) {
+  const key = resolveGitKey(address.apiUrl);
+  if (!key) throw new Error(`no Bunshin key for ${address.apiUrl}. Run \`bunshin repo login --api-url ${address.apiUrl}\` (or set BUNSHIN_API_KEY).`);
+  return new GitClient(address.apiUrl, key);
+}
+function git(args, opts = {}) {
+  const r = spawnSync("git", args, { encoding: "utf8", input: opts.input, cwd: opts.cwd, maxBuffer: 256 * 1024 * 1024, env: process.env });
+  const ok = r.status === 0;
+  if (!ok && !opts.allowFail) throw new Error(`git ${args.join(" ")}: ${(r.stderr || r.stdout || "").trim()}`);
+  return { ok, out: r.stdout ?? "", err: r.stderr ?? "" };
+}
+function presentObjects(shas, cwd) {
+  if (!shas.length) return /* @__PURE__ */ new Set();
+  const r = git(["cat-file", "--batch-check"], { input: shas.join("\n") + "\n", allowFail: true, cwd });
+  const have = /* @__PURE__ */ new Set();
+  for (const line of r.out.split("\n")) {
+    const m = /^([0-9a-f]{40}) (commit|tree|blob|tag) /.exec(line);
+    if (m) have.add(m[1]);
+  }
+  return have;
+}
+var isAncestor = (a, b) => git(["merge-base", "--is-ancestor", a, b], { allowFail: true }).ok;
+var objectType = (sha) => git(["cat-file", "-t", sha], { allowFail: true }).out.trim();
+async function doList(client, repo, write) {
+  const info = await client.info(repo);
+  for (const r of info.refs) write(`${r.sha} ${r.ref}
+`);
+  if (info.head) write(`@${info.head} HEAD
+`);
+  write("\n");
+}
+async function fetchObjects(client, repo, wanted, log = () => {
+}) {
+  if (wanted.every((s) => presentObjects([s]).has(s))) return;
+  const meta = (await client.bundles(repo)).bundles;
+  const have = presentObjects([...new Set(meta.flatMap((b) => b.tips))]);
+  const needed = meta.filter((b) => b.tips.some((t) => !have.has(t)));
+  if (!needed.length) throw new Error("the server has no bundle with the missing objects");
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "bunshin-git-"));
+  try {
+    let after = needed[0].seq - 1;
+    const want = new Set(needed.map((b) => b.seq));
+    let applied = 0;
+    for (; ; ) {
+      const page = await client.bundles(repo, after, true);
+      for (const b of page.bundles) {
+        after = b.seq;
+        if (!want.has(b.seq) || !b.data) continue;
+        const file = path.join(tmp, `${b.seq}.bundle`);
+        fs.writeFileSync(file, Buffer.from(b.data, "base64"));
+        git(["bundle", "unbundle", file]);
+        fs.rmSync(file, { force: true });
+        applied++;
+      }
+      if (!page.more || !page.bundles.length) break;
+    }
+    log(`bunshin: applied ${applied} bundle${applied === 1 ? "" : "s"}
+`);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+  const still = wanted.filter((s) => !presentObjects([s]).has(s));
+  if (still.length) throw new Error(`objects still missing after fetch: ${still.slice(0, 3).join(", ")}`);
+}
+function parsePushLine(line) {
+  let spec = line.slice("push ".length);
+  const force = spec.startsWith("+");
+  if (force) spec = spec.slice(1);
+  const i = spec.lastIndexOf(":");
+  return { src: spec.slice(0, i), dst: spec.slice(i + 1), force };
+}
+async function pushRefs(client, repo, specs) {
+  const info = await client.info(repo);
+  if (!info.repo.canPush) return specs.map((s) => `error ${s.dst} you may read this repository but not push to it`);
+  const remote = new Map(info.refs.map((r) => [r.ref, r.sha]));
+  const status = /* @__PURE__ */ new Map();
+  const updates = [];
+  for (const s of specs) {
+    const old = remote.get(s.dst) ?? ZERO_SHA;
+    if (!s.src) {
+      if (old === ZERO_SHA) status.set(s.dst, `error ${s.dst} no such ref on the remote`);
+      else updates.push({ ref: s.dst, old, new: ZERO_SHA, ...s.force ? { force: true } : {} });
+      continue;
+    }
+    const r = git(["rev-parse", "--verify", s.src], { allowFail: true });
+    if (!r.ok) {
+      status.set(s.dst, `error ${s.dst} src refspec ${s.src} does not match any`);
+      continue;
+    }
+    const sha = r.out.trim();
+    if (!s.force && old !== ZERO_SHA && old !== sha) {
+      if (s.dst.startsWith("refs/tags/")) {
+        status.set(s.dst, `error ${s.dst} already exists`);
+        continue;
+      }
+      if (!presentObjects([old]).has(old)) {
+        status.set(s.dst, `error ${s.dst} fetch first`);
+        continue;
+      }
+      if (!isAncestor(old, sha)) {
+        status.set(s.dst, `error ${s.dst} non-fast-forward`);
+        continue;
+      }
+    }
+    if (old === sha) {
+      status.set(s.dst, `ok ${s.dst}`);
+      continue;
+    }
+    updates.push({ ref: s.dst, old, new: sha, ...s.force ? { force: true } : {} });
+  }
+  const sends = updates.filter((u) => u.new !== ZERO_SHA);
+  let bundle = null;
+  if (sends.length) {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "bunshin-git-"));
+    const tmpRefs = [];
+    try {
+      sends.forEach((u, i) => {
+        const ref = `refs/bunshin-push/${process.pid}-${i}`;
+        git(["update-ref", ref, u.new]);
+        tmpRefs.push(ref);
+      });
+      const known = presentObjects([...new Set(remote.values())]);
+      const file = path.join(tmp, "push.bundle");
+      const r = git(["bundle", "create", "--quiet", file, ...tmpRefs, ...[...known].map((k) => `^${k}`)], { allowFail: true });
+      if (r.ok) bundle = new Uint8Array(fs.readFileSync(file));
+      else if (!/empty bundle/i.test(r.err)) throw new Error(r.err.trim() || "git bundle create failed");
+      else {
+        for (const u of sends) {
+          const target = objectType(u.new) === "commit" ? u.new : git(["rev-parse", `${u.new}^{commit}`], { allowFail: true }).out.trim();
+          if (![...known].some((k) => k === u.new || target && isAncestor(target, k))) throw new Error(`${u.ref}: objects are missing on the remote`);
+        }
+      }
+    } finally {
+      for (const ref of tmpRefs) git(["update-ref", "-d", ref], { allowFail: true });
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  }
+  if (updates.length) {
+    const res = await client.push(repo, updates, bundle);
+    for (const r of res.results) status.set(r.ref, r.ok ? `ok ${r.ref}` : `error ${r.ref} ${r.error ?? "rejected"}`);
+  }
+  return specs.map((s) => status.get(s.dst) ?? `error ${s.dst} not pushed`);
+}
+async function runRemoteHelper(_remote, url, io = {}) {
+  const write = io.write ?? ((s) => void process.stdout.write(s));
+  const log = io.log ?? ((s) => void process.stderr.write(s));
+  let client;
+  let repo;
+  try {
+    const address = parseRemoteUrl(url);
+    client = clientFor(address);
+    repo = address.repo;
+  } catch (e) {
+    log(`fatal: ${e instanceof Error ? e.message : String(e)}
+`);
+    return 128;
+  }
+  const rl = readline.createInterface({ input: io.input ?? process.stdin, crlfDelay: Infinity, terminal: false });
+  const lines = rl[Symbol.asyncIterator]();
+  const next = async () => {
+    const r = await lines.next();
+    return r.done ? null : String(r.value);
+  };
+  let verbose = 1;
+  try {
+    for (; ; ) {
+      const line = await next();
+      if (line === null || line === "") return 0;
+      if (line === "capabilities") {
+        write("fetch\npush\noption\n\n");
+      } else if (line.startsWith("option ")) {
+        const [, name, value] = line.split(" ");
+        if (name === "verbosity") {
+          verbose = Number(value) || 0;
+          write("ok\n");
+        } else if (name === "progress") write("ok\n");
+        else write("unsupported\n");
+      } else if (line === "list" || line === "list for-push") {
+        await doList(client, repo, write);
+      } else if (line.startsWith("fetch ")) {
+        const wanted = [line.split(" ")[1]];
+        for (let l = await next(); l && l.startsWith("fetch "); l = await next()) wanted.push(l.split(" ")[1]);
+        await fetchObjects(client, repo, wanted, verbose > 1 ? log : () => {
+        });
+        write("\n");
+      } else if (line.startsWith("push ")) {
+        const specs = [parsePushLine(line)];
+        for (let l = await next(); l && l.startsWith("push "); l = await next()) specs.push(parsePushLine(l));
+        for (const s of await pushRefs(client, repo, specs)) write(`${s}
+`);
+        write("\n");
+      } else {
+        log(`fatal: git-remote-bunshin: unsupported command "${line}"
+`);
+        return 1;
+      }
+    }
+  } catch (e) {
+    const status = e instanceof GitApiError ? e.status : 0;
+    const why = status === 404 ? `repository '${repo}' not found in Bunshin, or you cannot read it` : status === 401 ? "the Bunshin key was refused" : e instanceof Error ? e.message : String(e);
+    log(`fatal: ${why}
+`);
+    return 128;
+  }
+}
+
+// src/git-remote-bunshin.ts
+runRemoteHelper(process.argv[2] ?? "", process.argv[3] ?? process.argv[2] ?? "").then(
+  (code) => process.exit(code),
+  (e) => {
+    process.stderr.write(`fatal: ${e instanceof Error ? e.message : String(e)}
+`);
+    process.exit(128);
+  }
+);

package/dist/pi-extension.js

@@ -1,6 +1,6 @@
 // ../../adapters/pi/index.ts
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, renameSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync, renameSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -86,59 +86,59 @@ async function hook(event, ctx, extra = {}) {
 }
 function bunshin(pi) {
   if (process.env.BUNSHIN_CHILD || process.env.BUNSHIN_DISABLE) return;
-  let timer;
-  const clear = () => {
-    if (timer) clearInterval(timer);
-    timer = void 0;
-  };
+  const connected = (ctx) => existsSync(join(storeDir(ctx.cwd), "config.json"));
+  let startContext = "";
+  pi.on("session_start", async (event, ctx) => {
+    if (!connected(ctx)) return;
+    const output = await hook("session-start", ctx, { source: event.reason });
+    startContext = output.hookSpecificOutput?.additionalContext?.trim() ?? "";
+  });
   pi.on("before_agent_start", async (event, ctx) => {
-    if (!existsSync(join(storeDir(ctx.cwd), "config.json"))) {
+    if (!connected(ctx)) {
       if (ctx.hasUI) ctx.ui.notify("Run bunshin setup --harness pi in this project to connect your workspace.", "warning");
       return;
     }
     const output = await hook("user-prompt-submit", ctx, { prompt: event.prompt });
-    clear();
-    const pending = join(storeDir(ctx.cwd), "pending-inject", `${ctx.sessionManager.getSessionId()}.md`);
-    const deadline = Date.now() + 3e4;
-    timer = setInterval(() => {
-      if (Date.now() >= deadline) {
-        clear();
-        return;
-      }
-      if (!existsSync(pending)) return;
-      let text2;
-      try {
-        text2 = readFileSync(pending, "utf8");
-        unlinkSync(pending);
-      } catch {
-        return;
-      }
-      clear();
-      if (text2.trim()) pi.sendMessage({ customType: "bunshin-recall", content: text2, display: true }, { triggerTurn: false, deliverAs: "steer" });
-    }, 250);
-    timer.unref();
+    const text = [startContext, output.hookSpecificOutput?.additionalContext?.trim() ?? ""].filter(Boolean).join("\n\n");
+    startContext = "";
+    if (text) return { message: { customType: "bunshin-recall", content: text, display: true } };
+  });
+  pi.on("tool_call", async (event, ctx) => {
+    if (!["read", "edit", "write"].includes(event.toolName) || !connected(ctx)) return;
+    const output = await hook("pre-tool-use", ctx, { tool_name: event.toolName, tool_input: event.input });
     const text = output.hookSpecificOutput?.additionalContext;
-    if (text?.trim()) return { message: { customType: "bunshin-recall", content: text, display: true } };
+    if (text?.trim()) pi.sendMessage({ customType: "bunshin-push", content: text, display: true }, { triggerTurn: false, deliverAs: "steer" });
   });
   pi.on("agent_end", async (_event, ctx) => {
-    if (existsSync(join(storeDir(ctx.cwd), "config.json"))) await hook("stop", ctx, { stop_hook_active: false });
+    if (!connected(ctx)) return;
+    const output = await hook("stop", ctx, { stop_hook_active: false });
+    if (output.systemMessage && ctx.hasUI) ctx.ui.notify(output.systemMessage.replace("/learn", "/learn (bunshin learn)"), "info");
   });
   pi.on("session_before_compact", async (event, ctx) => {
-    if (existsSync(join(storeDir(ctx.cwd), "config.json"))) await hook("pre-compact", ctx, { trigger: event.reason });
+    if (connected(ctx)) await hook("pre-compact", ctx, { trigger: event.reason });
   });
   pi.on("session_shutdown", async (event, ctx) => {
-    clear();
-    if (existsSync(join(storeDir(ctx.cwd), "config.json"))) await hook("session-end", ctx, { reason: event.reason });
+    if (connected(ctx)) await hook("session-end", ctx, { reason: event.reason });
   });
+  const tokens = (input) => [...input.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)].map((match) => match[1] ?? match[2] ?? match[3]);
+  const show = (output, ctx) => {
+    if (ctx.hasUI) ctx.ui.notify(output.trim() || "Done.", "info");
+    else process.stdout.write(output);
+  };
   pi.registerCommand("bunshin", {
-    description: "Bunshin status, recall, lessons, or sync",
+    description: "Bunshin status, recall, load, review, questions, or sync",
     handler: async (input, ctx) => {
-      const tokens = [...input.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)].map((match) => match[1] ?? match[2] ?? match[3]);
-      const args = tokens.length ? tokens : ["status"];
+      const args = tokens(input);
+      if (!args.length) args.push("status");
       if (args[0] === "recall" && args.length > 1) args.splice(1, args.length - 1, args.slice(1).join(" "));
-      const output = await run(args, ctx.cwd, void 0, 6e4);
-      if (ctx.hasUI) ctx.ui.notify(output.trim() || "Done.", "info");
-      else process.stdout.write(output);
+      show(await run(args, ctx.cwd, void 0, 6e4), ctx);
+    }
+  });
+  pi.registerCommand("learn", {
+    description: "Capture what this session learned into the Bunshin library now",
+    handler: async (input, ctx) => {
+      transcript(ctx);
+      show(await run(["learn", "--session", ctx.sessionManager.getSessionId(), ...input.trim() ? [input.trim()] : []], ctx.cwd, void 0, 18e4), ctx);
     }
   });
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@bunshin-cc/bunshin",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "Shared memory for company AI agents. Connect Codex, Claude Code, or Pi to Bunshin.",
   "type": "module",
   "bin": {
-    "bunshin": "dist/bin.js"
+    "bunshin": "dist/bin.js",
+    "git-remote-bunshin": "dist/git-remote-bunshin.js"
   },
   "files": [
     "dist",
@@ -14,13 +15,6 @@
   "engines": {
     "node": ">=20"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.json --noEmit && esbuild src/bin.ts --bundle --platform=node --target=node20 --format=esm --external:@anthropic-ai/sdk --external:yaml --outfile=dist/bin.js && esbuild ../../adapters/pi/index.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/pi-extension.js",
-    "dev": "tsx src/bin.ts",
-    "test": "vitest run",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "prepack": "pnpm build"
-  },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.127.0",
     "yaml": "^2.8.0"
@@ -31,7 +25,7 @@
     "tsx": "^4.20.0",
     "typescript": "^5.8.0",
     "vitest": "^3.2.0",
-    "@bunshin/core": "workspace:*"
+    "@bunshin/core": "0.1.0"
   },
   "license": "MIT",
   "homepage": "https://bunshin.cc",
@@ -54,5 +48,11 @@
     "claude-code",
     "memory",
     "knowledge"
-  ]
-}
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json --noEmit && esbuild src/bin.ts --bundle --platform=node --target=node20 --format=esm --external:@anthropic-ai/sdk --external:yaml --outfile=dist/bin.js && esbuild src/git-remote-bunshin.ts --bundle --platform=node --target=node20 --format=esm --outfile=dist/git-remote-bunshin.js && esbuild ../../adapters/pi/index.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/pi-extension.js",
+    "dev": "tsx src/bin.ts",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}