forge-cw 0.1.9 → 0.1.11

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-DLM-Ix3c.js"></script>
+  <script type="module" crossorigin src="/assets/index-5ifgSOpU.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-N7b3C-h8.css">
 </head>
 <body>

package/cw/.bundle.json

@@ -1,4 +1,4 @@
 {
   "repo": "https://github.com/avarajar/cw.git",
-  "ref": "2411230d86ea745e5e08ac64993e35f8f107e69d"
+  "ref": "4fa95d752c8ae5301b807f1b025461306b699071"
 }

package/cw/cw

@@ -2991,19 +2991,23 @@ $(cat "$wf_file")"
             fi
         fi
 
-        # ── Account work context (init) ──────────────────────────────────
-        local acct_init_tpl="$(_account_root "$account")/templates/work_init.md"
-        if [[ -f "$acct_init_tpl" ]]; then
-            local acct_ctx
-            acct_ctx=$(cat "$acct_init_tpl")
-            acct_ctx="${acct_ctx//\$\{task\}/$task}"
-            acct_ctx="${acct_ctx//\$\{project\}/$name}"
-            acct_ctx="${acct_ctx//\$\{branch\}/$task}"
+        # ── Work context (init): global first, then the account's ────────
+        local init_tpl init_ctx
+        for init_tpl in "$CW_HOME/templates/work_init.md" "$(_account_root "$account")/templates/work_init.md"; do
+            [[ -f "$init_tpl" ]] || continue
+            init_ctx=$(cat "$init_tpl")
+            init_ctx="${init_ctx//\$\{task\}/$task}"
+            init_ctx="${init_ctx//\$\{project\}/$name}"
+            init_ctx="${init_ctx//\$\{branch\}/$task}"
             init_prompt="$init_prompt
 
-$acct_ctx"
-            _dim "  Account context: $account"
-        fi
+$init_ctx"
+            if [[ "$init_tpl" == "$CW_HOME/templates/work_init.md" ]]; then
+                _dim "  Work context: global"
+            else
+                _dim "  Account context: $account"
+            fi
+        done
 
         # Exclude .tasks from git (but DON'T pre-create the task dir — worktree needs it empty)
         mkdir -p "$path/.tasks"

package/dist/index.js

