u-foo 2.3.31 → 2.4.0

package/src/ui/ink/chatReducer.js

@@ -0,0 +1,359 @@
+"use strict";
+
+/**
+ * Chat reducer — the entire bag of UI state needed to render ChatApp,
+ * isolated as a pure function so jest can drive it through transitions
+ * without mounting ink.
+ *
+ * Action types (kept simple and explicit; we don't mint constants because
+ * the reducer is the only consumer):
+ *   { type: "log/append", text }           append a log line
+ *   { type: "log/appendMany", lines }      append multiple lines at once
+ *   { type: "log/clear" }                  reset log to banner
+ *   { type: "draft/set", value }
+ *   { type: "draft/clear" }
+ *   { type: "focus/toggle" }               Tab between input/dashboard
+ *   { type: "focus/set", mode }            "input" | "dashboard"
+ *   { type: "view/set", view }             projects|agents|mode|provider|cron
+ *   { type: "view/cycle", direction }      "left" | "right"
+ *   { type: "agents/set", list }           list of {fullId, type, id, nickname, …}
+ *   { type: "agents/select", index }
+ *   { type: "agents/cycle", direction }
+ *   { type: "agents/clearTarget" }
+ *   { type: "agents/window", windowStart }
+ *   { type: "projects/set", list, activeProjectRoot }
+ *   { type: "projects/select", index, projectRoot }
+ *   { type: "scope/set", scope }           "controller" | "project"
+ *   { type: "status/set", payload }        { message, type, showTimer, startedAt }
+ *   { type: "status/idle" }
+ *   { type: "history/push", value }
+ *   { type: "history/setIndex", index }
+ *   { type: "merge/append", entry }        tool merge add
+ *   { type: "merge/flush" }                freeze active group into log
+ *   { type: "merge/expand" }               Ctrl+O
+ *   { type: "settings/set", patch }        merge launch mode / provider / autoResume
+ */
+
+const fmt = require("../format");
+
+const LOG_CAP = 1000;
+const HISTORY_CAP = 200;
+const DASHBOARD_VIEWS = ["projects", "agents", "mode", "provider", "cron"];
+const DEFAULT_PROVIDER_OPTIONS = [
+  { label: "codex", value: "codex-cli" },
+  { label: "claude", value: "claude-cli" },
+  { label: "agy", value: "agy-cli" },
+];
+function projectRootOf(row = {}) {
+  return String((row && (row.root || row.project_root || row.projectRoot)) || "");
+}
+
+function createInitialState({ banner = [], globalMode = false, globalScope = "controller", settings = {} } = {}) {
+  const initialLaunchMode = settings.launchMode || "auto";
+  const initialAgentProvider = settings.agentProvider || "codex-cli";
+  const selectedProviderIndex = Math.max(0, DEFAULT_PROVIDER_OPTIONS.findIndex((opt) => opt.value === initialAgentProvider));
+  return {
+    logLines: banner.concat([""]).map((line, idx) => ({ id: `b-${idx}`, text: line })),
+    lineSeq: banner.length + 1,
+    draft: "",
+    focusMode: "input",
+    dashboardView: globalMode ? "projects" : "agents",
+    globalMode,
+    globalScope,
+    agents: [],
+    activeAgentMeta: new Map(),
+    selectedAgentIndex: -1,
+    agentSelectionMode: false,
+    agentListWindowStart: 0,
+    projects: [],
+    selectedProjectIndex: -1,
+    selectedProjectRoot: "",
+    projectListWindowStart: 0,
+    emptyProjectsDownArmed: false,
+    activeProjectRoot: "",
+    modeOptions: ["auto", "host", "terminal", "tmux", "internal"],
+    selectedModeIndex: Math.max(0, ["auto", "host", "terminal", "tmux", "internal"].indexOf(initialLaunchMode)),
+    providerOptions: DEFAULT_PROVIDER_OPTIONS,
+    selectedProviderIndex,
+    cronTasks: [],
+    selectedCronIndex: -1,
+    loopSummary: null,
+    viewingAgentId: null,
+    // activeStream is the in-flight chunk-by-chunk publisher message (set
+    // while the daemon is streaming). Rendered live below <Static>;
+    // promoted to <Static> when the stream finishes the same way the
+    // tool-merge group is.
+    activeStream: null,
+    inputHistory: [],
+    historyIndex: 0,
+    activeMerge: null,
+    lastMerge: null,
+    mergeId: 0,
+    status: { message: "", type: "thinking", showTimer: false, startedAt: 0 },
+    settings: { launchMode: initialLaunchMode, agentProvider: initialAgentProvider, autoResume: settings.autoResume === true },
+  };
+}
+
+function appendLog(state, lines) {
+  const incoming = Array.isArray(lines) ? lines : [lines];
+  let seq = state.lineSeq;
+  const out = state.logLines.concat(incoming.map((text) => {
+    const id = `l-${seq}`;
+    seq += 1;
+    return { id, text: String(text == null ? "" : text) };
+  }));
+  return {
+    ...state,
+    logLines: out.length > LOG_CAP ? out.slice(-LOG_CAP) : out,
+    lineSeq: seq,
+  };
+}
+
+function freezeMergeIntoLog(state) {
+  if (!state.activeMerge) return state;
+  const summary = fmt.buildToolMergeRowText(state.activeMerge.entries);
+  return appendLog({ ...state, activeMerge: null }, summary);
+}
+
+function reducer(state, action) {
+  if (!action || !action.type) return state;
+  switch (action.type) {
+    case "log/append":
+      return appendLog(freezeMergeIntoLog(state), action.text);
+    case "log/appendMany":
+      return appendLog(freezeMergeIntoLog(state), action.lines);
+    case "log/clear":
+      return {
+        ...state,
+        logLines: [],
+        lineSeq: 0,
+        activeMerge: null,
+      };
+    case "draft/set":
+      return { ...state, draft: String(action.value || "") };
+    case "draft/clear":
+      return { ...state, draft: "" };
+    case "focus/toggle":
+      return {
+        ...state,
+        focusMode: state.focusMode === "input" ? "dashboard" : "input",
+        emptyProjectsDownArmed: state.focusMode === "input" ? state.emptyProjectsDownArmed : false,
+      };
+    case "focus/set":
+      return {
+        ...state,
+        focusMode: action.mode === "dashboard" ? "dashboard" : "input",
+        emptyProjectsDownArmed: action.mode === "dashboard" ? state.emptyProjectsDownArmed : false,
+      };
+    case "view/set": {
+      const view = action.view;
+      const inAgentsView = view === "agents";
+      return {
+        ...state,
+        dashboardView: view,
+        agentSelectionMode: inAgentsView && state.focusMode === "dashboard" && state.selectedAgentIndex >= 0,
+        emptyProjectsDownArmed: view === "projects" ? state.emptyProjectsDownArmed : false,
+      };
+    }
+    case "view/cycle": {
+      const i = DASHBOARD_VIEWS.indexOf(state.dashboardView);
+      const direction = action.direction === "left" ? -1 : 1;
+      const start = i < 0 ? 0 : i;
+      const next = Math.max(0, Math.min(DASHBOARD_VIEWS.length - 1, start + direction));
+      return { ...state, dashboardView: DASHBOARD_VIEWS[next] };
+    }
+    case "agents/set": {
+      const list = Array.isArray(action.list) ? action.list : [];
+      const ids = list.map((a) => a.fullId || `${a.type}:${a.id}`);
+      const meta = new Map(list.map((a) => [a.fullId || `${a.type}:${a.id}`, a]));
+      let nextIdx = state.selectedAgentIndex;
+      let nextMode = state.agentSelectionMode;
+      if (ids.length === 0) {
+        nextIdx = -1;
+        nextMode = false;
+      } else if (nextIdx >= ids.length) {
+        nextIdx = ids.length - 1;
+      }
+      return {
+        ...state,
+        agents: ids,
+        activeAgentMeta: meta,
+        selectedAgentIndex: nextIdx,
+        agentSelectionMode: nextMode,
+      };
+    }
+    case "agents/patchMeta": {
+      const agentId = String(action.agentId || "").trim();
+      if (!agentId) return state;
+      const meta = new Map(state.activeAgentMeta instanceof Map ? state.activeAgentMeta : []);
+      const current = meta.get(agentId) || {};
+      meta.set(agentId, { ...current, ...(action.patch || {}) });
+      return { ...state, activeAgentMeta: meta };
+    }
+    case "agents/select":
+      return {
+        ...state,
+        selectedAgentIndex: action.index,
+        agentSelectionMode: action.index >= 0,
+      };
+    case "agents/cycle": {
+      if (state.agents.length === 0) return state;
+      const cur = state.selectedAgentIndex < 0 ? 0 : state.selectedAgentIndex;
+      const next = action.direction === "left"
+        ? Math.max(0, cur - 1)
+        : Math.min(state.agents.length - 1, cur + 1);
+      return { ...state, selectedAgentIndex: next, agentSelectionMode: true };
+    }
+    case "agents/clearTarget":
+      return { ...state, selectedAgentIndex: -1, agentSelectionMode: false };
+    case "agents/window":
+      return { ...state, agentListWindowStart: action.windowStart };
+    case "projects/set": {
+      const list = Array.isArray(action.list) ? action.list : [];
+      const previousSelectedRoot = state.selectedProjectRoot
+        || projectRootOf(state.projects[state.selectedProjectIndex]);
+      const selectedRoot = String(action.selectedProjectRoot || previousSelectedRoot || "");
+      const selectedIndex = selectedRoot
+        ? list.findIndex((row) => projectRootOf(row) === selectedRoot)
+        : -1;
+      return {
+        ...state,
+        projects: list,
+        selectedProjectRoot: selectedIndex >= 0 ? selectedRoot : "",
+        selectedProjectIndex: selectedIndex,
+        activeProjectRoot: action.activeProjectRoot || state.activeProjectRoot,
+        emptyProjectsDownArmed: list.length === 0 ? state.emptyProjectsDownArmed : false,
+      };
+    }
+    case "projects/select":
+      return {
+        ...state,
+        selectedProjectIndex: action.index,
+        selectedProjectRoot: String(action.projectRoot || projectRootOf(state.projects[action.index]) || ""),
+        emptyProjectsDownArmed: false,
+      };
+    case "projects/clearSelection":
+      return { ...state, selectedProjectIndex: -1, selectedProjectRoot: "", emptyProjectsDownArmed: false };
+    case "projects/armEmptyDown":
+      return { ...state, emptyProjectsDownArmed: true };
+    case "projects/window":
+      return { ...state, projectListWindowStart: Math.max(0, action.windowStart | 0) };
+    case "scope/set":
+      return { ...state, globalScope: action.scope === "project" ? "project" : "controller" };
+    case "status/set":
+      return { ...state, status: { ...state.status, ...action.payload } };
+    case "status/idle":
+      return { ...state, status: { message: "", type: "thinking", showTimer: false, startedAt: 0 } };
+    case "history/push": {
+      const value = String(action.value || "").trim();
+      if (!value) return state;
+      const next = state.inputHistory.concat([value]).slice(-HISTORY_CAP);
+      return { ...state, inputHistory: next, historyIndex: next.length };
+    }
+    case "history/load": {
+      const list = Array.isArray(action.list) ? action.list : [];
+      const next = list.slice(-HISTORY_CAP);
+      return { ...state, inputHistory: next, historyIndex: next.length };
+    }
+    case "history/setIndex":
+      return { ...state, historyIndex: Math.max(0, Math.min(state.inputHistory.length, action.index)) };
+    case "merge/append": {
+      const entry = fmt.normalizeToolMergeEntry(action.entry || {});
+      let next;
+      if (state.activeMerge) {
+        next = { ...state.activeMerge, entries: state.activeMerge.entries.concat([entry]) };
+      } else {
+        next = { id: state.mergeId + 1, entries: [entry], expanded: false };
+      }
+      const lastMerge = next.entries.length >= 2 ? next : state.lastMerge;
+      return {
+        ...state,
+        activeMerge: next,
+        lastMerge,
+        mergeId: state.activeMerge ? state.mergeId : state.mergeId + 1,
+      };
+    }
+    case "merge/flush":
+      return freezeMergeIntoLog(state);
+    case "merge/expand": {
+      const candidate = (state.activeMerge && !state.activeMerge.expanded && state.activeMerge.entries.length >= 2)
+        ? state.activeMerge
+        : (state.lastMerge && !state.lastMerge.expanded && state.lastMerge.entries.length >= 2
+            ? state.lastMerge
+            : null);
+      if (!candidate) return state;
+      const lines = fmt.buildMergedToolExpandedLines(candidate.entries).map((line, i, arr) =>
+        `${i === arr.length - 1 ? "└" : "│"} ${line}`
+      );
+      const after = appendLog(state, lines);
+      return {
+        ...after,
+        activeMerge: state.activeMerge && state.activeMerge.id === candidate.id ? null : state.activeMerge,
+        lastMerge: state.lastMerge && state.lastMerge.id === candidate.id
+          ? { ...state.lastMerge, expanded: true }
+          : state.lastMerge,
+      };
+    }
+    case "settings/set":
+      return { ...state, settings: { ...state.settings, ...(action.patch || {}) } };
+    case "settings/applyMode": {
+      const mode = state.modeOptions[state.selectedModeIndex] || state.settings.launchMode;
+      return { ...state, settings: { ...state.settings, launchMode: mode } };
+    }
+    case "settings/applyProvider": {
+      const selected = state.providerOptions[state.selectedProviderIndex];
+      const agentProvider = selected && selected.value ? selected.value : state.settings.agentProvider;
+      return { ...state, settings: { ...state.settings, agentProvider } };
+    }
+    case "modeIndex/set":
+      return { ...state, selectedModeIndex: Math.max(0, action.index | 0) };
+    case "providerIndex/set":
+      return { ...state, selectedProviderIndex: Math.max(0, action.index | 0) };
+    case "cronIndex/set":
+      return { ...state, selectedCronIndex: Math.max(-1, action.index | 0) };
+    case "cron/set":
+      return { ...state, cronTasks: Array.isArray(action.list) ? action.list : [] };
+    case "loop/set":
+      return { ...state, loopSummary: action.summary && typeof action.summary === "object" ? action.summary : null };
+    case "stream/begin":
+      return {
+        ...state,
+        activeStream: { publisher: action.publisher || "", text: "" },
+      };
+    case "stream/delta": {
+      if (!state.activeStream) {
+        return {
+          ...state,
+          activeStream: { publisher: action.publisher || "", text: String(action.delta || "") },
+        };
+      }
+      return {
+        ...state,
+        activeStream: {
+          ...state.activeStream,
+          text: state.activeStream.text + String(action.delta || ""),
+        },
+      };
+    }
+    case "stream/end": {
+      if (!state.activeStream) return state;
+      const lines = String(state.activeStream.text || "").split(/\r?\n/);
+      const prefix = state.activeStream.publisher
+        ? `${state.activeStream.publisher}: `
+        : "";
+      const annotated = prefix && lines.length > 0
+        ? [`${prefix}${lines[0]}`, ...lines.slice(1).map((l) => `  ${l}`)]
+        : lines;
+      const next = appendLog(state, annotated);
+      return { ...next, activeStream: null };
+    }
+    case "agentView/enter":
+      return { ...state, viewingAgentId: action.agentId || null };
+    case "agentView/exit":
+      return { ...state, viewingAgentId: null };
+    default:
+      return state;
+  }
+}
+
+module.exports = { reducer, createInitialState, DASHBOARD_VIEWS };

