u-foo 1.0.3 → 1.1.9

package/src/chat/inputHistoryController.js

@@ -0,0 +1,105 @@
+const fs = require("fs");
+
+function createInputHistoryController(options = {}) {
+  const {
+    inputHistoryFile,
+    historyDir,
+    setInputValue = () => {},
+    getInputValue = () => "",
+    fsMod = fs,
+  } = options;
+
+  if (!inputHistoryFile || !historyDir) {
+    throw new Error("createInputHistoryController requires inputHistoryFile and historyDir");
+  }
+
+  const inputHistory = [];
+  let historyIndex = 0;
+  let historyDraft = "";
+
+  function appendInputHistory(text) {
+    if (!text) return;
+    fsMod.mkdirSync(historyDir, { recursive: true });
+    fsMod.appendFileSync(inputHistoryFile, `${JSON.stringify({ text })}\n`);
+  }
+
+  function loadInputHistory(limit = 2000) {
+    try {
+      const raw = fsMod.readFileSync(inputHistoryFile, "utf8");
+      const lines = String(raw || "").trim().split(/\r?\n/).filter(Boolean);
+      const items = lines.slice(-limit).map((line) => JSON.parse(line));
+      for (const item of items) {
+        if (item && typeof item.text === "string" && item.text.trim() !== "") {
+          inputHistory.push(item.text);
+        }
+      }
+    } catch {
+      // ignore missing/invalid history
+    }
+    historyIndex = inputHistory.length;
+  }
+
+  function updateDraftFromInput() {
+    if (historyIndex === inputHistory.length) {
+      historyDraft = getInputValue();
+    }
+  }
+
+  function setIndexToEnd() {
+    historyIndex = inputHistory.length;
+    historyDraft = "";
+  }
+
+  function historyUp() {
+    if (inputHistory.length === 0) return false;
+    if (historyIndex === inputHistory.length) {
+      historyDraft = getInputValue();
+    }
+    if (historyIndex > 0) {
+      historyIndex -= 1;
+      setInputValue(inputHistory[historyIndex]);
+      return true;
+    }
+    return true;
+  }
+
+  function historyDown() {
+    if (inputHistory.length === 0) return false;
+    if (historyIndex < inputHistory.length - 1) {
+      historyIndex += 1;
+      setInputValue(inputHistory[historyIndex]);
+      return true;
+    }
+    if (historyIndex === inputHistory.length - 1) {
+      historyIndex = inputHistory.length;
+      setInputValue(historyDraft || "");
+      return true;
+    }
+    return false;
+  }
+
+  function commitSubmittedText(text) {
+    if (!text) return;
+    inputHistory.push(text);
+    appendInputHistory(text);
+    setIndexToEnd();
+  }
+
+  return {
+    loadInputHistory,
+    updateDraftFromInput,
+    historyUp,
+    historyDown,
+    commitSubmittedText,
+    setIndexToEnd,
+    getState: () => ({
+      history: [...inputHistory],
+      historyIndex,
+      historyDraft,
+    }),
+  };
+}
+
+module.exports = {
+  createInputHistoryController,
+};

package/src/chat/inputListenerController.js