@@ -656,7 +656,7 @@ var init_cw_reader = __esm({
         if (!match)
           return { frontmatter: {}, body: content };
         const rawBlock = match[1];
-        const body = match[2];
+        const body2 = match[2];
         const frontmatter = {};
         let inMetadata = false;
         const metadataObj = {};
@@ -680,7 +680,7 @@ var init_cw_reader = __esm({
         }
         if (Object.keys(metadataObj).length > 0)
           frontmatter["metadata"] = metadataObj;
-        return { frontmatter, body };
+        return { frontmatter, body: body2 };
       }
       // directory whose skills/ holds a scope's skills; an unregistered project ref is used as a path
       getSkillConfigDir(scope, scopeRef) {
@@ -742,7 +742,7 @@ var init_cw_reader = __esm({
           return null;
         try {
           const content = readFileSync2(skillMd, "utf-8");
-          const { frontmatter, body } = this.parseFrontmatter(content);
+          const { frontmatter, body: body2 } = this.parseFrontmatter(content);
           const references = [];
           const refsDir = join2(dir, "references");
           if (existsSync2(refsDir)) {
@@ -755,7 +755,7 @@ var init_cw_reader = __esm({
               }
             }
           }
-          return { name: String(frontmatter["name"] ?? name), scope, scopeRef, frontmatter, body, references };
+          return { name: String(frontmatter["name"] ?? name), scope, scopeRef, frontmatter, body: body2, references };
         } catch {
           return null;
         }
@@ -1311,10 +1311,10 @@ async function probeClaudeUsage(configDir, deps = {}) {
     });
     if (response.status === 401 || response.status === 403)
       return { state: "expired", windows: [], detail: "Claude rejected the stored token" };
-    const body = await response.text();
+    const body2 = await response.text();
     if (!response.ok)
       return { state: "error", windows: [], detail: `Claude answered ${response.status}` };
-    return { state: "ok", windows: mapClaudeUsage(JSON.parse(body)), detail: null };
+    return { state: "ok", windows: mapClaudeUsage(JSON.parse(body2)), detail: null };
   } catch (err) {
     return { state: "error", windows: [], detail: err instanceof Error ? err.message : String(err) };
   }
@@ -1539,9 +1539,9 @@ var init_login_manager = __esm({
       cwBin;
       spawn;
       entries = /* @__PURE__ */ new Map();
-      constructor(cwBin, spawn8 = spawnInPty) {
+      constructor(cwBin, spawn9 = spawnInPty) {
         this.cwBin = cwBin;
-        this.spawn = spawn8;
+        this.spawn = spawn9;
       }
       start(account, harness) {
         const key = `${account}::${harness}`;
@@ -1825,14 +1825,14 @@ function cwRoutes(reader, options = {}) {
     return c.json(reader.getAccounts());
   });
   app.post("/accounts", async (c) => {
-    const body = await c.req.json();
-    const harness = body.harness || void 0;
-    const provider = body.provider || void 0;
-    const model = body.model || void 0;
-    if (!body.name || !body.name.trim()) {
+    const body2 = await c.req.json();
+    const harness = body2.harness || void 0;
+    const provider = body2.provider || void 0;
+    const model = body2.model || void 0;
+    if (!body2.name || !body2.name.trim()) {
       return c.json({ ok: false, error: "Account name is required" }, 400);
     }
-    const trimmed = body.name.trim();
+    const trimmed = body2.name.trim();
     if (!ACCOUNT_NAME_RE.test(trimmed)) {
       return c.json({ ok: false, error: "Name must start with a letter or number and contain only letters, numbers, hyphens, and underscores (max 64 chars)" }, 400);
     }
@@ -2896,11 +2896,11 @@ function skillRoutes(reader, options = {}) {
   });
   app.get("/marketplaces", (c) => c.json(listMarketplaces(reader)));
   app.post("/marketplaces", async (c) => {
-    const body = await c.req.json().catch(() => ({}));
-    const source = body.source?.trim() ?? "";
+    const body2 = await c.req.json().catch(() => ({}));
+    const source = body2.source?.trim() ?? "";
     if (!source || source.startsWith("-"))
       return c.json({ error: "A GitHub repo, URL or path is required" }, 400);
-    const account = knownAccount(body.account);
+    const account = knownAccount(body2.account);
     if (!account)
       return c.json({ error: "Unknown account" }, 404);
     const failed = await runClaude("account", account, [["plugin", "marketplace", "add", source]], `Failed to add ${source}`);
@@ -2909,11 +2909,11 @@ function skillRoutes(reader, options = {}) {
     return c.json({ ok: true });
   });
   app.post("/plugins/install", async (c) => {
-    const body = await c.req.json().catch(() => ({}));
-    const id = body.id ?? "";
+    const body2 = await c.req.json().catch(() => ({}));
+    const id = body2.id ?? "";
     if (!PLUGIN_ID_RE.test(id))
       return c.json({ error: "Invalid plugin id" }, 400);
-    const account = knownAccount(body.account);
+    const account = knownAccount(body2.account);
     if (!account)
       return c.json({ error: "Unknown account" }, 404);
     const { name, marketplace } = splitPluginId(id);
@@ -3259,7 +3259,7 @@ function createJevClassifier({ apiKey, model = "jev-latest", timeoutMs = 3e3, fe
     async classify(input) {
       if (input.exitCode !== null)
         return { state: "exited", confidence: 1, source: "jev" };
-      const body = {
+      const body2 = {
         model,
         state: { harness: input.harness, seconds_since_last_output: Math.round(input.quietMs / 1e3), screen: jevScreen(input.screen ?? input.text) },
         questions: {
@@ -3273,7 +3273,7 @@ function createJevClassifier({ apiKey, model = "jev-latest", timeoutMs = 3e3, fe
       const res = await fetch2(JEV_URL, {
         method: "POST",
         headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-        body: JSON.stringify(body),
+        body: JSON.stringify(body2),
         signal: AbortSignal.timeout(timeoutMs)
       });
       if (!res.ok)
@@ -4092,6 +4092,11 @@ import { existsSync as existsSync12 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { join as join13 } from "node:path";
 import { createInterface } from "node:readline";
+import * as pty3 from "node-pty";
+function assertRepo(repo, what) {
+  if (!REPO.test(repo))
+    throw new KiokuError(`${what} is named as owner/repo, not "${repo}"`, 400);
+}
 function resolveKiokuBin(pathVar = process.env.PATH, home = homedir5()) {
   const fallback = join13(home, ".local", "bin", "kioku");
   return findOnPath("kioku", pathVar) ?? (existsSync12(fallback) ? fallback : "kioku");
@@ -4099,6 +4104,26 @@ function resolveKiokuBin(pathVar = process.env.PATH, home = homedir5()) {
 function rememberPrompt(text) {
   return `Remember this with kioku: ${text.replace(/\s+/g, " ").trim()}`;
 }
+function createTerminalRunner(env, timeoutMs) {
+  return (bin, args, cwd) => new Promise((resolve5) => {
+    let proc;
+    try {
+      proc = pty3.spawn(bin, args, { name: "xterm-256color", cols: 400, rows: 40, cwd, env });
+    } catch {
+      return resolve5({ code: 127, stdout: "", stderr: "ENOENT" });
+    }
+    let output = "";
+    const timer = setTimeout(() => proc.kill(), timeoutMs);
+    proc.onData((data) => {
+      output = (output + data).slice(-64 * 1024);
+    });
+    proc.onExit(({ exitCode }) => {
+      clearTimeout(timer);
+      const json = stripAnsi(output).split(/\r?\n/).reverse().map((line) => line.slice(line.indexOf("{")).trim()).find((line) => parseJson(line) !== null);
+      resolve5({ code: exitCode, stdout: json ?? "", stderr: output });
+    });
+  });
+}
 function parseJson(text) {
   try {
     return JSON.parse(text);
@@ -4118,7 +4143,7 @@ async function mapLimit(items, limit, fn) {
   await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
   return out;
 }
-var PAGE_TYPES, KiokuError, NOT_INSTALLED, START_TIMEOUT_MS, WRITE_TIMEOUT_MS, CACHE_MS2, ACTIVITY_SINCE, ACTIVITY_LIMIT, PARALLEL, MISSING, brainName, Kioku;
+var PAGE_TYPES, KiokuError, NOT_INSTALLED, START_TIMEOUT_MS, WRITE_TIMEOUT_MS, PUBLISH_TIMEOUT_MS, CACHE_MS2, ACTIVITY_SINCE, ACTIVITY_LIMIT, PARALLEL, TIERS, REPO, AREA, LANGUAGE, MISSING, brainName, Kioku;
 var init_kioku = __esm({
   "../core/dist/kioku.js"() {
     "use strict";
@@ -4144,15 +4169,21 @@ var init_kioku = __esm({
     NOT_INSTALLED = "kioku is not installed on this machine";
     START_TIMEOUT_MS = 2e4;
     WRITE_TIMEOUT_MS = 6e4;
+    PUBLISH_TIMEOUT_MS = 3 * 6e4;
     CACHE_MS2 = 5 * 6e4;
     ACTIVITY_SINCE = "2w";
     ACTIVITY_LIMIT = 40;
     PARALLEL = 6;
+    TIERS = ["personal", "project", "team"];
+    REPO = /^[\w.-]+\/[\w.-]+(\/[\w.-]+)?$/;
+    AREA = /^[A-Za-z0-9][\w.-]*(\/[A-Za-z0-9][\w.-]*)*$/;
+    LANGUAGE = /^[A-Za-z]{2,3}(-[A-Za-z0-9]+)*$/;
     MISSING = { installed: false, version: null, brains: [], projects: {}, activity: [] };
     brainName = (b) => b.name ?? b.key;
     Kioku = class {
       run;
       write;
+      terminal;
       startTimeoutMs;
       projects;
       now;
@@ -4163,6 +4194,7 @@ var init_kioku = __esm({
         this.binPath = options.bin;
         this.run = options.run ?? createRunner();
         this.write = options.write ?? createRunner(envWithoutHost(), WRITE_TIMEOUT_MS);
+        this.terminal = options.terminal;
         this.startTimeoutMs = options.startTimeoutMs ?? START_TIMEOUT_MS;
         this.projects = options.projects ?? (() => ({}));
         this.now = options.now ?? Date.now;
@@ -4244,10 +4276,7 @@ var init_kioku = __esm({
         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 brain = await this.findBrain(input.brain);
         const args = [
           "page",
           "save",
@@ -4266,19 +4295,108 @@ var init_kioku = __esm({
           ...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);
+        const { out, fail } = await this.invoke(args, brain.folder, this.write, input.body);
         if (out?.status === "done" && out.path) {
-          this.snapshot = null;
+          this.expire();
           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);
+        throw fail("kioku could not save the page");
+      }
+      // the cached reading when there is one, else only the list of brains
+      async listBrains() {
+        return this.snapshot ? (await this.snapshot.value).brains : (await this.json(["brain", "list"], homedir5()))?.brains ?? [];
+      }
+      async findBrain(key) {
+        const brain = (await this.listBrains()).find((b) => b.key === key);
+        if (!brain?.onDisk)
+          throw new KiokuError(`no brain ${key} on this machine`, 404);
+        return brain;
+      }
+      // the next status reads again, while the old reading still answers a poll that is not fresh
+      expire() {
+        if (this.snapshot)
+          this.snapshot.at = -Infinity;
+      }
+      // runs a verb that writes; fail turns kioku's refusal into a 400 with its message
+      async invoke(args, cwd, run, input) {
+        const result2 = await run(this.bin, args, cwd, input);
+        if (result2.code === 127)
+          throw new KiokuError(NOT_INSTALLED, 404);
+        const out = parseJson(result2.stdout);
+        return { out, ok: result2.code === 0 && out !== null && !out.error, fail: (fallback) => new KiokuError(out?.error?.message ?? (tailOutput(result2.stderr, 1) || fallback), 400) };
+      }
+      async change(args, cwd, run = this.write) {
+        const { out, ok, fail } = await this.invoke([...args, "--json"], cwd, run);
+        if (!ok || !out)
+          throw fail(`kioku ${args.slice(0, 2).join(" ")} failed`);
+        this.expire();
+        return out;
+      }
+      // makes a brain on this machine only; kioku never makes a repository here
+      async createBrain(input) {
+        assertRepo(input.repo, "the brain");
+        if (!TIERS.includes(input.tier))
+          throw new KiokuError(`the tier is one of ${TIERS.join(", ")}`, 400);
+        if (input.team)
+          assertRepo(input.team, "the team brain");
+        if (input.language && !LANGUAGE.test(input.language))
+          throw new KiokuError("the language is a tag such as en or es", 400);
+        const args = [
+          "brain",
+          "create",
+          input.repo,
+          "--tier",
+          input.tier,
+          ...input.team && input.tier === "project" ? ["--team", input.team] : [],
+          ...input.language ? ["--language", input.language] : []
+        ];
+        const { brain, name, path } = await this.change(args, homedir5());
+        return { brain, name, path };
+      }
+      async addArea(key, area, summary) {
+        if (!AREA.test(area))
+          throw new KiokuError("an area is letters, digits, dots, dashes and underscores, with / between parts", 400);
+        if (!summary)
+          throw new KiokuError("say what the area is for", 400);
+        const brain = await this.findBrain(key);
+        const out = await this.change(["namespace", "add", area, `--summary=${summary}`, "--brain", brain.key], brain.folder);
+        return { brain: out.brain, namespace: out.namespace };
+      }
+      // writes the project's kioku.yaml; a brain the machine does not know is made first, since kioku links only known brains without a terminal
+      async linkProject(input) {
+        if (!input.brain && !input.team)
+          throw new KiokuError("name a project brain, a team brain, or both", 400);
+        const path = this.projects()[input.project]?.path;
+        if (!path || !existsSync12(path))
+          throw new KiokuError(`no CW project ${input.project} on this machine`, 404);
+        if (input.brain)
+          assertRepo(input.brain, "the project brain");
+        if (input.team)
+          assertRepo(input.team, "the team brain");
+        const known = await this.listBrains();
+        const isKnown = (repo) => known.some((b) => b.key === repo || b.key.endsWith(`/${repo}`));
+        const created = [];
+        if (input.team && !isKnown(input.team))
+          created.push((await this.createBrain({ repo: input.team, tier: "team" })).brain);
+        if (input.brain && !isKnown(input.brain))
+          created.push((await this.createBrain({ repo: input.brain, tier: "project", team: input.team })).brain);
+        const args = ["init", ...input.brain ? [input.brain] : [], ...input.team ? ["--team", input.team] : []];
+        const { file } = await this.change(args, path);
+        return { file, created };
+      }
+      // the only verb that reaches a git host: without `to`, kioku makes a private GitHub repository with gh
+      async publish(key, to) {
+        if (to?.startsWith("-"))
+          throw new KiokuError("the address cannot start with -", 400);
+        const brain = await this.findBrain(key);
+        if (brain.remote)
+          throw new KiokuError(`${brainName(brain)} already has a repository: ${brain.remote}`, 400);
+        const out = await this.change(["brain", "publish", brain.key, ...to ? ["--to", to] : []], brain.folder, this.terminal ??= createTerminalRunner(envWithoutHost(), PUBLISH_TIMEOUT_MS));
+        return { brain: out.brain, status: out.status, remote: out.remote ?? null };
       }
       // one viewer at a time; a second call reuses the running one
       async openViewer() {
@@ -4363,6 +4481,24 @@ function kiokuRoutes(kioku = new Kioku(), options = {}) {
     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("/brains", async (c) => {
+    const { repo, tier, team, language } = await body(c);
+    return c.json(await kioku.createBrain({ repo: trim(repo) ?? "", tier: tier ?? "", team: trim(team), language: trim(language) }), 201);
+  });
+  app.post("/areas", async (c) => {
+    const { brain, area, summary } = await body(c);
+    return c.json(await kioku.addArea(brain ?? "", trim(area) ?? "", trim(summary) ?? ""), 201);
+  });
+  app.post("/link", async (c) => {
+    const { project, brain, team } = await body(c);
+    return c.json(await kioku.linkProject({ project: project ?? "", brain: trim(brain), team: trim(team) }));
+  });
+  app.post("/publish", async (c) => {
+    const { brain, to, understood } = await body(c);
+    if (understood !== true)
+      return c.json({ error: "publishing needs the warning accepted" }, 400);
+    return c.json(await kioku.publish(brain ?? "", trim(to)));
+  });
   app.post("/remember", async (c) => {
     const { project, sessionDir, text } = await c.req.json().catch(() => ({}));
     const line = text?.trim();
@@ -4383,12 +4519,14 @@ function kiokuRoutes(kioku = new Kioku(), options = {}) {
   });
   return app;
 }
-var REMEMBER_MAX;
+var trim, REMEMBER_MAX, body;
 var init_kioku_routes = __esm({
   "../core/dist/kioku-routes.js"() {
     "use strict";
     init_kioku();
+    trim = (value) => value?.trim() || void 0;
     REMEMBER_MAX = 500;
+    body = (c) => c.req.json().catch(() => ({}));
   }
 });
 
@@ -4570,8 +4708,8 @@ data: ${JSON.stringify(data)}
   });
   app.put("/api/modules/:module/settings", async (c) => {
     const moduleId = c.req.param("module");
-    const body = await c.req.json();
-    for (const [key, value] of Object.entries(body)) {
+    const body2 = await c.req.json();
+    for (const [key, value] of Object.entries(body2)) {
       db.setModuleSetting(moduleId, key, String(value));
     }
     return c.json({ ok: true });
@@ -4839,8 +4977,8 @@ function waitForListening(server) {
 async function probePort(port, timeoutMs = 1500) {
   try {
     const res = await fetch(`http://127.0.0.1:${port}/api/health`, { signal: AbortSignal.timeout(timeoutMs) });
-    const body = await res.json().catch(() => null);
-    return body?.status === "ok" && typeof body.modules === "number" ? "forge" : "other";
+    const body2 = await res.json().catch(() => null);
+    return body2?.status === "ok" && typeof body2.modules === "number" ? "forge" : "other";
   } catch (err) {
     return err.name === "TimeoutError" ? "unresponsive" : "other";
   }

package/package.json

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