u-foo 3.0.9 → 3.0.11

package/src/ui/scrollbackReplay.js

@@ -0,0 +1,82 @@
+"use strict";
+
+/**
+ * Phase 2 replay harness: apply a transcript event list to a pure reducer
+ * shape used by Rust scrollback (JS mirror for fixtures).
+ */
+
+const DEFAULT_CAP = 4000;
+
+function createScrollbackState({ cap = DEFAULT_CAP } = {}) {
+  return {
+    entries: [],
+    cap,
+    scrollOffset: 0,
+    followTail: true,
+  };
+}
+
+function applyScrollbackEvent(state, event) {
+  const next = {
+    ...state,
+    entries: state.entries.slice(),
+  };
+  const name = event && event.name;
+  const payload = (event && event.payload) || {};
+  if (name === "transcript.reset" || name === "app.snapshot") {
+    if (name === "app.snapshot" && Array.isArray(payload.entries)) {
+      next.entries = payload.entries.map((row, i) => ({
+        id: row.id || `e-${i}`,
+        kind: row.kind || "system",
+        text: String(row.text || ""),
+        speaker: String(row.speaker || ""),
+      }));
+    } else if (name === "transcript.reset") {
+      next.entries = [];
+    }
+    next.scrollOffset = 0;
+    next.followTail = true;
+  } else if (name === "transcript.append") {
+    next.entries.push({
+      id: payload.id || `e-${next.entries.length}`,
+      kind: payload.kind || "system",
+      text: String(payload.text || ""),
+      speaker: String(payload.speaker || ""),
+    });
+  } else if (name === "stream.delta") {
+    const id = payload.id || "stream";
+    const idx = [...next.entries].reverse().findIndex((e) => e.id === id);
+    if (idx >= 0) {
+      const real = next.entries.length - 1 - idx;
+      next.entries[real] = {
+        ...next.entries[real],
+        text: `${next.entries[real].text}${payload.text || payload.delta || ""}`,
+      };
+    } else {
+      next.entries.push({
+        id,
+        kind: "assistant",
+        text: String(payload.text || payload.delta || ""),
+        speaker: String(payload.speaker || ""),
+      });
+    }
+  }
+  while (next.entries.length > next.cap) next.entries.shift();
+  if (next.followTail) next.scrollOffset = 0;
+  return next;
+}
+
+function replayScrollbackEvents(events, options = {}) {
+  let state = createScrollbackState(options);
+  for (const event of events || []) {
+    state = applyScrollbackEvent(state, event);
+  }
+  return state;
+}
+
+module.exports = {
+  DEFAULT_CAP,
+  createScrollbackState,
+  applyScrollbackEvent,
+  replayScrollbackEvents,
+};

package/src/ui/settingsBridge.js

@@ -0,0 +1,49 @@
+"use strict";
+
+/**
+ * Shared launch-mode / agent-provider options for Ink + Rust chat hosts.
+ */
+
+const MODE_OPTIONS = Object.freeze(["auto", "host", "terminal", "tmux", "internal"]);
+
+const PROVIDER_OPTIONS = Object.freeze([
+  { label: "codex", value: "codex-cli" },
+  { label: "claude", value: "claude-cli" },
+  { label: "agy", value: "agy-cli" },
+  { label: "kimi", value: "kimi-cli" },
+]);
+
+function buildSettingsSnapshot(settings = {}) {
+  const { normalizeLaunchMode, normalizeAgentProvider } = require("../config");
+  const launchMode = normalizeLaunchMode(settings.launchMode || "auto");
+  const agentProvider = normalizeAgentProvider(settings.agentProvider || "codex-cli");
+  return {
+    launch_mode: launchMode,
+    agent_provider: agentProvider,
+    mode_options: MODE_OPTIONS.slice(),
+    provider_options: PROVIDER_OPTIONS.map((opt) => ({ ...opt })),
+  };
+}
+
+function applySettingsPatch(projectRoot, patch = {}) {
+  const { saveConfig, normalizeLaunchMode, normalizeAgentProvider } = require("../config");
+  const next = {};
+  if (patch.launch_mode != null || patch.launchMode != null) {
+    next.launchMode = normalizeLaunchMode(patch.launch_mode || patch.launchMode);
+  }
+  if (patch.agent_provider != null || patch.agentProvider != null) {
+    next.agentProvider = normalizeAgentProvider(patch.agent_provider || patch.agentProvider);
+  }
+  if (Object.keys(next).length === 0) {
+    return { ok: false, error: "empty settings patch" };
+  }
+  saveConfig(projectRoot, next);
+  return { ok: true, settings: buildSettingsSnapshot({ ...patch, ...next }) };
+}
+
+module.exports = {
+  MODE_OPTIONS,
+  PROVIDER_OPTIONS,
+  buildSettingsSnapshot,
+  applySettingsPatch,
+};

