u-foo 1.0.6 → 1.1.9

package/src/chat/layout.js

@@ -0,0 +1,165 @@
+function createChatLayout(options = {}) {
+  const {
+    blessed,
+    currentInputHeight = 4,
+    version = "unknown",
+  } = options;
+
+  const screen = blessed.screen({
+    smartCSR: true,
+    title: "ufoo chat",
+    fullUnicode: true,
+    // Toggle mouse at runtime to balance copy vs scroll
+    sendFocus: true,
+    mouse: false,
+    // Allow Ctrl+C to exit even when input grabs keys
+    ignoreLocked: ["C-c"],
+  });
+  // Prefer normal buffer for reliable terminal selection/copy
+  if (screen.program && typeof screen.program.normalBuffer === "function") {
+    screen.program.normalBuffer();
+    if (screen.program.put && typeof screen.program.put.keypad_local === "function") {
+      screen.program.put.keypad_local();
+    }
+    if (typeof screen.program.clear === "function") {
+      screen.program.clear();
+      screen.program.cup(0, 0);
+    }
+  }
+
+  // Log area (no border for cleaner look)
+  const logBox = blessed.log({
+    parent: screen,
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: "100%-5", // Will be adjusted dynamically
+    tags: true,
+    scrollable: true,
+    alwaysScroll: true,
+    scrollback: 10000,
+    scrollbar: null,
+    keys: true,
+    vi: true,
+    // Mouse handled globally (toggleable) to keep copy working
+    mouse: false,
+    // Ensure proper wrapping and width calculation
+    wrap: true,
+  });
+
+  // Status line just above input
+  const statusLine = blessed.box({
+    parent: screen,
+    bottom: currentInputHeight,
+    left: 0,
+    width: "100%",
+    height: 1,
+    style: { fg: "gray" },
+    tags: true,
+    content: "",
+  });
+  const bannerText = `{bold}UFOO{/bold} · Multi-Agent Manager{|}v${version}`;
+  statusLine.setContent(bannerText);
+
+  // Command completion panel
+  const completionPanel = blessed.box({
+    parent: screen,
+    bottom: currentInputHeight - 1,
+    left: 0,
+    width: "100%",
+    height: 0,
+    hidden: true,
+    wrap: false,
+    border: {
+      type: "line",
+      top: true,
+      left: false,
+      right: false,
+      bottom: false,
+    },
+    style: {
+      border: { fg: "yellow" },
+      fg: "white",
+      // No bg - uses terminal default background
+    },
+    padding: {
+      left: 0,
+      right: 0,
+      top: 0,
+      bottom: 0,
+    },
+    tags: true,
+  });
+
+  // Dashboard at very bottom
+  const dashboard = blessed.box({
+    parent: screen,
+    bottom: 0,
+    left: 0,
+    width: "100%",
+    height: 1,
+    style: { fg: "gray" },
+    tags: true,
+  });
+
+  // Bottom border line for input area (above dashboard)
+  const inputBottomLine = blessed.line({
+    parent: screen,
+    bottom: 1,
+    left: 1,
+    width: "100%-2",
+    orientation: "horizontal",
+    style: { fg: "gray" },
+  });
+
+  // Prompt indicator
+  const promptBox = blessed.box({
+    parent: screen,
+    bottom: 2,
+    left: 0,
+    width: 2,
+    height: currentInputHeight - 3,
+    content: ">",
+    style: { fg: "cyan" },
+  });
+
+  // Input area without left/right border
+  const input = blessed.textarea({
+    parent: screen,
+    bottom: 2,
+    left: 2,
+    width: "100%-2",
+    height: currentInputHeight - 3,
+    inputOnFocus: true,
+    keys: true,
+  });
+  // Avoid textarea's extra wrap margin (causes a phantom empty column)
+  input.type = "box";
+
+  // Top border line for input area (just above input)
+  const inputTopLine = blessed.line({
+    parent: screen,
+    bottom: currentInputHeight - 1, // 4-1=3: above input(2) + inputHeight(1)
+    left: 1,
+    width: "100%-2",
+    orientation: "horizontal",
+    style: { fg: "gray" },
+  });
+
+  return {
+    screen,
+    logBox,
+    statusLine,
+    bannerText,
+    completionPanel,
+    dashboard,
+    inputBottomLine,
+    promptBox,
+    input,
+    inputTopLine,
+  };
+}
+
+module.exports = {
+  createChatLayout,
+};

package/src/chat/pasteController.js