package/src/ui/runInk.js

@@ -0,0 +1,57 @@
+"use strict";
+
+/**
+ * Ink runtime launcher for ufoo TUIs.
+ *
+ * ufoo is CommonJS, ink@5 is ESM-only. We bridge by dynamic-importing ink
+ * and exposing a CJS-friendly API that takes a `createRoot(React, ink)`
+ * factory instead of a pre-built React element. The factory is invoked with
+ * the loaded `React` module and ink namespace so callers don't need to
+ * import them themselves.
+ *
+ * Usage:
+ *   const { runInk } = require("./runInk");
+ *   const handle = await runInk(
+ *     (React, ink) => React.createElement(App, props),
+ *     { stdin, stdout },
+ *   );
+ *   await handle.waitUntilExit();
+ */
+
+async function runInk(createRoot, options = {}) {
+  const ink = await import("ink");
+  const React = require("react");
+  const element = createRoot(React, ink);
+  if (!element) throw new Error("runInk: createRoot returned no element");
+  const stdout = options.stdout || process.stdout;
+  const inst = ink.render(element, {
+    stdin: options.stdin || process.stdin,
+    stdout,
+    stderr: options.stderr || process.stderr,
+    exitOnCtrlC: options.exitOnCtrlC !== false,
+    patchConsole: options.patchConsole === true,
+  });
+  // ink keeps the final rendered frame on screen when it unmounts (it writes
+  // the frame as plain stdout output), which leaves the TUI lingering after
+  // Ctrl+C. Clear and home the cursor on every clean exit so the shell prompt
+  // returns to the top of a blank screen.
+  const wrappedExit = inst.waitUntilExit().then((value) => {
+    try {
+      if (stdout && stdout.isTTY && typeof stdout.write === "function") {
+        stdout.write("\x1b[2J\x1b[H");
+      }
+    } catch { /* ignore */ }
+    return value;
+  });
+  return {
+    waitUntilExit: () => wrappedExit,
+    rerender: (next) => inst.rerender(next),
+    unmount: () => inst.unmount(),
+    cleanup: () => inst.cleanup(),
+    instance: inst,
+    React,
+    ink,
+  };
+}
+
+module.exports = { runInk };

