u-foo 3.0.9 → 3.0.11

package/src/app/chat/streamState.js

@@ -0,0 +1,182 @@
+"use strict";
+
+/**
+ * Burst-coalescing sender + chat stream state (Phase 0B extraction from ChatApp).
+ */
+
+const { stripBlessedTags } = require("../../ui/chatLogModel");
+
+const STREAM_FLUSH_INTERVAL_MS = 80;
+
+function createThrottledSender(send, windowMs = 500) {
+  let lastSentAt = 0;
+  let timer = null;
+  const fire = () => {
+    timer = null;
+    lastSentAt = Date.now();
+    send();
+  };
+  return () => {
+    const now = Date.now();
+    const elapsed = now - lastSentAt;
+    if (elapsed >= windowMs) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      lastSentAt = now;
+      send();
+      return;
+    }
+    if (!timer) {
+      timer = setTimeout(fire, windowMs - elapsed);
+      if (typeof timer.unref === "function") timer.unref();
+    }
+  };
+}
+
+function createChatStreamState({
+  dispatch,
+  appendHistory,
+  displayNameForPublisher = (value) => value,
+  flushIntervalMs = STREAM_FLUSH_INTERVAL_MS,
+} = {}) {
+  const streams = new Map();
+  const pendingDeliveries = new Map();
+  const pendingDeltas = new Map();
+  let flushTimer = null;
+
+  function flushDeltas() {
+    if (flushTimer) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+    if (pendingDeltas.size === 0) return;
+    for (const batch of pendingDeltas.values()) {
+      dispatch({
+        type: "stream/delta",
+        publisher: batch.publisher,
+        delta: batch.parts.join(""),
+      });
+    }
+    pendingDeltas.clear();
+  }
+
+  function scheduleFlush() {
+    if (flushTimer) return;
+    flushTimer = setTimeout(flushDeltas, flushIntervalMs);
+    if (typeof flushTimer.unref === "function") flushTimer.unref();
+  }
+
+  function deliveryKey(agentId, agentLabel) {
+    return String(agentId || agentLabel || "").trim();
+  }
+
+  function markPendingDelivery(agentId, agentLabel) {
+    const key = deliveryKey(agentId, agentLabel);
+    if (!key) return;
+    const existing = pendingDeliveries.get(key) || { count: 0, keys: new Set() };
+    existing.count += 1;
+    for (const candidate of [agentId, agentLabel]) {
+      const value = String(candidate || "").trim();
+      if (value) {
+        pendingDeliveries.set(value, existing);
+        existing.keys.add(value);
+      }
+    }
+  }
+
+  function getPendingState(publisher, displayName) {
+    for (const candidate of [publisher, displayName]) {
+      const key = String(candidate || "").trim();
+      if (key && pendingDeliveries.has(key)) {
+        return { key, state: pendingDeliveries.get(key) };
+      }
+    }
+    return null;
+  }
+
+  function consumePendingDelivery(publisher, displayName) {
+    const hit = getPendingState(publisher, displayName);
+    if (!hit) return false;
+    hit.state.count -= 1;
+    if (hit.state.count <= 0) {
+      for (const key of hit.state.keys || []) pendingDeliveries.delete(key);
+    }
+    return true;
+  }
+
+  function beginStream(publisher, prefix, continuationPrefix, meta) {
+    const key = String(publisher || "bus");
+    let state = streams.get(key);
+    if (state) return state;
+    const displayName = stripBlessedTags(prefix || displayNameForPublisher(key) || key)
+      .replace(/\s*·\s*$/, "")
+      .trim() || displayNameForPublisher(key) || key;
+    state = {
+      publisher: key,
+      displayName,
+      prefix,
+      continuationPrefix,
+      parts: [],
+      meta: meta || {},
+    };
+    streams.set(key, state);
+    dispatch({ type: "stream/begin", publisher: displayName });
+    return state;
+  }
+
+  function appendStreamDelta(state, delta) {
+    if (!state || !delta) return;
+    const text = String(delta || "");
+    state.parts.push(text);
+    let batch = pendingDeltas.get(state.publisher);
+    if (!batch) {
+      batch = { publisher: state.displayName || state.publisher, parts: [] };
+      pendingDeltas.set(state.publisher, batch);
+    }
+    batch.parts.push(text);
+    scheduleFlush();
+  }
+
+  function finalizeStream(publisher, meta, reason = "") {
+    const key = String(publisher || "bus");
+    const state = streams.get(key);
+    if (!state) return;
+    flushDeltas();
+    dispatch({ type: "stream/end" });
+    if (typeof appendHistory === "function") {
+      const full = state.parts.join("");
+      const text = state.displayName
+        ? `${state.displayName}: ${full}`
+        : full;
+      appendHistory("bus", text, { ...(meta || state.meta || {}), stream_done: true, stream_reason: reason });
+    }
+    streams.delete(key);
+  }
+
+  function hasStream(publisher) {
+    return streams.has(String(publisher || "bus"));
+  }
+
+  return {
+    markPendingDelivery,
+    getPendingState,
+    consumePendingDelivery,
+    beginStream,
+    appendStreamDelta,
+    finalizeStream,
+    hasStream,
+    flushDeltas,
+  };
+}
+
+/** @deprecated Prefer createChatStreamState. */
+const createInkStreamState = createChatStreamState;
+
+module.exports = {
+  STREAM_FLUSH_INTERVAL_MS,
+  createThrottledSender,
+  createChatStreamState,
+  createInkStreamState,
+};