@@ -0,0 +1,81 @@
+function createPasteController(options = {}) {
+  const {
+    shouldHandle = () => true,
+    normalizePaste = (text) => text,
+    insertTextAtCursor = () => {},
+    setImmediateFn = setImmediate,
+    clearImmediateFn = clearImmediate,
+  } = options;
+
+  const PASTE_START = "\x1b[200~";
+  const PASTE_END = "\x1b[201~";
+  let pasteActive = false;
+  let pasteBuffer = "";
+  let pasteRemainder = "";
+  let suppressKeypress = false;
+  let suppressReset = null;
+
+  function keepMarkerPrefixTail(text, marker) {
+    const max = Math.min(marker.length - 1, text.length);
+    for (let len = max; len > 0; len -= 1) {
+      if (text.endsWith(marker.slice(0, len))) {
+        return text.slice(-len);
+      }
+    }
+    return "";
+  }
+
+  function scheduleSuppressReset() {
+    suppressKeypress = true;
+    if (suppressReset) clearImmediateFn(suppressReset);
+    suppressReset = setImmediateFn(() => {
+      if (!pasteActive) suppressKeypress = false;
+    });
+  }
+
+  function handleProgramData(data) {
+    if (!shouldHandle()) return;
+    let buffer = pasteRemainder + data.toString("utf8");
+    pasteRemainder = "";
+    while (buffer.length > 0) {
+      if (!pasteActive) {
+        const start = buffer.indexOf(PASTE_START);
+        if (start === -1) {
+          pasteRemainder = keepMarkerPrefixTail(buffer, PASTE_START);
+          return;
+        }
+        buffer = buffer.slice(start + PASTE_START.length);
+        pasteActive = true;
+        pasteBuffer = "";
+        scheduleSuppressReset();
+        continue;
+      }
+      const end = buffer.indexOf(PASTE_END);
+      if (end === -1) {
+        pasteBuffer += buffer;
+        scheduleSuppressReset();
+        return;
+      }
+      pasteBuffer += buffer.slice(0, end);
+      buffer = buffer.slice(end + PASTE_END.length);
+      pasteActive = false;
+      scheduleSuppressReset();
+      const normalized = normalizePaste(pasteBuffer);
+      pasteBuffer = "";
+      if (normalized) insertTextAtCursor(normalized);
+    }
+  }
+
+  function isSuppressKeypress() {
+    return suppressKeypress;
+  }
+
+  return {
+    handleProgramData,
+    isSuppressKeypress,
+  };
+}
+
+module.exports = {
+  createPasteController,
+};

package/src/chat/rawKeyMap.js

@@ -0,0 +1,42 @@
+function keyToRaw(ch, key) {
+  if (ch && ch.length === 1) return ch;
+  if (!key) return null;
+
+  switch (key.name) {
+    case "return":
+    case "enter":
+      return "\r";
+    case "backspace":
+      return "\x7f";
+    case "tab":
+      return "\t";
+    case "escape":
+      return "\x1b";
+    case "up":
+      return "\x1b[A";
+    case "down":
+      return "\x1b[B";
+    case "right":
+      return "\x1b[C";
+    case "left":
+      return "\x1b[D";
+    case "home":
+      return "\x1b[H";
+    case "end":
+      return "\x1b[F";
+    case "pageup":
+      return "\x1b[5~";
+    case "pagedown":
+      return "\x1b[6~";
+    case "delete":
+      return "\x1b[3~";
+    case "insert":
+      return "\x1b[2~";
+    default:
+      return ch || null;
+  }
+}
+
+module.exports = {
+  keyToRaw,
+};

package/src/chat/settingsController.js