package/src/bus/messageMeta.js

@@ -1,52 +0,0 @@
-"use strict";
-
-const INJECTION_MODES = {
-  IMMEDIATE: "immediate",
-  QUEUED: "queued",
-};
-
-function normalizeInjectionMode(value, fallback = INJECTION_MODES.IMMEDIATE) {
-  const raw = String(value || "").trim().toLowerCase();
-  if (raw === INJECTION_MODES.QUEUED) return INJECTION_MODES.QUEUED;
-  if (raw === INJECTION_MODES.IMMEDIATE) return INJECTION_MODES.IMMEDIATE;
-  return fallback;
-}
-
-function normalizeMessageSource(value) {
-  const raw = String(value || "").trim();
-  return raw || "";
-}
-
-function buildMessageData(message, options = {}) {
-  const base = options && typeof options.data === "object" && options.data
-    ? { ...options.data }
-    : {};
-  const data = { ...base, message };
-  data.injection_mode = normalizeInjectionMode(
-    options.injectionMode || data.injection_mode,
-    INJECTION_MODES.IMMEDIATE,
-  );
-  const source = normalizeMessageSource(options.source || data.source);
-  if (source) {
-    data.source = source;
-  } else {
-    delete data.source;
-  }
-  return data;
-}
-
-function getInjectionModeFromEvent(evt, fallback = INJECTION_MODES.IMMEDIATE) {
-  const data = evt && typeof evt.data === "object" && evt.data ? evt.data : {};
-  return normalizeInjectionMode(
-    data.injection_mode || evt?.injection_mode,
-    fallback,
-  );
-}
-
-module.exports = {
-  INJECTION_MODES,
-  normalizeInjectionMode,
-  normalizeMessageSource,
-  buildMessageData,
-  getInjectionModeFromEvent,
-};