u-foo 1.0.6 → 1.1.9

package/src/chat/streamTracker.js

@@ -0,0 +1,138 @@
+function createStreamTracker(options = {}) {
+  const {
+    logBox,
+    writeSpacer,
+    appendHistory,
+    escapeBlessed,
+    onStreamStart,
+    now = () => new Date().toISOString(),
+  } = options;
+
+  const streamStates = new Map();
+  const pendingDeliveries = new Map();
+
+  function buildStreamDisplayText(fullText, prefix, continuationPrefix) {
+    const lines = String(fullText || "").split("\n");
+    return lines.map((line, i) => {
+      const p = i === 0 ? prefix : continuationPrefix;
+      return `${p}${escapeBlessed(line)}`;
+    }).join("\n");
+  }
+
+  function beginStream(publisher, prefix, continuationPrefix, meta) {
+    let state = streamStates.get(publisher);
+    if (state) return state;
+
+    if (typeof writeSpacer === "function") {
+      writeSpacer();
+    }
+    logBox.pushLine(prefix);
+    state = {
+      publisher,
+      prefix,
+      continuationPrefix,
+      lineIndex: logBox.getLines().length - 1,
+      buffer: "",
+      full: "",
+      linesEmitted: 0,
+      meta,
+    };
+    streamStates.set(publisher, state);
+    if (typeof onStreamStart === "function") {
+      onStreamStart();
+    }
+    return state;
+  }
+
+  function appendStreamDelta(state, delta) {
+    if (!delta || !state) return;
+    state.full += delta;
+    state.buffer += delta;
+    const parts = state.buffer.split("\n");
+    if (parts.length > 1) {
+      const completed = parts.slice(0, -1);
+      for (const line of completed) {
+        const prefix = state.linesEmitted === 0 ? state.prefix : state.continuationPrefix;
+        logBox.setLine(state.lineIndex, `${prefix}${escapeBlessed(line)}`);
+        state.linesEmitted += 1;
+        logBox.pushLine(state.continuationPrefix);
+        state.lineIndex = logBox.getLines().length - 1;
+      }
+      state.buffer = parts[parts.length - 1];
+    }
+    const prefix = state.linesEmitted === 0 ? state.prefix : state.continuationPrefix;
+    logBox.setLine(state.lineIndex, `${prefix}${escapeBlessed(state.buffer)}`);
+  }
+
+  function finalizeStream(publisher, meta, reason = "") {
+    const state = streamStates.get(publisher);
+    if (!state) return;
+    const text = buildStreamDisplayText(state.full, state.prefix, state.continuationPrefix);
+    appendHistory({
+      ts: now(),
+      type: "bus",
+      text,
+      meta: { ...(meta || {}), stream_done: true, stream_reason: reason },
+    });
+    streamStates.delete(publisher);
+  }
+
+  function hasStream(publisher) {
+    return streamStates.has(publisher);
+  }
+
+  function markPendingDelivery(agentId, agentLabel) {
+    const key = agentId || agentLabel;
+    if (!key) return;
+    const existing = pendingDeliveries.get(key);
+    const state = existing || { count: 0, keys: new Set() };
+    state.count += 1;
+    if (agentId) {
+      pendingDeliveries.set(agentId, state);
+      state.keys.add(agentId);
+    }
+    if (agentLabel && agentLabel !== agentId) {
+      pendingDeliveries.set(agentLabel, state);
+      state.keys.add(agentLabel);
+    }
+    if (!agentId && !agentLabel) {
+      pendingDeliveries.set(key, state);
+      state.keys.add(key);
+    }
+  }
+
+  function getPendingState(publisher, displayName) {
+    if (publisher && pendingDeliveries.has(publisher)) {
+      return { key: publisher, state: pendingDeliveries.get(publisher) };
+    }
+    if (displayName && pendingDeliveries.has(displayName)) {
+      return { key: displayName, state: pendingDeliveries.get(displayName) };
+    }
+    return null;
+  }
+
+  function consumePendingDelivery(publisher, displayName) {
+    const hit = getPendingState(publisher, displayName);
+    if (!hit) return false;
+    const state = hit.state;
+    state.count -= 1;
+    if (state.count <= 0) {
+      for (const key of state.keys || []) {
+        pendingDeliveries.delete(key);
+      }
+    }
+    return true;
+  }
+
+  return {
+    beginStream,
+    appendStreamDelta,
+    finalizeStream,
+    hasStream,
+    markPendingDelivery,
+    getPendingState,
+    consumePendingDelivery,
+  };
+}
+
+module.exports = { createStreamTracker };