@@ -0,0 +1,132 @@
+const path = require("path");
+
+function createSettingsController(options = {}) {
+  const {
+    projectRoot,
+    saveConfig = () => {},
+    normalizeLaunchMode = (value) => value,
+    normalizeAgentProvider = (value) => value,
+    normalizeAssistantEngine = (value) => value,
+    fsModule,
+    getUfooPaths = () => ({ agentDir: "" }),
+    logMessage = () => {},
+    renderDashboard = () => {},
+    renderScreen = () => {},
+    restartDaemon = () => {},
+    getLaunchMode = () => "terminal",
+    setLaunchModeState = () => {},
+    setSelectedModeIndex = () => {},
+    getAgentProvider = () => "codex-cli",
+    setAgentProviderState = () => {},
+    setSelectedProviderIndex = () => {},
+    getAssistantEngine = () => "auto",
+    setAssistantEngineState = () => {},
+    setSelectedAssistantIndex = () => {},
+    assistantOptions = [],
+    getAutoResume = () => true,
+    setAutoResumeState = () => {},
+    setSelectedResumeIndex = () => {},
+  } = options;
+
+  if (!projectRoot) {
+    throw new Error("createSettingsController requires projectRoot");
+  }
+  if (!fsModule) {
+    throw new Error("createSettingsController requires fsModule");
+  }
+
+  function providerLabel(value) {
+    return value === "claude-cli" ? "claude" : "codex";
+  }
+
+  function assistantLabel(value) {
+    const normalized = normalizeAssistantEngine(value);
+    if (normalized === "codex") return "codex";
+    if (normalized === "claude") return "claude";
+    if (normalized === "ufoo") return "ufoo";
+    return "auto";
+  }
+
+  function clearUfooAgentIdentity() {
+    const agentDir = getUfooPaths(projectRoot).agentDir;
+    const stateFile = path.join(agentDir, "ufoo-agent.json");
+    const historyFile = path.join(agentDir, "ufoo-agent.history.jsonl");
+    try {
+      fsModule.rmSync(stateFile, { force: true });
+    } catch {
+      // Ignore cleanup failures.
+    }
+    try {
+      fsModule.rmSync(historyFile, { force: true });
+    } catch {
+      // Ignore cleanup failures.
+    }
+  }
+
+  function setLaunchMode(mode) {
+    const next = normalizeLaunchMode(mode);
+    if (next === getLaunchMode()) return false;
+    setLaunchModeState(next);
+    setSelectedModeIndex(next === "internal" ? 2 : (next === "tmux" ? 1 : 0));
+    saveConfig(projectRoot, { launchMode: next });
+    logMessage("status", `{white-fg}⚙{/white-fg} Launch mode: ${next}`);
+    renderDashboard();
+    renderScreen();
+    void restartDaemon();
+    return true;
+  }
+
+  function setAgentProvider(provider) {
+    const next = normalizeAgentProvider(provider);
+    if (next === getAgentProvider()) return false;
+    setAgentProviderState(next);
+    setSelectedProviderIndex(next === "claude-cli" ? 1 : 0);
+    saveConfig(projectRoot, { agentProvider: next });
+    clearUfooAgentIdentity();
+    logMessage("status", `{white-fg}⚙{/white-fg} ufoo-agent: ${providerLabel(next)}`);
+    renderDashboard();
+    renderScreen();
+    void restartDaemon();
+    return true;
+  }
+
+  function setAutoResume(value) {
+    const next = value !== false;
+    if (next === getAutoResume()) return false;
+    setAutoResumeState(next);
+    setSelectedResumeIndex(next ? 0 : 1);
+    saveConfig(projectRoot, { autoResume: next });
+    const label = next ? "Resume previous session" : "Start new session";
+    logMessage("status", `{white-fg}⚙{/white-fg} Resume mode: ${label}`);
+    renderDashboard();
+    renderScreen();
+    return true;
+  }
+
+  function setAssistantEngine(engine) {
+    const next = normalizeAssistantEngine(engine);
+    if (next === getAssistantEngine()) return false;
+    setAssistantEngineState(next);
+    const idx = assistantOptions.findIndex((opt) => opt && opt.value === next);
+    setSelectedAssistantIndex(idx >= 0 ? idx : 0);
+    saveConfig(projectRoot, { assistantEngine: next });
+    logMessage("status", `{white-fg}⚙{/white-fg} assistant-engine: ${assistantLabel(next)}`);
+    renderDashboard();
+    renderScreen();
+    return true;
+  }
+
+  return {
+    providerLabel,
+    assistantLabel,
+    clearUfooAgentIdentity,
+    setLaunchMode,
+    setAgentProvider,
+    setAssistantEngine,
+    setAutoResume,
+  };
+}
+
+module.exports = {
+  createSettingsController,
+};

package/src/chat/statusLineController.js

