forge-cw 0.1.8 → 0.1.9

package/console/index.html

@@ -4,7 +4,7 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Forge Console</title>
-  <script type="module" crossorigin src="/assets/index-BpkdtYRb.js"></script>
+  <script type="module" crossorigin src="/assets/index-DLM-Ix3c.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-N7b3C-h8.css">
 </head>
 <body>

package/dist/index.js

@@ -814,6 +814,14 @@ var init_cw_types = __esm({
 import { execFile } from "node:child_process";
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 import { join as join3 } from "node:path";
+function envWithoutHost(env = process.env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0 && key !== "CLAUDECODE" && !key.startsWith("CLAUDE_CODE_"))
+      out[key] = value;
+  }
+  return out;
+}
 function envWithoutHarness(env = process.env) {
   const out = {};
   for (const [key, value] of Object.entries(env)) {
@@ -940,8 +948,8 @@ function closeWarningsFor(input) {
   return warnings;
 }
 function createRunner(env, timeoutMs = COMMAND_TIMEOUT_MS) {
-  return (bin, args, cwd) => new Promise((resolve5) => {
-    execFile2(bin, args, { cwd, env, timeout: timeoutMs, maxBuffer: 5 * 1024 * 1024 }, (err, stdout, stderr) => {
+  return (bin, args, cwd, input) => new Promise((resolve5) => {
+    const child = execFile2(bin, args, { cwd, env, timeout: timeoutMs, maxBuffer: 5 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (!err)
         return resolve5({ code: 0, stdout: String(stdout), stderr: String(stderr) });
       const { code } = err;
@@ -949,6 +957,11 @@ function createRunner(env, timeoutMs = COMMAND_TIMEOUT_MS) {
         return resolve5({ code: 127, stdout: "", stderr: "ENOENT" });
       resolve5({ code: typeof code === "number" ? code : 1, stdout: String(stdout), stderr: String(stderr) || err.message });
     });
+    if (input !== void 0) {
+      child.stdin?.on("error", () => {
+      });
+      child.stdin?.end(input);
+    }
   });
 }
 function isCwLink(worktree, porcelainLine) {
@@ -3144,6 +3157,15 @@ var init_pty_manager = __esm({
       get(sessionId) {
         return this.sessions.get(sessionId);
       }
+      // types a line into a live session, then Enter apart, so the agent's prompt takes it as typed and not as a paste
+      typeLine(project, sessionDir, text) {
+        const session = this.sessions.get(this.makeKey(project, sessionDir));
+        if (!session)
+          return false;
+        session.pty.write(text);
+        setTimeout(() => session.pty.write("\r"), 150);
+        return true;
+      }
       // the state tracker reads the screen at the size the user sees it
       resize(sessionId, cols, rows) {
         const session = this.sessions.get(sessionId);
@@ -4074,6 +4096,9 @@ function resolveKiokuBin(pathVar = process.env.PATH, home = homedir5()) {
   const fallback = join13(home, ".local", "bin", "kioku");
   return findOnPath("kioku", pathVar) ?? (existsSync12(fallback) ? fallback : "kioku");
 }
+function rememberPrompt(text) {
+  return `Remember this with kioku: ${text.replace(/\s+/g, " ").trim()}`;
+}
 function parseJson(text) {
   try {
     return JSON.parse(text);
@@ -4093,13 +4118,22 @@ async function mapLimit(items, limit, fn) {
   await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
   return out;
 }
-var KiokuError, NOT_INSTALLED, START_TIMEOUT_MS, CACHE_MS2, ACTIVITY_SINCE, ACTIVITY_LIMIT, PARALLEL, MISSING, brainName, Kioku;
+var PAGE_TYPES, KiokuError, NOT_INSTALLED, START_TIMEOUT_MS, WRITE_TIMEOUT_MS, CACHE_MS2, ACTIVITY_SINCE, ACTIVITY_LIMIT, PARALLEL, MISSING, brainName, Kioku;
 var init_kioku = __esm({
   "../core/dist/kioku.js"() {
     "use strict";
     init_task_review();
+    init_cw_doctor();
     init_cw_install();
     init_output();
+    PAGE_TYPES = {
+      memory: { kind: "memory" },
+      instinct: { kind: "memory", sub: "instinct" },
+      decision: { kind: "knowledge", sub: "decision" },
+      playbook: { kind: "knowledge", sub: "playbook" },
+      context: { kind: "knowledge", sub: "context" },
+      rule: { kind: "rule" }
+    };
     KiokuError = class extends Error {
       status;
       constructor(message, status = 502) {
@@ -4109,6 +4143,7 @@ var init_kioku = __esm({
     };
     NOT_INSTALLED = "kioku is not installed on this machine";
     START_TIMEOUT_MS = 2e4;
+    WRITE_TIMEOUT_MS = 6e4;
     CACHE_MS2 = 5 * 6e4;
     ACTIVITY_SINCE = "2w";
     ACTIVITY_LIMIT = 40;
@@ -4117,6 +4152,7 @@ var init_kioku = __esm({
     brainName = (b) => b.name ?? b.key;
     Kioku = class {
       run;
+      write;
       startTimeoutMs;
       projects;
       now;
@@ -4126,6 +4162,7 @@ var init_kioku = __esm({
       constructor(options = {}) {
         this.binPath = options.bin;
         this.run = options.run ?? createRunner();
+        this.write = options.write ?? createRunner(envWithoutHost(), WRITE_TIMEOUT_MS);
         this.startTimeoutMs = options.startTimeoutMs ?? START_TIMEOUT_MS;
         this.projects = options.projects ?? (() => ({}));
         this.now = options.now ?? Date.now;
@@ -4163,17 +4200,18 @@ var init_kioku = __esm({
         const entries = Object.entries(this.projects()).filter(([, p]) => existsSync12(p.path));
         const readBrain = async (b) => {
           if (!b.onDisk)
-            return { kinds: {}, writes: [] };
+            return { kinds: {}, namespaces: [], writes: [] };
           const [ns, log] = await Promise.all([
             this.json(["namespace", "list", "--brain", b.key], b.folder),
             this.json(["brain", "log", "--since", ACTIVITY_SINCE, "--brain", b.key], b.folder)
           ]);
           const kinds = {};
-          for (const n of ns?.brains?.find((x) => x.brain === brainName(b))?.namespaces ?? []) {
+          const namespaces = ns?.brains?.find((x) => x.brain === brainName(b))?.namespaces ?? [];
+          for (const n of namespaces) {
             for (const [kind, count] of Object.entries(n.pages))
               kinds[kind] = (kinds[kind] ?? 0) + count;
           }
-          return { kinds, writes: log?.writes ?? [] };
+          return { kinds, namespaces: namespaces.map((n) => n.namespace), writes: log?.writes ?? [] };
         };
         const readChain = async (path) => (await this.json(["brain", "list"], path))?.chain ?? [];
         const [perBrain, chains] = await Promise.all([
@@ -4182,12 +4220,13 @@ var init_kioku = __esm({
         ]);
         const activity = perBrain.flatMap((p) => p.writes).sort((x, y) => y.date.localeCompare(x.date));
         const brains = listed.map((b, i) => {
-          const { kinds } = perBrain[i];
+          const { kinds, namespaces } = perBrain[i];
           const name = brainName(b);
           return {
             ...b,
             pages: Object.values(kinds).reduce((sum, n) => sum + n, 0),
             kinds,
+            namespaces,
             touched: activity.find((w) => w.brain === name)?.date ?? null
           };
         });
@@ -4200,6 +4239,47 @@ var init_kioku = __esm({
           activity: activity.slice(0, ACTIVITY_LIMIT).map(({ verb, title, path, date, author, brain }) => ({ verb, title, path, date, author, brain }))
         };
       }
+      // writes through kioku, which validates, commits and pushes a shared brain; Forge never writes a brain's files
+      async save(input) {
+        const type = PAGE_TYPES[input.type];
+        if (!type)
+          throw new KiokuError(`unknown page type ${input.type}`, 400);
+        const brains = this.snapshot ? (await this.snapshot.value).brains : (await this.json(["brain", "list"], homedir5()))?.brains ?? [];
+        const brain = brains.find((b) => b.key === input.brain);
+        if (!brain?.onDisk)
+          throw new KiokuError(`no brain ${input.brain} on this machine`, 404);
+        const args = [
+          "page",
+          "save",
+          "--brain",
+          brain.key,
+          "--kind",
+          type.kind,
+          ...type.sub ? ["--sub", type.sub] : [],
+          "--title",
+          input.title,
+          "--summary",
+          input.summary,
+          "--source",
+          "Forge",
+          ...input.namespace ? ["--namespace", input.namespace] : [],
+          ...input.create ? ["--create"] : [],
+          "--json"
+        ];
+        const result2 = await this.write(this.bin, args, brain.folder, input.body);
+        if (result2.code === 127)
+          throw new KiokuError(NOT_INSTALLED, 404);
+        const out = parseJson(result2.stdout);
+        if (out?.status === "done" && out.path) {
+          this.snapshot = null;
+          return { status: "done", brain: brainName(brain), path: out.path, publication: out.publication ?? null };
+        }
+        if (out?.status === "similar")
+          return { status: "similar", similar: (out.similar ?? []).map(({ brain: brain2, path, title, summary }) => ({ brain: brain2, path, title, summary })) };
+        if (out?.status === "namespace")
+          return { status: "namespace", namespaces: (out.namespaces ?? []).map(({ namespace, summary }) => ({ namespace, summary })) };
+        throw new KiokuError(out?.error?.message ?? (tailOutput(result2.stderr, 1) || "kioku could not save the page"), 400);
+      }
       // one viewer at a time; a second call reuses the running one
       async openViewer() {
         this.viewer ??= this.startViewer();
@@ -4239,7 +4319,7 @@ var init_kioku = __esm({
             const missing = err.code === "ENOENT";
             fail(new KiokuError(missing ? NOT_INSTALLED : err.message, missing ? 404 : 502));
           });
-          child.on("exit", (code) => {
+          child.on("close", (code) => {
             if (this.viewer === started)
               this.viewer = null;
             fail(new KiokuError(tailOutput(stderr, 1) || `kioku web exited with code ${code}`));
@@ -4265,7 +4345,7 @@ var init_kioku = __esm({
 
 // ../core/dist/kioku-routes.js
 import { Hono as Hono4 } from "hono";
-function kiokuRoutes(kioku = new Kioku()) {
+function kiokuRoutes(kioku = new Kioku(), options = {}) {
   const app = new Hono4();
   app.onError((err, c) => {
     if (err instanceof KiokuError)
@@ -4273,6 +4353,29 @@ function kiokuRoutes(kioku = new Kioku()) {
     throw err;
   });
   app.get("/status", async (c) => c.json(await kioku.status(c.req.query("fresh") === "1")));
+  app.post("/pages", async (c) => {
+    const input = await c.req.json().catch(() => ({}));
+    const brain = input.brain?.trim();
+    const title = input.title?.trim();
+    const summary = input.summary?.trim();
+    if (!brain || !input.type || !title || !summary || !input.body?.trim())
+      return c.json({ error: "brain, type, title, summary and body are required" }, 400);
+    const result2 = await kioku.save({ brain, type: input.type, title, summary, body: input.body, namespace: input.namespace?.trim() || void 0, create: input.create === true });
+    return c.json(result2, result2.status === "done" ? 201 : 200);
+  });
+  app.post("/remember", async (c) => {
+    const { project, sessionDir, text } = await c.req.json().catch(() => ({}));
+    const line = text?.trim();
+    if (!project || !sessionDir || !line)
+      return c.json({ error: "project, sessionDir and text are required" }, 400);
+    if (line.length > REMEMBER_MAX)
+      return c.json({ error: `keep it under ${REMEMBER_MAX} characters` }, 400);
+    if (options.canRemember && !options.canRemember(project, sessionDir))
+      return c.json({ error: "only Claude Code sessions have kioku's skill" }, 400);
+    if (!options.type?.(project, sessionDir, rememberPrompt(line)))
+      return c.json({ error: "the session has no live terminal" }, 409);
+    return c.json({ ok: true });
+  });
   app.post("/viewer", async (c) => c.json({ address: await kioku.openViewer() }));
   app.delete("/viewer", (c) => {
     kioku.stopViewer();
@@ -4280,10 +4383,12 @@ function kiokuRoutes(kioku = new Kioku()) {
   });
   return app;
 }
+var REMEMBER_MAX;
 var init_kioku_routes = __esm({
   "../core/dist/kioku-routes.js"() {
     "use strict";
     init_kioku();
+    REMEMBER_MAX = 500;
   }
 });
 
@@ -4332,7 +4437,11 @@ function createForgeServer(options) {
   const terminalWss = createTerminalWss(ptyManager, cwReader, { localOnly, general: generalSessions });
   app.route("/api/liveframe", liveframeRoutes());
   const kioku = new Kioku({ projects: () => cwReader.getProjects() });
-  app.route("/api/kioku", kiokuRoutes(kioku));
+  app.route("/api/kioku", kiokuRoutes(kioku, {
+    type: (project, sessionDir, text) => ptyManager.typeLine(project, sessionDir, text),
+    // kioku's plugin, and so its skill, exists only for Claude Code
+    canRemember: (project, sessionDir) => cwReader.getSession(project, sessionDir)?.harness === "claude"
+  }));
   app.get("/api/cw/session-states", (c) => c.json({ classifier: states.remoteName ?? "local", shadow: states.isShadow, states: states.snapshot() }));
   app.post("/api/cw/terminal/kill", async (c) => {
     const { project, sessionDir } = await c.req.json();
@@ -4787,6 +4896,7 @@ __export(dist_exports, {
   portInUseMessage: () => portInUseMessage,
   probePort: () => probePort,
   quietSqliteWarning: () => quietSqliteWarning,
+  rememberPrompt: () => rememberPrompt,
   resolveKiokuBin: () => resolveKiokuBin,
   resolveListenOptions: () => resolveListenOptions,
   skillRoutes: () => skillRoutes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-cw",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "A visual dashboard for your coding agents on Claude Code, Codex, Pi or OpenCode. Installs CW for you.",
   "license": "MIT",
   "type": "module",