package/src/chat/text.js

@@ -0,0 +1,70 @@
+function neutralizeBlessedCommaTags(text) {
+  if (text == null) return "";
+  const raw = String(text);
+  if (!raw.includes("{")) return raw;
+  return raw.replace(/\{\/?[\w\-,;!#]*[;,][\w\-,;!#]*\}/g, (m) => {
+    const inner = m.slice(1, -1).replace(/[,;]/g, (ch) => `${ch} `);
+    return `{${inner}}`;
+  });
+}
+
+function escapeBlessed(text) {
+  if (text == null) return "";
+  const raw = neutralizeBlessedCommaTags(text);
+  if (!raw) return "";
+  // Avoid allowing payload to terminate escape mode.
+  const safe = raw.replace(/\{\/escape\}/g, "{open}/escape{close}");
+  return `{escape}${safe}{/escape}`;
+}
+
+function stripBlessedTags(text) {
+  if (text == null) return "";
+  return String(text).replace(/\{[^}]+\}/g, "");
+}
+
+function stripAnsi(text) {
+  if (text == null) return "";
+  return String(text).replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+function truncateAnsi(text, maxVisible) {
+  if (text == null) return "";
+  if (maxVisible <= 0) return "";
+  const input = String(text);
+  let out = "";
+  let visible = 0;
+  let i = 0;
+  let truncated = false;
+  while (i < input.length && visible < maxVisible) {
+    if (input[i] === "\x1b") {
+      const match = input.slice(i).match(/^\x1b\[[0-9;]*m/);
+      if (match) {
+        out += match[0];
+        i += match[0].length;
+        continue;
+      }
+    }
+    out += input[i];
+    i += 1;
+    visible += 1;
+  }
+  if (i < input.length) truncated = true;
+  if (truncated) out += "\x1b[0m";
+  return out;
+}
+
+function truncateText(text, maxWidth) {
+  if (maxWidth <= 0) return "";
+  if (text.length <= maxWidth) return text;
+  if (maxWidth <= 3) return text.slice(0, maxWidth);
+  return `${text.slice(0, maxWidth - 3)}...`;
+}
+
+module.exports = {
+  neutralizeBlessedCommaTags,
+  escapeBlessed,
+  stripBlessedTags,
+  stripAnsi,
+  truncateAnsi,
+  truncateText,
+};

package/src/chat/transport.js

@@ -0,0 +1,61 @@
+const net = require("net");
+const path = require("path");
+const fs = require("fs");
+const { spawn, spawnSync } = require("child_process");
+
+function connectSocket(sockPath) {
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(sockPath, () => resolve(client));
+    client.on("error", reject);
+  });
+}
+
+function resolveProjectFile(projectRoot, relativePath, fallbackRelativePath) {
+  const local = path.join(projectRoot, relativePath);
+  if (fs.existsSync(local)) return local;
+  return path.join(__dirname, "..", "..", fallbackRelativePath);
+}
+
+function startDaemon(projectRoot, options = {}) {
+  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
+  const env = options.forceResume
+    ? { ...process.env, UFOO_FORCE_RESUME: "1" }
+    : process.env;
+  const child = spawn(process.execPath, [daemonBin, "daemon", "--start"], {
+    detached: true,
+    stdio: "ignore",
+    cwd: projectRoot,
+    env,
+  });
+  child.unref();
+}
+
+function stopDaemon(projectRoot) {
+  const daemonBin = resolveProjectFile(projectRoot, path.join("bin", "ufoo.js"), path.join("bin", "ufoo.js"));
+  spawnSync(process.execPath, [daemonBin, "daemon", "--stop"], {
+    stdio: "ignore",
+    cwd: projectRoot,
+  });
+}
+
+async function connectWithRetry(sockPath, retries, delayMs) {
+  for (let i = 0; i < retries; i += 1) {
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      const client = await connectSocket(sockPath);
+      return client;
+    } catch {
+      // eslint-disable-next-line no-await-in-loop
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
+  return null;
+}
+
+module.exports = {
+  connectSocket,
+  connectWithRetry,
+  resolveProjectFile,
+  startDaemon,
+  stopDaemon,
+};

package/src/cli/busCoreCommands.js

@@ -0,0 +1,59 @@
+"use strict";
+
+async function runBusCoreCommand(eventBus, cmd, cmdArgs = []) {
+  switch (cmd) {
+    case "init":
+      await eventBus.init();
+      return {};
+    case "join":
+      return {
+        subscriber: await eventBus.join(cmdArgs[0], cmdArgs[1], cmdArgs[2]),
+      };
+    case "leave":
+      await eventBus.leave(cmdArgs[0]);
+      return {};
+    case "send":
+      {
+        const publisher = await eventBus.ensureJoined();
+        await eventBus.send(cmdArgs[0], cmdArgs[1], publisher);
+      }
+      return {};
+    case "broadcast":
+      {
+        const publisher = await eventBus.ensureJoined();
+        await eventBus.broadcast(cmdArgs[0], publisher);
+      }
+      return {};
+    case "wake":
+      {
+        const publisher = await eventBus.ensureJoined();
+        await eventBus.wake(cmdArgs[0], { publisher, reason: "remote" });
+      }
+      return {};
+    case "check":
+      await eventBus.check(cmdArgs[0]);
+      return {};
+    case "ack":
+      await eventBus.ack(cmdArgs[0]);
+      return {};
+    case "consume":
+      await eventBus.consume(cmdArgs[0], cmdArgs.includes("--from-beginning"));
+      return {};
+    case "status":
+      await eventBus.status();
+      return {};
+    case "resolve":
+      await eventBus.resolve(cmdArgs[0], cmdArgs[1]);
+      return {};
+    case "rename":
+      await eventBus.rename(cmdArgs[0], cmdArgs[1]);
+      return {};
+    case "whoami":
+      await eventBus.whoami();
+      return {};
+    default:
+      throw new Error(`Unknown bus subcommand: ${cmd}`);
+  }
+}
+
+module.exports = { runBusCoreCommand };

package/src/cli/ctxCoreCommands.js

@@ -0,0 +1,199 @@
+"use strict";
+
+const path = require("path");
+
+function createUnknownCtxError(subcmd) {
+  const err = new Error(`Unknown ctx subcommand: ${subcmd}`);
+  err.code = "UFOO_CTX_UNKNOWN";
+  return err;
+}
+
+async function runCtxCommand(subcmd = "doctor", subargs = [], options = {}) {
+  const {
+    cwd = process.cwd(),
+    allowIndexNew = true,
+    updateDecisionIndexPaths = true,
+  } = options;
+
+  const DecisionsManager = require("../context/decisions");
+  const ContextDoctor = require("../context/doctor");
+  const SyncManager = require("../context/sync");
+
+  switch (subcmd) {
+    case "doctor": {
+      const doctor = new ContextDoctor(cwd);
+      const mode = subargs.includes("--project") ? "project" : "protocol";
+      const projectPath = mode === "project" ? subargs[subargs.indexOf("--project") + 1] : null;
+      await doctor.run({ mode, projectPath });
+      return;
+    }
+    case "lint": {
+      const doctor = new ContextDoctor(cwd);
+      const mode = subargs.includes("--project") ? "project" : "protocol";
+      const projectPath = mode === "project" ? subargs[subargs.indexOf("--project") + 1] : null;
+      if (mode === "project") {
+        doctor.lintProject(projectPath);
+      } else {
+        doctor.lintProtocol();
+      }
+      return;
+    }
+    case "decisions": {
+      const manager = new DecisionsManager(cwd);
+      const opts = {};
+
+      if (allowIndexNew) {
+        if (subargs[0] === "index" || subargs.includes("--index")) {
+          manager.writeIndex();
+          return;
+        }
+        if (subargs[0] === "new") {
+          const create = { title: "", author: "", status: "", nickname: "" };
+          for (let i = 1; i < subargs.length; i++) {
+            const arg = subargs[i];
+            if (arg === "--author") {
+              create.author = subargs[++i] || "";
+              continue;
+            }
+            if (arg === "--status") {
+              create.status = subargs[++i] || "";
+              continue;
+            }
+            if (arg === "--nickname") {
+              create.nickname = subargs[++i] || "";
+              continue;
+            }
+            if (!arg.startsWith("-")) {
+              create.title = create.title ? `${create.title} ${arg}` : arg;
+            }
+          }
+          manager.createDecision(create);
+          return;
+        }
+      }
+
+      for (let i = 0; i < subargs.length; i++) {
+        if (subargs[i] === "-n") opts.num = parseInt(subargs[++i]);
+        if (subargs[i] === "-s") opts.status = subargs[++i];
+        if (subargs[i] === "-l") opts.listOnly = true;
+        if (subargs[i] === "-a") opts.all = true;
+        if (subargs[i] === "-d") {
+          manager.decisionsDir = subargs[++i];
+          if (updateDecisionIndexPaths) {
+            manager.contextDir = path.dirname(manager.decisionsDir);
+            manager.indexFile = path.join(manager.contextDir, "decisions.jsonl");
+          }
+        }
+        if (subargs[i] === "--nickname") opts.nickname = subargs[++i];
+      }
+
+      if (opts.listOnly) {
+        manager.list({ status: opts.status || "open" });
+      } else {
+        manager.show({
+          status: opts.status || "open",
+          num: opts.num || 1,
+          all: opts.all || false,
+        });
+      }
+      return;
+    }
+    case "sync": {
+      const manager = new SyncManager(cwd);
+      const action = (subargs[0] || "list").toLowerCase();
+
+      if (action === "write" || action === "new" || action === "add") {
+        const create = {
+          message: "",
+          from: "",
+          for: "",
+          decision: "",
+          file: "",
+          tests: "",
+          verification: "",
+          risk: "",
+          next: "",
+        };
+
+        for (let i = 1; i < subargs.length; i++) {
+          const arg = subargs[i];
+          if (arg === "--from") {
+            create.from = subargs[++i] || "";
+            continue;
+          }
+          if (arg === "--for") {
+            create.for = subargs[++i] || "";
+            continue;
+          }
+          if (arg === "--decision") {
+            create.decision = subargs[++i] || "";
+            continue;
+          }
+          if (arg === "--file") {
+            create.file = subargs[++i] || "";
+            continue;
+          }
+          if (arg === "--tests") {
+            create.tests = subargs[++i] || "";
+            continue;
+          }
+          if (arg === "--verification") {
+            create.verification = subargs[++i] || "";
+            continue;
+          }
+          if (arg === "--risk") {
+            create.risk = subargs[++i] || "";
+            continue;
+          }
+          if (arg === "--next") {
+            create.next = subargs[++i] || "";
+            continue;
+          }
+          if (!arg.startsWith("-")) {
+            create.message = create.message ? `${create.message} ${arg}` : arg;
+          }
+        }
+
+        manager.write(create);
+        return;
+      }
+
+      if (action === "list" || action === "show" || action === "-l") {
+        const opts = {
+          num: 20,
+          for: "",
+          from: "",
+        };
+
+        for (let i = 1; i < subargs.length; i++) {
+          const arg = subargs[i];
+          if (arg === "-n" || arg === "--num") {
+            opts.num = parseInt(subargs[++i], 10);
+            continue;
+          }
+          if (arg === "--for") {
+            opts.for = subargs[++i] || "";
+            continue;
+          }
+          if (arg === "--from") {
+            opts.from = subargs[++i] || "";
+          }
+        }
+
+        manager.list(opts);
+        return;
+      }
+
+      throw new Error(
+        `Unknown ctx sync action: ${action}. Use 'list' or 'write'.`
+      );
+    }
+    default:
+      throw createUnknownCtxError(subcmd);
+  }
+}
+
+module.exports = {
+  runCtxCommand,
+  createUnknownCtxError,
+};