@@ -0,0 +1,177 @@
+function createStatusLineController(options = {}) {
+  const {
+    statusLine,
+    bannerText = "",
+    renderScreen = () => {},
+    setIntervalFn = setInterval,
+    clearIntervalFn = clearInterval,
+    now = () => Date.now(),
+  } = options;
+
+  if (!statusLine) {
+    throw new Error("createStatusLineController requires statusLine");
+  }
+
+  const pendingStatusLines = [];
+  const busStatusQueue = [];
+  let primaryStatusText = bannerText;
+  let primaryStatusPending = false;
+
+  const shimmerStart = now();
+  let animationTimer = null;
+  const STATUS_ANIM_FRAME_MS = 50;
+  const SHIMMER_PADDING = 10;
+  const SHIMMER_BAND_HALF_WIDTH = 5;
+  const SHIMMER_SWEEP_MS = 2000;
+  const SPINNER_PERIOD_MS = 600;
+
+  function formatProcessingText(text) {
+    if (!text) return text;
+    if (text.includes("{")) return text;
+    if (!/processing/i.test(text)) return text;
+    return text;
+  }
+
+  function shimmerText(text, nowMs) {
+    if (!text) return "";
+    if (text.includes("{")) return text;
+    const chars = Array.from(text);
+    const period = chars.length + SHIMMER_PADDING * 2;
+    const pos = Math.floor(((nowMs - shimmerStart) % SHIMMER_SWEEP_MS) / SHIMMER_SWEEP_MS * period);
+    let out = "";
+    for (let i = 0; i < chars.length; i += 1) {
+      const iPos = i + SHIMMER_PADDING;
+      const dist = Math.abs(iPos - pos);
+      let intensity = 0;
+      if (dist <= SHIMMER_BAND_HALF_WIDTH) {
+        const x = Math.PI * (dist / SHIMMER_BAND_HALF_WIDTH);
+        intensity = 0.5 * (1 + Math.cos(x));
+      }
+      const ch = chars[i];
+      if (intensity < 0.2) {
+        out += `{gray-fg}${ch}{/gray-fg}`;
+      } else if (intensity < 0.6) {
+        out += ch;
+      } else {
+        out += `{bold}{white-fg}${ch}{/white-fg}{/bold}`;
+      }
+    }
+    return out;
+  }
+
+  function spinnerFrame(nowMs) {
+    const on = Math.floor((nowMs - shimmerStart) / SPINNER_PERIOD_MS) % 2 === 0;
+    return on ? "{gray-fg}•{/gray-fg}" : "{gray-fg}◦{/gray-fg}";
+  }
+
+  function renderPendingStatus(text, nowMs) {
+    const spinner = spinnerFrame(nowMs);
+    const shimmer = shimmerText(text, nowMs);
+    return shimmer ? `${spinner} ${shimmer}` : spinner;
+  }
+
+  function renderStatusLine(nowMs = now()) {
+    let content = primaryStatusText || "";
+    if (primaryStatusPending) {
+      content = renderPendingStatus(primaryStatusText, nowMs);
+    }
+    if (busStatusQueue.length > 0) {
+      const extra = busStatusQueue.length > 1
+        ? ` {gray-fg}(+${busStatusQueue.length - 1}){/gray-fg}`
+        : "";
+      const busText = `${busStatusQueue[0].text}${extra}`;
+      content = content
+        ? `${content} {gray-fg}·{/gray-fg} ${busText}`
+        : busText;
+    }
+    statusLine.setContent(content);
+  }
+
+  function updateAnimation() {
+    if (primaryStatusPending && !animationTimer) {
+      animationTimer = setIntervalFn(() => {
+        if (!primaryStatusPending) return;
+        renderStatusLine(now());
+        renderScreen();
+      }, STATUS_ANIM_FRAME_MS);
+    } else if (!primaryStatusPending && animationTimer) {
+      clearIntervalFn(animationTimer);
+      animationTimer = null;
+    }
+  }
+
+  function setPrimaryStatus(text, options = {}) {
+    primaryStatusText = text || "";
+    primaryStatusPending = Boolean(options.pending);
+    updateAnimation();
+    renderStatusLine();
+  }
+
+  function queueStatusLine(text) {
+    pendingStatusLines.push(text || "");
+    if (pendingStatusLines.length === 1) {
+      setPrimaryStatus(pendingStatusLines[0], { pending: true });
+      renderScreen();
+    }
+  }
+
+  function resolveStatusLine(text) {
+    if (pendingStatusLines.length > 0) {
+      pendingStatusLines.shift();
+    }
+    if (pendingStatusLines.length > 0) {
+      setPrimaryStatus(pendingStatusLines[0], { pending: true });
+    } else {
+      setPrimaryStatus(text || "", { pending: false });
+    }
+    renderScreen();
+  }
+
+  function enqueueBusStatus(item) {
+    if (!item || !item.text) return;
+    const key = item.key || item.text;
+    const formatted = formatProcessingText(item.text);
+    const existing = busStatusQueue.find((entry) => entry.key === key);
+    if (existing) {
+      existing.text = formatted;
+    } else {
+      busStatusQueue.push({ key, text: formatted });
+    }
+    renderStatusLine();
+  }
+
+  function resolveBusStatus(item) {
+    if (!item) return;
+    const key = item.key || item.text;
+    let index = -1;
+    if (key) {
+      index = busStatusQueue.findIndex((entry) => entry.key === key);
+    }
+    if (index === -1 && item.text) {
+      index = busStatusQueue.findIndex((entry) => entry.text === item.text);
+    }
+    if (index === -1) return;
+    busStatusQueue.splice(index, 1);
+    renderStatusLine();
+  }
+
+  function destroy() {
+    if (animationTimer) {
+      clearIntervalFn(animationTimer);
+      animationTimer = null;
+    }
+  }
+
+  return {
+    queueStatusLine,
+    resolveStatusLine,
+    enqueueBusStatus,
+    resolveBusStatus,
+    renderStatusLine,
+    destroy,
+  };
+}
+
+module.exports = {
+  createStatusLineController,
+};