package/src/ui/toolMergeBridge.js

@@ -0,0 +1,66 @@
+"use strict";
+
+/**
+ * Shared tool-merge → ufoo-ui tool.* event helpers for Rust hosts.
+ */
+
+const fmt = require("./format");
+
+const EXIT_SUSPEND = 75;
+
+function createToolMergePublisher(publish) {
+  let merge = null;
+  let mergeId = 1;
+  let scope = 0;
+
+  function beginScope() {
+    flush();
+    scope += 1;
+  }
+
+  function flush() {
+    if (!merge || !Array.isArray(merge.entries) || merge.entries.length === 0) {
+      merge = null;
+      return;
+    }
+    const summary = fmt.buildMergedToolSummaryText(merge.entries);
+    const detail = fmt.buildMergedToolExpandedLines(merge.entries).join("\n");
+    const row = typeof fmt.buildToolMergeRowText === "function"
+      ? fmt.buildToolMergeRowText(merge.entries)
+      : (merge.entries.length >= 2
+        ? `· ${summary} (Ctrl+O expand)`
+        : summary);
+    publish("tool.group", {
+      id: `tool-merge-${merge.id}`,
+      summary: row || summary,
+      detail,
+      expanded_text: detail,
+      count: merge.entries.length,
+    });
+    merge = null;
+  }
+
+  function pushTool(entry = {}) {
+    merge = fmt.appendToolMergeEntry(merge, entry, scope, mergeId);
+    if (merge && merge.id) mergeId = Math.max(mergeId, Number(merge.id) + 1);
+    // Live collapsed summary while group grows.
+    if (merge) {
+      publish("tool.start", {
+        id: `tool-merge-${merge.id}`,
+        summary: fmt.buildMergedToolSummaryText(merge.entries),
+      });
+    }
+  }
+
+  return {
+    beginScope,
+    flush,
+    pushTool,
+    EXIT_SUSPEND,
+  };
+}
+
+module.exports = {
+  EXIT_SUSPEND,
+  createToolMergePublisher,
+};

package/src/ui/tuiLauncher.js

