@bunshin-cc/bunshin 0.1.0

package/dist/pi-extension.js

@@ -0,0 +1,148 @@
+// ../../adapters/pi/index.ts
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, renameSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var bundledCli = fileURLToPath(new URL("./bin.js", import.meta.url));
+var cli = process.env.BUNSHIN_BIN ? { command: process.env.BUNSHIN_BIN, args: [] } : existsSync(bundledCli) ? { command: process.execPath, args: [bundledCli] } : { command: "bunshin", args: [] };
+function run(args, cwd, input, timeoutMs = 1e4) {
+  return new Promise((resolve) => {
+    const child = spawn(cli.command, [...cli.args, ...args], { cwd, stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, BUNSHIN_HARNESS: "pi" } });
+    let output = "";
+    let error = "";
+    let done = false;
+    const finish = (value) => {
+      if (!done) {
+        done = true;
+        clearTimeout(timer);
+        resolve(value);
+      }
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish("bunshin: command timed out");
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      output += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      error += chunk;
+    });
+    child.on("error", (err) => finish(`bunshin: ${err.message}`));
+    child.on("close", (code) => finish(code === 0 ? output : error || output));
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(input ? JSON.stringify(input) : void 0);
+  });
+}
+function storeDir(cwd) {
+  let current = cwd;
+  for (; ; ) {
+    if (existsSync(join(current, ".bunshin/config.json"))) return join(current, ".bunshin");
+    const parent = dirname(current);
+    if (parent === current) return join(homedir(), ".bunshin");
+    current = parent;
+  }
+}
+function transcriptLines(messages) {
+  return messages.flatMap((message) => {
+    if (!["user", "assistant", "toolResult"].includes(message.role)) return [];
+    let content = message.content;
+    if (message.role === "toolResult") {
+      content = [{ type: "tool_result", content, is_error: !!message.isError }];
+    } else if (Array.isArray(content)) {
+      content = content.flatMap((block) => {
+        if (block.type === "text") return [block];
+        if (block.type === "toolCall") return [{ type: "tool_use", name: block.name, input: block.arguments }];
+        return [];
+      });
+    }
+    return [{ type: message.role === "assistant" ? "assistant" : "user", message: { content }, timestamp: message.timestamp }];
+  });
+}
+function transcript(ctx) {
+  const directory = join(storeDir(ctx.cwd), "transcripts");
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  const file = join(directory, `pi-${ctx.sessionManager.getSessionId()}.jsonl`);
+  const messages = ctx.sessionManager.getBranch().flatMap((entry) => entry.type === "message" ? [entry.message] : []);
+  const temporary = `${file}.${process.pid}.tmp`;
+  writeFileSync(temporary, transcriptLines(messages).map((line) => JSON.stringify(line)).join("\n") + "\n", { mode: 384 });
+  renameSync(temporary, file);
+  return file;
+}
+async function hook(event, ctx, extra = {}) {
+  const raw = await run(["hook", event], ctx.cwd, {
+    session_id: ctx.sessionManager.getSessionId(),
+    cwd: ctx.cwd,
+    transcript_path: transcript(ctx),
+    ...extra
+  });
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function bunshin(pi) {
+  if (process.env.BUNSHIN_CHILD || process.env.BUNSHIN_DISABLE) return;
+  let timer;
+  const clear = () => {
+    if (timer) clearInterval(timer);
+    timer = void 0;
+  };
+  pi.on("before_agent_start", async (event, ctx) => {
+    if (!existsSync(join(storeDir(ctx.cwd), "config.json"))) {
+      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 = output.hookSpecificOutput?.additionalContext;
+    if (text?.trim()) return { message: { customType: "bunshin-recall", content: text, display: true } };
+  });
+  pi.on("agent_end", async (_event, ctx) => {
+    if (existsSync(join(storeDir(ctx.cwd), "config.json"))) await hook("stop", ctx, { stop_hook_active: false });
+  });
+  pi.on("session_before_compact", async (event, ctx) => {
+    if (existsSync(join(storeDir(ctx.cwd), "config.json"))) 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 });
+  });
+  pi.registerCommand("bunshin", {
+    description: "Bunshin status, recall, lessons, 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"];
+      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);
+    }
+  });
+}
+export {
+  bunshin as default,
+  transcriptLines
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@bunshin-cc/bunshin",
+  "version": "0.1.0",
+  "description": "Shared memory for company AI agents. Connect Codex, Claude Code, or Pi to Bunshin.",
+  "type": "module",
+  "bin": {
+    "bunshin": "dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.127.0",
+    "yaml": "^2.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "esbuild": "^0.28.1",
+    "tsx": "^4.20.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0",
+    "@bunshin/core": "0.1.0"
+  },
+  "license": "MIT",
+  "homepage": "https://bunshin.cc",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yiheinchai/bunshin.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "./dist/pi-extension.js"
+    ]
+  },
+  "keywords": [
+    "pi-package",
+    "codex",
+    "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 ../../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"
+  }
+}