@@ -0,0 +1,304 @@
+function createInputListenerController(options = {}) {
+  const {
+    getCurrentView = () => "main",
+    exitHandler = () => {},
+    getFocusMode = () => "input",
+    getDashboardView = () => "agents",
+    getSelectedAgentIndex = () => -1,
+    getActiveAgents = () => [],
+    getTargetAgent = () => null,
+    requestCloseAgent = () => {},
+    logMessage = () => {},
+    isSuppressKeypress = () => false,
+    normalizeCommandPrefix = () => {},
+    handleDashboardKey = () => false,
+    exitDashboardMode = () => {},
+    completionController,
+    getLogHeight = () => 10,
+    scrollLog = () => {},
+    insertTextAtCursor = () => {},
+    normalizePaste = (text) => text,
+    resetPreferredCol = () => {},
+    getCursorPos = () => 0,
+    setCursorPos = () => {},
+    ensureInputCursorVisible = () => {},
+    getWrapWidth = () => 0,
+    getCursorRowCol = () => ({ row: 0, col: 0 }),
+    countLines = () => 1,
+    getCursorPosForRowCol = () => 0,
+    getPreferredCol = () => null,
+    setPreferredCol = () => {},
+    historyUp = () => false,
+    historyDown = () => false,
+    enterDashboardMode = () => {},
+    resizeInput = () => {},
+    updateDraftFromInput = () => {},
+  } = options;
+
+  if (!completionController) {
+    throw new Error("createInputListenerController requires completionController");
+  }
+
+  function shouldShowCompletion(value = "") {
+    const text = String(value || "");
+    return text.startsWith("/") || text.startsWith("@");
+  }
+
+  function render(textarea) {
+    if (textarea && textarea.screen && typeof textarea.screen.render === "function") {
+      textarea.screen.render();
+    }
+  }
+
+  function updateCursor(textarea) {
+    if (textarea && typeof textarea._updateCursor === "function") {
+      textarea._updateCursor();
+    }
+  }
+
+  function handleKey(ch, key = {}, textarea) {
+    const keyName = key && key.name;
+
+    if (getCurrentView() === "agent") return;
+
+    if (key && key.ctrl && keyName === "c") {
+      exitHandler();
+      return;
+    }
+
+    if (key && key.ctrl && keyName === "x") {
+      const focusMode = getFocusMode();
+      const dashboardView = getDashboardView();
+      if (focusMode === "dashboard" && dashboardView !== "agents") {
+        handleDashboardKey(key);
+        return;
+      }
+      const selectedAgentIndex = getSelectedAgentIndex();
+      const activeAgents = getActiveAgents();
+      const targetAgent = getTargetAgent();
+      if (
+        focusMode === "dashboard" &&
+        dashboardView === "agents" &&
+        selectedAgentIndex >= 0 &&
+        selectedAgentIndex < activeAgents.length
+      ) {
+        requestCloseAgent(activeAgents[selectedAgentIndex]);
+      } else if (targetAgent) {
+        requestCloseAgent(targetAgent);
+      } else {
+        logMessage("error", "{white-fg}✗{/white-fg} No agent selected");
+      }
+      return;
+    }
+
+    if (isSuppressKeypress()) {
+      return;
+    }
+
+    normalizeCommandPrefix();
+
+    if (getFocusMode() === "dashboard") {
+      if (handleDashboardKey(key)) return;
+      const dashboardView = getDashboardView();
+      if (
+        dashboardView === "agents" &&
+        ch &&
+        ch.length === 1 &&
+        !(key && key.ctrl) &&
+        !(key && key.meta) &&
+        !/^[\x00-\x1f\x7f]$/.test(ch)
+      ) {
+        exitDashboardMode(true);
+      } else {
+        return;
+      }
+    }
+
+    if (completionController.isActive() && completionController.handleKey(ch, key)) return;
+
+    if (keyName === "pageup" || keyName === "pagedown") {
+      const delta = Math.max(1, Math.floor(getLogHeight() / 2));
+      scrollLog(keyName === "pageup" ? -delta : delta);
+      return;
+    }
+
+    if (ch && ch.length > 1 && (!keyName || keyName.length !== 1)) {
+      insertTextAtCursor(normalizePaste(ch));
+      return;
+    }
+
+    if (ch && (ch.includes("\n") || ch.includes("\r")) && (keyName !== "return" && keyName !== "enter")) {
+      insertTextAtCursor(normalizePaste(ch));
+      return;
+    }
+
+    if (keyName === "return" || keyName === "enter") {
+      if (key && key.shift) {
+        insertTextAtCursor("\n");
+      } else {
+        resetPreferredCol();
+        if (textarea && typeof textarea._done === "function") {
+          textarea._done(null, textarea.value);
+        }
+      }
+      return;
+    }
+
+    if (keyName === "left") {
+      const cursorPos = getCursorPos();
+      if (cursorPos > 0) setCursorPos(cursorPos - 1);
+      resetPreferredCol();
+      ensureInputCursorVisible();
+      updateCursor(textarea);
+      render(textarea);
+      return;
+    }
+
+    if (keyName === "right") {
+      const cursorPos = getCursorPos();
+      if (cursorPos < (textarea && textarea.value ? textarea.value.length : 0)) {
+        setCursorPos(cursorPos + 1);
+      }
+      resetPreferredCol();
+      ensureInputCursorVisible();
+      updateCursor(textarea);
+      render(textarea);
+      return;
+    }
+
+    if (keyName === "home") {
+      setCursorPos(0);
+      resetPreferredCol();
+      ensureInputCursorVisible();
+      updateCursor(textarea);
+      render(textarea);
+      return;
+    }
+
+    if (keyName === "end") {
+      setCursorPos((textarea && textarea.value ? textarea.value.length : 0));
+      resetPreferredCol();
+      ensureInputCursorVisible();
+      updateCursor(textarea);
+      render(textarea);
+      return;
+    }
+
+    if (keyName === "up") {
+      if (completionController.isActive() && textarea && textarea.value === "/" && getCursorPos() === 1) {
+        completionController.jumpToLast();
+        return;
+      }
+      if (historyUp()) {
+        completionController.hide();
+        return;
+      }
+    }
+
+    if (keyName === "down") {
+      if (historyDown()) {
+        completionController.hide();
+        return;
+      }
+    }
+
+    if (keyName === "up" || keyName === "down") {
+      const innerWidth = getWrapWidth();
+      if (innerWidth > 0) {
+        const cursorPos = getCursorPos();
+        const value = (textarea && textarea.value) || "";
+        const { row, col } = getCursorRowCol(value, cursorPos, innerWidth);
+        if (getPreferredCol() === null) setPreferredCol(col);
+        const totalRows = countLines(value, innerWidth);
+
+        if (keyName === "down" && row >= totalRows - 1) {
+          enterDashboardMode();
+          return;
+        }
+
+        const targetRow = keyName === "up"
+          ? Math.max(0, row - 1)
+          : Math.min(totalRows - 1, row + 1);
+        setCursorPos(getCursorPosForRowCol(value, targetRow, getPreferredCol(), innerWidth));
+      }
+      ensureInputCursorVisible();
+      updateCursor(textarea);
+      render(textarea);
+      return;
+    }
+
+    if (keyName === "escape") {
+      if (textarea && typeof textarea._done === "function") {
+        textarea._done(null, null);
+      }
+      return;
+    }
+
+    if (keyName === "backspace") {
+      const cursorPos = getCursorPos();
+      if (cursorPos > 0 && textarea) {
+        textarea.value = textarea.value.slice(0, cursorPos - 1) + textarea.value.slice(cursorPos);
+        setCursorPos(cursorPos - 1);
+        resetPreferredCol();
+        resizeInput();
+        ensureInputCursorVisible();
+        updateCursor(textarea);
+        updateDraftFromInput();
+
+        if (shouldShowCompletion(textarea.value)) {
+          completionController.show(textarea.value);
+        } else {
+          completionController.hide();
+        }
+
+        render(textarea);
+      }
+      return;
+    }
+
+    if (keyName === "delete") {
+      const cursorPos = getCursorPos();
+      if (textarea && cursorPos < textarea.value.length) {
+        textarea.value = textarea.value.slice(0, cursorPos) + textarea.value.slice(cursorPos + 1);
+        resetPreferredCol();
+        resizeInput();
+        ensureInputCursorVisible();
+        updateCursor(textarea);
+        render(textarea);
+        updateDraftFromInput();
+      }
+      return;
+    }
+
+    const insertChar = (ch && ch.length === 1)
+      ? ch
+      : (keyName && keyName.length === 1 ? keyName : null);
+
+    if (insertChar && !/^[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]$/.test(insertChar) && textarea) {
+      const cursorPos = getCursorPos();
+      textarea.value = textarea.value.slice(0, cursorPos) + insertChar + textarea.value.slice(cursorPos);
+      setCursorPos(cursorPos + 1);
+      normalizeCommandPrefix();
+      resetPreferredCol();
+      resizeInput();
+      updateCursor(textarea);
+      updateDraftFromInput();
+
+      if (shouldShowCompletion(textarea.value)) {
+        completionController.show(textarea.value);
+      } else if (completionController.isActive()) {
+        completionController.hide();
+      }
+
+      render(textarea);
+    }
+  }
+
+  return {
+    handleKey,
+  };
+}
+
+module.exports = {
+  createInputListenerController,
+};