@@ -0,0 +1,105 @@
+"use strict";
+
+/**
+ * Resolve / spawn ufoo-tui. Terminal UI is Rust-only.
+ *
+ * UFOO_TUI=auto|rust → rust when binary+version probe OK, else error.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const PROTOCOL = "ufoo-ui/1";
+
+function normalizeTuiMode(value = process.env.UFOO_TUI) {
+  const raw = String(value || "auto").trim().toLowerCase();
+  if (raw === "rust") return "rust";
+  return "auto";
+}
+
+function candidateBinaryPaths() {
+  const out = [];
+  if (process.env.UFOO_TUI_BIN) {
+    out.push(String(process.env.UFOO_TUI_BIN));
+    return out;
+  }
+  const platform = `${process.platform}-${process.arch}`;
+  const root = path.resolve(__dirname, "../..");
+  out.push(path.join(root, "target/release/ufoo-tui"));
+  out.push(path.join(root, "target/debug/ufoo-tui"));
+  out.push(path.join(root, "crates/ufoo-tui/target/release/ufoo-tui"));
+  out.push(path.join(root, "crates/ufoo-tui/target/debug/ufoo-tui"));
+  out.push(path.join(root, "dist/tui", platform, "ufoo-tui"));
+  try {
+    const optional = require.resolve(`@u-foo/tui-${platform}/ufoo-tui`);
+    out.push(optional);
+  } catch {
+    // optional package not installed
+  }
+  return out;
+}
+
+function resolveUfooTuiBinary() {
+  for (const candidate of candidateBinaryPaths()) {
+    try {
+      if (candidate && fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+        return candidate;
+      }
+    } catch {
+      // continue
+    }
+  }
+  return null;
+}
+
+function probeBinaryVersion(binaryPath) {
+  try {
+    const result = spawnSync(binaryPath, ["--version"], {
+      encoding: "utf8",
+      timeout: 3000,
+    });
+    if (result.status !== 0) return null;
+    return String(result.stdout || result.stderr || "").trim();
+  } catch {
+    return null;
+  }
+}
+
+function resolveTuiLaunchPlan({
+  mode = normalizeTuiMode(),
+  surface = "chat",
+} = {}) {
+  const normalized = normalizeTuiMode(mode);
+  const binary = resolveUfooTuiBinary();
+  const version = binary ? probeBinaryVersion(binary) : null;
+
+  if (!binary || !version) {
+    return {
+      mode: "error",
+      binary,
+      version,
+      protocol: PROTOCOL,
+      reason: binary ? "version_probe_failed" : "binary_missing",
+      surface,
+    };
+  }
+
+  return {
+    mode: "rust",
+    binary,
+    version,
+    protocol: PROTOCOL,
+    reason: normalized === "rust" ? "forced_rust" : "auto_prefer_rust",
+    surface,
+  };
+}
+
+module.exports = {
+  PROTOCOL,
+  normalizeTuiMode,
+  resolveUfooTuiBinary,
+  probeBinaryVersion,
+  resolveTuiLaunchPlan,
+  candidateBinaryPaths,
+};

package/src/ui/ucodeStatusLine.js

@@ -0,0 +1,74 @@
+"use strict";
+
+/**
+ * Pure ucode status-line helpers (shared by Rust host tests / plan UI).
+ */
+
+const fmt = require("./format");
+
+function inferStatusType(text = "", requestedType = "") {
+  const type = String(requestedType || "").trim().toLowerCase();
+  if (type === "done" || type === "success" || type === "error" || type === "idle" || type === "none") {
+    return type;
+  }
+  const clean = String(text || "").trim();
+  if (/^[✗!]/.test(clean) || /\b(error|failed|failure)\b/i.test(clean) || /失败|错误/.test(clean)) return "error";
+  if (
+    /^[✓✔]/.test(clean) ||
+    /^(done|complete|completed|finished|success|succeeded|ready)\b/i.test(clean) ||
+    /\bdone\s*$/i.test(clean) ||
+    /完成|成功/.test(clean)
+  ) return "done";
+  return type || "thinking";
+}
+
+function collapseThinkingTail(text, maxChars = 80) {
+  const collapsed = String(text || "").replace(/\s+/g, " ").trim();
+  const parsed = Number(maxChars);
+  const limit = Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 80;
+  if (!collapsed) return "";
+
+  let candidate = collapsed;
+  const boldParts = collapsed.match(/\*\*[^*]+\*\*/g);
+  if (boldParts && boldParts.length > 0) {
+    candidate = boldParts[boldParts.length - 1].replace(/\*/g, "").trim() || candidate;
+  } else {
+    const clauses = collapsed.split(/(?<=[.!?。！？])\s+/).map((part) => part.trim()).filter(Boolean);
+    if (clauses.length > 1) candidate = clauses[clauses.length - 1];
+  }
+
+  if (candidate.length <= limit) return candidate;
+  return `…${candidate.slice(-(limit - 1))}`;
+}
+
+function computeStatusText(status, spinnerTick, backgroundSuffix = "", idlePlanHint = "") {
+  const message = String((status && status.message) || "");
+  const suffix = String(backgroundSuffix || "");
+  if (!message) {
+    const hint = String(idlePlanHint || "").trim();
+    return hint ? `UCODE · Ready · ${hint}${suffix}` : `UCODE · Ready${suffix}`;
+  }
+  const type = inferStatusType(message, status && status.type);
+  if (type === "done" || type === "success") {
+    const clean = message.trim();
+    return `${/^[✓✔]/.test(clean) ? clean : `✓ ${clean}`}${suffix}`;
+  }
+  if (type === "error") {
+    const clean = message.trim();
+    return `${/^[✗!]/.test(clean) ? clean : `✗ ${clean}`}${suffix}`;
+  }
+  if (type === "idle" || type === "none") return `${message.trim() || "UCODE · Ready"}${suffix}`;
+  const indicators = fmt.STATUS_INDICATORS[type] || fmt.STATUS_INDICATORS.thinking;
+  const indicator = indicators[Math.max(0, Math.floor(Number(spinnerTick) || 0)) % indicators.length];
+  const startedAt = Number.isFinite(status && status.startedAt) ? status.startedAt : 0;
+  const timerText = status && status.showTimer && startedAt
+    ? ` (${fmt.formatPendingElapsed(Date.now() - startedAt)}, esc cancel)`
+    : "";
+  return `${indicator} ${message}${timerText}${suffix}`;
+}
+
+module.exports = {
+  inferStatusType,
+  collapseThinkingTail,
+  computeStatusText,
+};