u-foo 1.0.3 → 1.1.9

package/src/status/index.js

@@ -0,0 +1,285 @@
+const fs = require("fs");
+const path = require("path");
+const childProcess = require("child_process");
+const { readJSON } = require("../bus/utils");
+const { getUfooPaths } = require("../ufoo/paths");
+
+function normalizeTty(ttyPath) {
+  if (!ttyPath) return "";
+  const trimmed = String(ttyPath).trim();
+  if (!trimmed || trimmed === "not a tty") return "";
+  if (trimmed === "/dev/tty") return "";
+  return trimmed;
+}
+
+function tryTtyWithFd(fd) {
+  try {
+    const res = childProcess.spawnSync("tty", {
+      stdio: [fd, "pipe", "ignore"],
+      encoding: "utf8",
+    });
+    if (res && res.status === 0) {
+      const tty = normalizeTty(res.stdout || "");
+      if (tty) return tty;
+    }
+  } catch {
+    // ignore
+  }
+  return "";
+}
+
+function detectCurrentTty() {
+  const stdinTtyPath = normalizeTty(process.stdin?.ttyPath || "");
+  if (stdinTtyPath) return stdinTtyPath;
+
+  const fromStdin = tryTtyWithFd(0);
+  if (fromStdin) return fromStdin;
+
+  try {
+    const fd = fs.openSync("/dev/tty", "r");
+    const fromTty = tryTtyWithFd(fd);
+    fs.closeSync(fd);
+    if (fromTty) return fromTty;
+  } catch {
+    // ignore
+  }
+
+  return "";
+}
+
+/**
+ * 显示项目状态
+ */
+class StatusDisplay {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.paths = getUfooPaths(projectRoot);
+    this.ufooDir = this.paths.ufooDir;
+  }
+
+  /**
+   * 检查 .ufoo 目录是否存在
+   */
+  checkUfooDir() {
+    if (!fs.existsSync(this.ufooDir)) {
+      console.error("FAIL: .ufoo not found. Run: ufoo init");
+      process.exit(1);
+    }
+  }
+
+  /**
+   * 获取当前订阅者信息
+   */
+  getCurrentSubscriber() {
+    // 优先使用 UFOO_SUBSCRIBER_ID（daemon 启动的情况）
+    if (process.env.UFOO_SUBSCRIBER_ID) {
+      return process.env.UFOO_SUBSCRIBER_ID;
+    }
+
+    const agentsFile = this.paths.agentsFile;
+    if (!fs.existsSync(agentsFile)) {
+      return null;
+    }
+
+    // 尝试通过 tty 查找订阅者
+    const currentTty = detectCurrentTty();
+
+    if (currentTty && currentTty.startsWith("/dev/")) {
+      const busData = readJSON(agentsFile);
+      if (busData && busData.agents) {
+        for (const [id, meta] of Object.entries(busData.agents)) {
+          if (meta.tty === currentTty) {
+            return id;
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 统计未读消息
+   */
+  countUnreadMessages() {
+    const queuesDir = this.paths.busQueuesDir;
+    if (!fs.existsSync(queuesDir)) {
+      return { total: 0, details: [] };
+    }
+
+    const agentsFile = this.paths.agentsFile;
+    const busData = readJSON(agentsFile, {});
+
+    let total = 0;
+    const details = [];
+
+    const subscribers = fs.readdirSync(queuesDir);
+    for (const safeName of subscribers) {
+      const pendingFile = path.join(queuesDir, safeName, "pending.jsonl");
+      if (!fs.existsSync(pendingFile)) {
+        continue;
+      }
+
+      const stat = fs.statSync(pendingFile);
+      if (stat.size === 0) {
+        continue;
+      }
+
+      const content = fs.readFileSync(pendingFile, "utf8").trim();
+      const count = content ? content.split("\n").length : 0;
+
+      if (count > 0) {
+        total += count;
+
+        // 找到订阅者名称
+        let subscriberName = safeName.replace(/_/, ":");
+        if (busData.agents) {
+          for (const [id, meta] of Object.entries(busData.agents)) {
+            if (id.replace(/:/, "_") === safeName) {
+              subscriberName = id;
+              break;
+            }
+          }
+        }
+
+        details.push({ subscriber: subscriberName, count });
+      }
+    }
+
+    return { total, details };
+  }
+
+  /**
+   * 统计开放的决策
+   */
+  countOpenDecisions() {
+    const DecisionsManager = require("../context/decisions");
+    const manager = new DecisionsManager(this.projectRoot);
+    const decisionsDir = manager.decisionsDir;
+    if (!fs.existsSync(decisionsDir)) {
+      return { total: 0, details: [] };
+    }
+
+    let total = 0;
+    const details = [];
+
+    const files = fs.readdirSync(decisionsDir)
+      .filter((f) => f.endsWith(".md"))
+      .sort();
+
+    for (const file of files) {
+      const filePath = path.join(decisionsDir, file);
+      const content = fs.readFileSync(filePath, "utf8");
+
+      // 提取状态
+      const status = this.extractStatus(content);
+      if (status === "open") {
+        total++;
+
+        // 提取标题
+        const title = this.extractTitle(content);
+        details.push({ file, title: title || "(no title)" });
+      }
+    }
+
+    return { total, details };
+  }
+
+  /**
+   * 从决策文件提取状态
+   */
+  extractStatus(content) {
+    const lines = content.split("\n");
+    let inFrontmatter = false;
+    let frontmatterCount = 0;
+
+    for (const line of lines) {
+      if (line.trim() === "---") {
+        frontmatterCount++;
+        if (frontmatterCount === 2) {
+          break;
+        }
+        inFrontmatter = frontmatterCount === 1;
+        continue;
+      }
+
+      if (inFrontmatter && line.startsWith("status:")) {
+        return line.split(":")[1].trim();
+      }
+    }
+
+    return "open";
+  }
+
+  /**
+   * 从决策文件提取标题
+   */
+  extractTitle(content) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line.startsWith("#")) {
+        return line.replace(/^#\s*/, "").trim();
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 获取订阅者昵称（如果存在）
+   */
+  getSubscriberNickname(subscriber) {
+    if (!subscriber) return null;
+    const agentsFile = this.paths.agentsFile;
+    const busData = readJSON(agentsFile);
+    if (!busData || !busData.agents) return null;
+    const meta = busData.agents[subscriber];
+    return meta && meta.nickname ? meta.nickname : null;
+  }
+
+  /**
+   * 显示横幅
+   */
+  showBanner(subscriber) {
+    console.log("=== ufoo status ===");
+    if (subscriber) {
+      console.log(`Agent: ${subscriber}`);
+    } else {
+      console.log();
+    }
+  }
+
+  /**
+   * 显示完整状态
+   */
+  async show() {
+    this.checkUfooDir();
+
+    const subscriber = this.getCurrentSubscriber();
+
+    // 显示横幅
+    this.showBanner(subscriber);
+
+    // 显示项目路径
+    console.log(`Project: ${this.projectRoot}`);
+
+    // 显示未读消息
+    const unread = this.countUnreadMessages();
+    console.log(`Unread messages: ${unread.total}`);
+    if (unread.details.length > 0) {
+      for (const { subscriber: sub, count } of unread.details) {
+        console.log(`  - ${sub}: ${count}`);
+      }
+    }
+
+    // 显示开放的决策
+    const decisions = this.countOpenDecisions();
+    console.log(`Open decisions: ${decisions.total}`);
+    if (decisions.details.length > 0) {
+      for (const { file, title } of decisions.details) {
+        console.log(`  - ${file}: ${title}`);
+      }
+    }
+  }
+}
+
+module.exports = StatusDisplay;

package/src/terminal/adapterContract.js

@@ -0,0 +1,87 @@
+const TERMINAL_CAPABILITY_KEYS = [
+  "supportsActivate",
+  "supportsSubscribeFull",
+  "supportsSubscribeScreen",
+  "supportsSnapshot",
+  "supportsReplay",
+  "supportsWindowClose",
+  "supportsSocketProtocol",
+  "supportsNotifierInjector",
+  "supportsInternalQueueLoop",
+  "supportsRestartFallback",
+  "supportsSessionReuse",
+];
+
+const TERMINAL_ADAPTER_METHODS = [
+  "connect",
+  "disconnect",
+  "send",
+  "sendRaw",
+  "resize",
+  "snapshot",
+  "subscribe",
+  "activate",
+  "getState",
+];
+
+function createTerminalCapabilities(overrides = {}) {
+  const capabilities = {};
+  for (const key of TERMINAL_CAPABILITY_KEYS) {
+    capabilities[key] = false;
+  }
+  return { ...capabilities, ...overrides };
+}
+
+function assertTerminalCapabilities(capabilities) {
+  if (!capabilities || typeof capabilities !== "object") {
+    throw new Error("TerminalAdapter capabilities must be an object");
+  }
+  for (const key of TERMINAL_CAPABILITY_KEYS) {
+    if (!(key in capabilities)) {
+      throw new Error(`TerminalAdapter capabilities missing: ${key}`);
+    }
+    if (typeof capabilities[key] !== "boolean") {
+      throw new Error(`TerminalAdapter capability must be boolean: ${key}`);
+    }
+  }
+  return true;
+}
+
+function createUnsupportedCapabilityError(capability, operation) {
+  const suffix = operation ? ` (operation: ${operation})` : "";
+  const err = new Error(`TerminalAdapter capability unsupported: ${capability}${suffix}`);
+  err.code = "UFOO_UNSUPPORTED_CAPABILITY";
+  err.capability = capability;
+  err.operation = operation || null;
+  return err;
+}
+
+function requireCapability(capabilities, capability, operation) {
+  if (!capabilities || !capabilities[capability]) {
+    throw createUnsupportedCapabilityError(capability, operation);
+  }
+  return true;
+}
+
+function assertTerminalAdapterContract(adapter) {
+  if (!adapter || typeof adapter !== "object") {
+    throw new Error("TerminalAdapter must be an object");
+  }
+  for (const method of TERMINAL_ADAPTER_METHODS) {
+    if (typeof adapter[method] !== "function") {
+      throw new Error(`TerminalAdapter missing method: ${method}`);
+    }
+  }
+  assertTerminalCapabilities(adapter.capabilities);
+  return true;
+}
+
+module.exports = {
+  TERMINAL_CAPABILITY_KEYS,
+  TERMINAL_ADAPTER_METHODS,
+  createTerminalCapabilities,
+  assertTerminalCapabilities,
+  createUnsupportedCapabilityError,
+  requireCapability,
+  assertTerminalAdapterContract,
+};

package/src/terminal/adapterRouter.js

@@ -0,0 +1,84 @@
+const {
+  createTerminalCapabilities,
+  assertTerminalAdapterContract,
+} = require("./adapterContract");
+const { createTerminalAdapter } = require("./adapters/terminalAdapter");
+const { createTmuxAdapter } = require("./adapters/tmuxAdapter");
+const { createInternalQueueAdapter } = require("./adapters/internalQueueAdapter");
+const { createInternalPtyAdapter } = require("./adapters/internalPtyAdapter");
+
+function createTerminalAdapterRouter(options = {}) {
+  const {
+    activateAgent = () => {},
+    activateTerminal = null,
+    activateTmux = null,
+    sendRaw = () => {},
+    sendResize = () => {},
+    requestSnapshot = () => false,
+  } = options;
+
+  function createAdapter({ capabilities, handlers = {} }) {
+    const adapter = {
+      capabilities,
+      connect: handlers.connect || (async () => false),
+      disconnect: handlers.disconnect || (async () => false),
+      send: handlers.send || (() => false),
+      sendRaw: handlers.sendRaw || (() => false),
+      resize: handlers.resize || (() => false),
+      snapshot: handlers.snapshot || (() => false),
+      subscribe: handlers.subscribe || (() => false),
+      activate: handlers.activate || (() => false),
+      getState: handlers.getState || (() => ({})),
+    };
+    assertTerminalAdapterContract(adapter);
+    return adapter;
+  }
+
+  function getAdapter(params = {}) {
+    const { launchMode = "", agentId = "" } = params;
+
+    if (launchMode === "terminal") {
+      return createTerminalAdapter({
+        agentId,
+        activateAgent: activateTerminal || activateAgent,
+        createAdapter,
+      });
+    }
+
+    if (launchMode === "tmux") {
+      return createTmuxAdapter({
+        agentId,
+        activateAgent: activateTmux || activateAgent,
+        createAdapter,
+      });
+    }
+
+    if (launchMode === "internal-pty") {
+      return createInternalPtyAdapter({
+        sendRaw,
+        sendResize,
+        requestSnapshot,
+        createAdapter,
+      });
+    }
+
+    if (launchMode === "internal") {
+      return createInternalQueueAdapter({
+        sendRaw,
+        sendResize,
+        requestSnapshot,
+        createAdapter,
+      });
+    }
+
+    return createAdapter({ capabilities: createTerminalCapabilities() });
+  }
+
+  return {
+    getAdapter,
+  };
+}
+
+module.exports = {
+  createTerminalAdapterRouter,
+};

package/src/terminal/adapters/externalAdapter.js

@@ -0,0 +1,14 @@
+const { createTerminalAdapter } = require("./terminalAdapter");
+const { createTmuxAdapter } = require("./tmuxAdapter");
+
+function createExternalAdapter(options = {}) {
+  const mode = options.mode || "terminal";
+  if (mode === "tmux") {
+    return createTmuxAdapter(options);
+  }
+  return createTerminalAdapter(options);
+}
+
+module.exports = {
+  createExternalAdapter,
+};

package/src/terminal/adapters/internalAdapter.js

@@ -0,0 +1,13 @@
+const { createInternalPtyAdapter } = require("./internalPtyAdapter");
+const { createInternalQueueAdapter } = require("./internalQueueAdapter");
+
+function createInternalAdapter(options = {}) {
+  if (options.usePty) {
+    return createInternalPtyAdapter(options);
+  }
+  return createInternalQueueAdapter(options);
+}
+
+module.exports = {
+  createInternalAdapter,
+};

package/src/terminal/adapters/internalPtyAdapter.js

@@ -0,0 +1,42 @@
+const { createTerminalCapabilities } = require("../adapterContract");
+
+function createInternalPtyAdapter(options = {}) {
+  const {
+    sendRaw = () => {},
+    sendResize = () => {},
+    requestSnapshot = () => false,
+    createAdapter = () => {},
+  } = options;
+
+  const capabilities = createTerminalCapabilities({
+    supportsInternalQueueLoop: true,
+    supportsSocketProtocol: true,
+    supportsSubscribeFull: true,
+    supportsSubscribeScreen: true,
+    supportsSnapshot: true,
+  });
+
+  return createAdapter({
+    capabilities,
+    handlers: {
+      send: (data) => {
+        sendRaw(data);
+        return true;
+      },
+      sendRaw: (data) => {
+        sendRaw(data);
+        return true;
+      },
+      resize: (cols, rows) => {
+        sendResize(cols, rows);
+        return true;
+      },
+      snapshot: () => Boolean(requestSnapshot("screen")),
+      subscribe: () => Boolean(requestSnapshot("full")),
+    },
+  });
+}
+
+module.exports = {
+  createInternalPtyAdapter,
+};

package/src/terminal/adapters/internalQueueAdapter.js

@@ -0,0 +1,37 @@
+const { createTerminalCapabilities } = require("../adapterContract");
+
+function createInternalQueueAdapter(options = {}) {
+  const {
+    sendRaw = () => {},
+    createAdapter = () => {},
+  } = options;
+
+  const capabilities = createTerminalCapabilities({
+    supportsInternalQueueLoop: true,
+    supportsSocketProtocol: false,
+    supportsSubscribeFull: false,
+    supportsSubscribeScreen: false,
+    supportsSnapshot: false,
+  });
+
+  return createAdapter({
+    capabilities,
+    handlers: {
+      send: (data) => {
+        sendRaw(data);
+        return true;
+      },
+      sendRaw: (data) => {
+        sendRaw(data);
+        return true;
+      },
+      resize: () => false,
+      snapshot: () => false,
+      subscribe: () => false,
+    },
+  });
+}
+
+module.exports = {
+  createInternalQueueAdapter,
+};

package/src/terminal/adapters/terminalAdapter.js

@@ -0,0 +1,31 @@
+const { createTerminalCapabilities } = require("../adapterContract");
+
+function createTerminalAdapter(options = {}) {
+  const {
+    agentId = "",
+    activateAgent = () => {},
+    createAdapter = () => {},
+  } = options;
+
+  const capabilities = createTerminalCapabilities({
+    supportsActivate: true,
+    supportsReplay: true,
+    supportsWindowClose: true,
+    supportsNotifierInjector: true,
+    supportsSessionReuse: true,
+  });
+
+  return createAdapter({
+    capabilities,
+    handlers: {
+      activate: () => {
+        activateAgent(agentId);
+        return true;
+      },
+    },
+  });
+}
+
+module.exports = {
+  createTerminalAdapter,
+};

package/src/terminal/adapters/tmuxAdapter.js

@@ -0,0 +1,30 @@
+const { createTerminalCapabilities } = require("../adapterContract");
+
+function createTmuxAdapter(options = {}) {
+  const {
+    agentId = "",
+    activateAgent = () => {},
+    createAdapter = () => {},
+  } = options;
+
+  const capabilities = createTerminalCapabilities({
+    supportsActivate: true,
+    supportsReplay: false,
+    supportsNotifierInjector: true,
+    supportsSessionReuse: true,
+  });
+
+  return createAdapter({
+    capabilities,
+    handlers: {
+      activate: () => {
+        activateAgent(agentId);
+        return true;
+      },
+    },
+  });
+}
+
+module.exports = {
+  createTmuxAdapter,
+};

package/src/terminal/detect.js

@@ -0,0 +1,64 @@
+/**
+ * Terminal type detection
+ *
+ * Detects the terminal emulator and its capabilities from environment variables.
+ * Results are cached for the lifetime of the process.
+ */
+
+const TERMINAL_TYPES = {
+  ITERM2: "iterm2",
+  APPLE_TERMINAL: "apple-terminal",
+  KITTY: "kitty",
+  WEZTERM: "wezterm",
+  ALACRITTY: "alacritty",
+  UNKNOWN: "unknown",
+};
+
+let cached = null;
+
+/**
+ * Detect the current terminal emulator.
+ * @returns {{ type: string, version: string, truecolor: boolean }}
+ */
+function detect() {
+  if (cached) return cached;
+
+  const prog = process.env.TERM_PROGRAM || "";
+  const ver = process.env.TERM_PROGRAM_VERSION || "";
+  const colorterm = (process.env.COLORTERM || "").toLowerCase();
+  const truecolor = colorterm === "truecolor" || colorterm === "24bit";
+
+  let type = TERMINAL_TYPES.UNKNOWN;
+
+  if (prog === "iTerm.app" || process.env.ITERM_SESSION_ID) {
+    type = TERMINAL_TYPES.ITERM2;
+  } else if (prog === "Apple_Terminal") {
+    type = TERMINAL_TYPES.APPLE_TERMINAL;
+  } else if (prog === "kitty" || process.env.KITTY_PID) {
+    type = TERMINAL_TYPES.KITTY;
+  } else if (prog === "WezTerm") {
+    type = TERMINAL_TYPES.WEZTERM;
+  } else if (prog === "Alacritty") {
+    type = TERMINAL_TYPES.ALACRITTY;
+  }
+
+  cached = { type, version: ver, truecolor };
+  return cached;
+}
+
+function isITerm2() {
+  return detect().type === TERMINAL_TYPES.ITERM2;
+}
+
+function isAppleTerminal() {
+  return detect().type === TERMINAL_TYPES.APPLE_TERMINAL;
+}
+
+/**
+ * Reset cached detection (for testing).
+ */
+function resetCache() {
+  cached = null;
+}
+
+module.exports = { detect, isITerm2, isAppleTerminal, resetCache, TERMINAL_TYPES };

package/src/terminal/index.js

@@ -0,0 +1,8 @@
+/**
+ * Terminal detection and feature modules.
+ */
+
+const detect = require("./detect");
+const iterm2 = require("./iterm2");
+
+module.exports = { ...detect, iterm2 };