package/src/app/cli/features/doctor.js

@@ -13,6 +13,27 @@ class RepoDoctor {
     this.failed = true;
   }
 
+  reportTui() {
+    try {
+      const { resolveTuiLaunchPlan, resolveUfooTuiBinary } = require("../../../ui/tuiLauncher");
+      const binary = resolveUfooTuiBinary();
+      const plan = resolveTuiLaunchPlan({ mode: process.env.UFOO_TUI || "auto" });
+      console.log("TUI:");
+      console.log(`- UFOO_TUI=${process.env.UFOO_TUI || "auto"} → ${plan.mode} (${plan.reason})`);
+      if (binary) {
+        console.log(`- binary: ${binary}${plan.version ? ` (${plan.version})` : ""}`);
+      } else {
+        console.log("- binary: missing (required; Ink TUI removed)");
+      }
+      console.log("- force: UFOO_TUI=rust | UFOO_TUI_BIN=/path/to/ufoo-tui");
+      if (plan.mode === "error") {
+        console.log(`- note: chat/ucode will fail until ufoo-tui is built (${plan.reason})`);
+      }
+    } catch (err) {
+      console.log(`TUI: unavailable (${err && err.message ? err.message : err})`);
+    }
+  }
+
   run() {
     const skillsDir = path.join(this.repoRoot, "SKILLS");
     const contextSkill = path.join(skillsDir, "uctx", "SKILL.md");
@@ -30,6 +51,7 @@ class RepoDoctor {
     console.log("Skills:");
     if (fs.existsSync(contextSkill)) console.log(`- uctx: ${contextSkill}`);
     if (fs.existsSync(busSkill)) console.log(`- ubus: ${busSkill}`);
+    this.reportTui();
 
     if (this.failed) {
       console.log("Status: FAILED");

package/src/code/UcodeController.js

@@ -0,0 +1,156 @@
+"use strict";
+
+/**
+ * Headless UcodeController — task serial queue, cancel, view ports.
+ *
+ * Runner/tools/session stay in src/code/*; Ink/Rust hosts attach via ports.
+ */
+
+function createUcodeController({
+  projectRoot = process.cwd(),
+  ports = {},
+} = {}) {
+  const view = {
+    dispatch: typeof ports.dispatch === "function" ? ports.dispatch : () => {},
+    setStatus: typeof ports.setStatus === "function" ? ports.setStatus : () => {},
+    appendLog: typeof ports.appendLog === "function" ? ports.appendLog : () => {},
+  };
+
+  let started = false;
+  let abortController = null;
+  let chain = Promise.resolve();
+  let queueDepth = 0;
+
+  function start() {
+    started = true;
+  }
+
+  function stop() {
+    if (abortController) {
+      try {
+        abortController.abort();
+      } catch {
+        // ignore
+      }
+      abortController = null;
+    }
+    queueDepth = 0;
+    started = false;
+  }
+
+  function beginTask() {
+    abortController = new AbortController();
+    queueDepth = Math.max(1, queueDepth);
+    return abortController;
+  }
+
+  function endTask() {
+    if (queueDepth > 0) queueDepth -= 1;
+    if (queueDepth === 0) abortController = null;
+  }
+
+  function cancelTask() {
+    if (abortController) abortController.abort();
+  }
+
+  function isBusy() {
+    return queueDepth > 0;
+  }
+
+  /**
+   * Serialize async work so NL / auto-bus / resume never overlap.
+   * AbortController is allocated synchronously so cancel works before the slot starts.
+   */
+  function runExclusive(fn) {
+    const abort = new AbortController();
+    queueDepth += 1;
+    abortController = abort;
+    const run = chain.then(async () => {
+      if (!started) {
+        return null;
+      }
+      abortController = abort;
+      try {
+        if (abort.signal.aborted) {
+          const err = new Error("aborted");
+          err.name = "AbortError";
+          throw err;
+        }
+        return await fn(abort);
+      } finally {
+        queueDepth = Math.max(0, queueDepth - 1);
+        if (abortController === abort) abortController = null;
+      }
+    });
+    chain = run.catch(() => {});
+    return run;
+  }
+
+  return {
+    projectRoot,
+    view,
+    isStarted: () => started,
+    isBusy,
+    start,
+    stop,
+    beginTask,
+    endTask,
+    cancelTask,
+    runExclusive,
+    getAbortSignal: () => (abortController ? abortController.signal : null),
+  };
+}
+
+/**
+ * Throttle thinking_delta → status.set so fast streams don't flood the UI.
+ */
+function createThinkingStatusPublisher(publish, options = {}) {
+  const intervalMs = Number(options.intervalMs) > 0 ? Number(options.intervalMs) : 120;
+  let tail = "";
+  let timer = null;
+  let lastFlush = 0;
+
+  function collapse(text) {
+    const raw = String(text || "").replace(/\s+/g, " ").trim();
+    if (!raw) return "Thinking…";
+    return raw.length > 72 ? `${raw.slice(-72)}` : raw;
+  }
+
+  function flush() {
+    timer = null;
+    lastFlush = Date.now();
+    publish("status.set", {
+      text: collapse(tail),
+      busy: true,
+    });
+  }
+
+  function onThinkingDelta(chunk) {
+    tail += String(chunk || "");
+    const elapsed = Date.now() - lastFlush;
+    if (elapsed >= intervalMs) {
+      flush();
+      return;
+    }
+    if (!timer) {
+      timer = setTimeout(flush, Math.max(16, intervalMs - elapsed));
+      if (typeof timer.unref === "function") timer.unref();
+    }
+  }
+
+  function reset() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    tail = "";
+    lastFlush = 0;
+  }
+
+  return { onThinkingDelta, reset, flush };
+}
+
+module.exports = {
+  createUcodeController,
+  createThinkingStatusPublisher,
+};

package/src/code/context/planGraphService.js

@@ -121,6 +121,10 @@ function finalizeTerminalPrimaryPlan(executionState = null, planGraph = null, ad
   const pg = planGraph && typeof planGraph === "object" ? planGraph : null;
   if (!pg || !pg.graphId) return null;
   if (!advance || String(advance.yieldReason || "") !== "graph_terminal") return null;
+  // TaskLoop children may briefly sit in planGraph during processTaskRun;
+  // never archive them as the Agent Loop primary (they stay in graphs[]).
+  const ownerKind = String((pg.owner && pg.owner.kind) || "agent_loop").trim();
+  if (ownerKind === "task_loop") return null;
 
   const completionSummary = buildPlanCompletionSummary(pg, advance);
   const archived = archivePlanGraph(executionState, pg, { reason: "graph_terminal" });

package/src/code/repl.js

@@ -350,10 +350,11 @@ async function runUcodeCoreAgent({
       runNaturalLanguageTask,
       runUbusCommand,
       formatNlResult,
+      submitUserInteractionAnswer,
       workspaceRoot,
-  state,
-  resumeSessionState,
-  persistSessionState,
+      state,
+      resumeSessionState,
+      persistSessionState,
       autoBus: {
         enabled: shouldAutoConsumeBus(process.env.UFOO_SUBSCRIBER_ID || ""),
         getPendingCount: () => getPendingBusCount(state.workspaceRoot || workspaceRoot, process.env.UFOO_SUBSCRIBER_ID || ""),

package/src/code/runtime/taskLoop.js

@@ -263,10 +263,10 @@ function processTaskRun(executionState = null, taskRunId = "", options = {}) {
   live.lastFocusText = renderTaskFocusText(focus);
   putTaskRun(executionState, live);
 
-  // Advance child graph tools if runTool provided
+  // Advance child graph tools if runTool provided. Target via graphId so
+  // runPlanGraphCommand keeps the Agent Loop primary intact and does not
+  // treat the TaskLoop child as a terminal primary plan.
   if (typeof options.runTool === "function") {
-    const previousActive = executionState.planGraph;
-    executionState.planGraph = child;
     const wrappedRunTool = (toolInput = {}) => {
       const current = getTaskRun(executionState, taskRunId);
       if (!current || current.cancelRequested || current.status === "cancelling") {
@@ -296,62 +296,58 @@ function processTaskRun(executionState = null, taskRunId = "", options = {}) {
       });
       return options.runTool(toolInput);
     };
-    try {
-      const advanced = runPlanGraphCommand({
-        operation: "patch",
-        operations: [],
-        commandId: `advance_${live.id}_${Date.now()}`,
-      }, {
-        executionState,
-        runTool: wrappedRunTool,
-        autoAdvance: true,
-        knownTools: options.knownTools,
+    const advanced = runPlanGraphCommand({
+      operation: "patch",
+      graphId: live.childGraphId,
+      operations: [],
+      commandId: `advance_${live.id}_${Date.now()}`,
+    }, {
+      executionState,
+      runTool: wrappedRunTool,
+      autoAdvance: true,
+      knownTools: options.knownTools,
+    });
+    const after = getGraph(executionState, live.childGraphId);
+    if (after) {
+      after.owner = child.owner || after.owner;
+      after.parentGraphId = child.parentGraphId || after.parentGraphId;
+      after.parentNodeId = child.parentNodeId || after.parentNodeId;
+      setGraph(executionState, after);
+    }
+    casTaskRunStatus(executionState, live.id, {
+      expectedStatus: "running",
+      nextStatus: "running",
+      phase: after && after.waitingFor ? "waiting_model" : "executing_tools",
+    });
+    syncParentNodeFromRun(executionState, getTaskRun(executionState, taskRunId));
+
+    if (after && after.waitingFor) {
+      routeGraphYield(executionState, {
+        graph: after,
+        reason: after.lastYieldReason || "llm_required",
+        waitingFor: after.waitingFor,
       });
-      // Persist child back
-      if (executionState.planGraph) {
-        executionState.planGraph.owner = child.owner;
-        executionState.planGraph.parentGraphId = child.parentGraphId;
-        executionState.planGraph.parentNodeId = child.parentNodeId;
-        setGraph(executionState, executionState.planGraph);
-      }
-      const after = getGraph(executionState, live.childGraphId) || executionState.planGraph;
-      casTaskRunStatus(executionState, live.id, {
-        expectedStatus: "running",
-        nextStatus: "running",
-        phase: after && after.waitingFor ? "waiting_model" : "executing_tools",
+      enqueueTaskEvent(executionState, live.id, {
+        kind: "model_turn",
+        waitingFor: after.waitingFor,
+        focusText: live.lastFocusText,
       });
-      syncParentNodeFromRun(executionState, getTaskRun(executionState, taskRunId));
-
-      if (after && after.waitingFor) {
-        routeGraphYield(executionState, {
-          graph: after,
-          reason: after.lastYieldReason || "llm_required",
-          waitingFor: after.waitingFor,
-        });
-        enqueueTaskEvent(executionState, live.id, {
-          kind: "model_turn",
-          waitingFor: after.waitingFor,
-          focusText: live.lastFocusText,
-        });
-        return {
-          ok: true,
-          status: "running",
-          yieldReason: "llm_required",
-          focusText: live.lastFocusText,
-          waitingFor: after.waitingFor,
-          advance: advanced.modelPayload || advanced,
-        };
-      }
       return {
         ok: true,
         status: "running",
-        yieldReason: "awaiting_complete_task",
+        yieldReason: "llm_required",
         focusText: live.lastFocusText,
+        waitingFor: after.waitingFor,
         advance: advanced.modelPayload || advanced,
       };
-    } finally {
-      executionState.planGraph = previousActive;
     }
+    return {
+      ok: true,
+      status: "running",
+      yieldReason: "awaiting_complete_task",
+      focusText: live.lastFocusText,
+      advance: advanced.modelPayload || advanced,
+    };
   }
 
   enqueueTaskEvent(executionState, live.id, {

package/src/code/tui.js

@@ -38,8 +38,19 @@ const {
 } = fmt;
 
 function runUcodeTui(props = {}) {
-  const { runUcodeInkTui } = require("../ui/ink/UcodeApp");
-  return runUcodeInkTui(props);
+  const { resolveTuiLaunchPlan } = require("../ui/tuiLauncher");
+  const plan = resolveTuiLaunchPlan({
+    mode: props.tuiMode || process.env.UFOO_TUI,
+    surface: "ucode",
+  });
+  if (plan.mode !== "rust") {
+    const err = new Error(`Rust TUI unavailable (${plan.reason})`);
+    err.code = "UFOO_TUI_UNAVAILABLE";
+    err.plan = plan;
+    throw err;
+  }
+  const { runUcodeRust } = require("../ui/rustUcodeHost");
+  return runUcodeRust({ ...props, tuiMode: "rust" });
 }
 
 module.exports = {