package/src/chat/inputMath.js

@@ -0,0 +1,104 @@
+function safeStrWidth(strWidth, value) {
+  if (typeof strWidth === "function") return strWidth(value);
+  return Array.from(String(value || "")).length;
+}
+
+function getInnerWidth({ input, screen, promptWidth = 2 }) {
+  const lpos = input.lpos || input._getCoords();
+  if (lpos && Number.isFinite(lpos.xl) && Number.isFinite(lpos.xi)) {
+    return Math.max(1, lpos.xl - lpos.xi + 1);
+  }
+  if (typeof input.width === "number") return Math.max(1, input.width);
+  if (typeof input.width === "string") {
+    const match = input.width.match(/^100%-([0-9]+)$/);
+    if (match && typeof screen.width === "number") {
+      return Math.max(1, screen.width - parseInt(match[1], 10));
+    }
+  }
+  if (typeof screen.width === "number") return Math.max(1, screen.width - promptWidth);
+  if (typeof screen.cols === "number") return Math.max(1, screen.cols - promptWidth);
+  return 1;
+}
+
+function getWrapWidth(input, fallbackWidth) {
+  if (input._clines && typeof input._clines.width === "number") {
+    return Math.max(1, input._clines.width);
+  }
+  return Math.max(1, fallbackWidth || 1);
+}
+
+function countLines(text, width, strWidth) {
+  if (width <= 0) return 1;
+  const lines = String(text || "").split("\n");
+  let total = 0;
+  for (const line of lines) {
+    const lineWidth = safeStrWidth(strWidth, line);
+    total += Math.max(1, Math.ceil(lineWidth / width));
+  }
+  return total;
+}
+
+function getCursorRowCol(text, pos, width, strWidth) {
+  if (width <= 0) return { row: 0, col: 0 };
+  const before = String(text || "").slice(0, Math.max(0, pos));
+  const lines = before.split("\n");
+  let row = 0;
+  for (let i = 0; i < lines.length - 1; i += 1) {
+    const lineWidth = safeStrWidth(strWidth, lines[i]);
+    row += Math.max(1, Math.ceil(lineWidth / width));
+  }
+  const lastLine = lines[lines.length - 1] || "";
+  const lastWidth = safeStrWidth(strWidth, lastLine);
+  row += Math.floor(lastWidth / width);
+  const col = lastWidth % width;
+  return { row, col };
+}
+
+function getLinePosForCol(line, targetCol, strWidth) {
+  if (targetCol <= 0) return 0;
+  let col = 0;
+  let offset = 0;
+  for (const ch of Array.from(String(line || ""))) {
+    const w = safeStrWidth(strWidth, ch);
+    if (col + w > targetCol) return offset;
+    col += w;
+    offset += ch.length;
+  }
+  return offset;
+}
+
+function getCursorPosForRowCol(text, targetRow, targetCol, width, strWidth) {
+  if (width <= 0) return 0;
+  const source = String(text || "");
+  const lines = source.split("\n");
+  let row = 0;
+  let pos = 0;
+  for (const line of lines) {
+    const lineWidth = safeStrWidth(strWidth, line);
+    const wrappedRows = Math.max(1, Math.ceil(lineWidth / width));
+    if (targetRow < row + wrappedRows) {
+      const rowInLine = targetRow - row;
+      const visualCol = rowInLine * width + Math.max(0, targetCol);
+      return pos + getLinePosForCol(line, visualCol, strWidth);
+    }
+    pos += line.length + 1;
+    row += wrappedRows;
+  }
+  return source.length;
+}
+
+function normalizePaste(text) {
+  if (!text) return "";
+  let normalized = String(text).replace(/\x1b\[200~|\x1b\[201~/g, "");
+  normalized = normalized.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return normalized;
+}
+
+module.exports = {
+  getInnerWidth,
+  getWrapWidth,
+  countLines,
+  getCursorRowCol,
+  getCursorPosForRowCol,
+  normalizePaste,
+};

package/src/chat/inputSubmitHandler.js

@@ -0,0 +1,171 @@
+const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
+
+function createInputSubmitHandler(options = {}) {
+  const {
+    state,
+    parseAtTarget = () => null,
+    resolveAgentId = () => null,
+    executeCommand = async () => false,
+    queueStatusLine = () => {},
+    send = () => {},
+    logMessage = () => {},
+    getAgentLabel = (id) => id,
+    escapeBlessed = (value) => String(value || ""),
+    markPendingDelivery = () => {},
+    clearTargetAgent = () => {},
+    setTargetAgent = () => {},
+    enterAgentView = () => {},
+    getAgentAdapter = () => null,
+    activateAgent = async () => {},
+    getInjectSockPath = () => "",
+    existsSync = () => false,
+    commitInputHistory = () => {},
+    focusInput = () => {},
+    renderScreen = () => {},  // Add renderScreen callback
+  } = options;
+
+  if (!state || typeof state !== "object") {
+    throw new Error("createInputSubmitHandler requires a mutable state object");
+  }
+
+  async function tryActivateTargetAgent(agentId) {
+    const adapter = getAgentAdapter(agentId);
+    const capabilities = adapter && adapter.capabilities ? adapter.capabilities : null;
+    const sockPath = getInjectSockPath(agentId);
+    const supportsSocket = Boolean(capabilities && capabilities.supportsSocketProtocol);
+    const supportsActivate = Boolean(capabilities && capabilities.supportsActivate);
+    const supportsInternalQueue = Boolean(capabilities && capabilities.supportsInternalQueueLoop);
+
+    if (existsSync(sockPath) && supportsSocket) {
+      clearTargetAgent();
+      enterAgentView(agentId);
+      return true;
+    }
+
+    if (supportsActivate) {
+      clearTargetAgent();
+      try {
+        if (adapter && typeof adapter.activate === "function") {
+          adapter.activate(agentId);
+        } else {
+          const pendingActivation = activateAgent(agentId);
+          if (pendingActivation && typeof pendingActivation.catch === "function") {
+            pendingActivation.catch(() => {});
+          }
+        }
+      } catch {
+        // Best-effort activation.
+      }
+      return true;
+    }
+
+    if (supportsInternalQueue) {
+      clearTargetAgent();
+      enterAgentView(agentId, { useBus: true });
+      return true;
+    }
+
+    return false;
+  }
+
+  async function handleSubmit(value) {
+    const text = String(value || "").trim();
+
+    if (!text) {
+      if (state.targetAgent) {
+        const handled = await tryActivateTargetAgent(state.targetAgent);
+        if (handled) return;
+      }
+      focusInput();
+      return;
+    }
+
+    commitInputHistory(text);
+
+    if (state.targetAgent) {
+      const label = getAgentLabel(state.targetAgent);
+      logMessage(
+        "user",
+        `{cyan-fg}→{/cyan-fg} {magenta-fg}@${escapeBlessed(label)}{/magenta-fg} ${escapeBlessed(text)}`
+      );
+      renderScreen();  // Immediately render the user message
+      markPendingDelivery(state.targetAgent);
+      send({ type: IPC_REQUEST_TYPES.BUS_SEND, target: state.targetAgent, message: text });
+      clearTargetAgent();
+      focusInput();
+      return;
+    }
+
+    const atTarget = parseAtTarget(text);
+    if (atTarget) {
+      if (!atTarget.message) {
+        const resolvedTarget = resolveAgentId(atTarget.target) || "";
+        if (!resolvedTarget) {
+          logMessage("error", "{white-fg}✗{/white-fg} Unknown @target");
+          focusInput();
+          return;
+        }
+        setTargetAgent(resolvedTarget);
+        logMessage(
+          "status",
+          `{white-fg}⚙{/white-fg} Target selected: @${escapeBlessed(atTarget.target)}`
+        );
+        focusInput();
+        return;
+      }
+      const resolvedTarget = resolveAgentId(atTarget.target) || atTarget.target;
+      logMessage(
+        "user",
+        `{cyan-fg}→{/cyan-fg} {magenta-fg}@${escapeBlessed(atTarget.target)}{/magenta-fg} ${escapeBlessed(atTarget.message)}`
+      );
+      renderScreen();  // Immediately render the user message
+      markPendingDelivery(resolvedTarget);
+      send({ type: IPC_REQUEST_TYPES.BUS_SEND, target: resolvedTarget, message: atTarget.message });
+      focusInput();
+      return;
+    }
+
+    if (text.startsWith("/")) {
+      logMessage("user", `{white-fg}→{/white-fg} ${escapeBlessed(text)}`);
+      renderScreen();  // Render slash command immediately
+      try {
+        await executeCommand(text);
+      } catch (err) {
+        logMessage("error", `{white-fg}✗{/white-fg} Command error: ${escapeBlessed(err.message)}`);
+      }
+      focusInput();
+      return;
+    }
+
+    if (state.pending && state.pending.disambiguate) {
+      const idx = parseInt(text, 10);
+      const choice = state.pending.disambiguate.candidates[idx - 1];
+      if (choice) {
+        queueStatusLine(`ufoo-agent processing (assigning ${choice.agent_id})`);
+        send({
+          type: IPC_REQUEST_TYPES.PROMPT,
+          text: `Use agent ${choice.agent_id} to handle: ${state.pending.original || "the request"}`,
+        });
+        state.pending = null;
+      } else {
+        logMessage("error", "Invalid selection.");
+      }
+    } else {
+      state.pending = { original: text };
+      queueStatusLine("ufoo-agent processing");
+      send({ type: IPC_REQUEST_TYPES.PROMPT, text });
+      logMessage("user", `{white-fg}→{/white-fg} ${escapeBlessed(text)}`);
+      renderScreen();  // Render plain text message immediately
+    }
+
+    focusInput();
+  }
+
+  return {
+    handleSubmit,
+  };
+}
+
+module.exports = {
+  createInputSubmitHandler,
+};