u-foo 2.5.15 → 3.0.1

package/src/code/providers/anthropicMessagesTransport.js

@@ -0,0 +1,93 @@
+"use strict";
+
+const { assertTransport } = require("./transportContract");
+
+/**
+ * Anthropic Messages API transport adapter.
+ * @param {{
+ *   resolveUrl: Function,
+ *   runTurn: Function,
+ *   toJsonString: Function,
+ *   clipText: Function,
+ * }} deps
+ */
+function createAnthropicMessagesTransport(deps = {}) {
+  const {
+    resolveUrl,
+    runTurn,
+    toJsonString,
+    clipText,
+  } = deps;
+
+  const transport = {
+    name: "anthropic-messages",
+    resolveUrl,
+    prepareMessages({ messages, prompt }) {
+      messages.push({
+        role: "user",
+        content: String(prompt || ""),
+      });
+    },
+    runTurn,
+    getToolCalls(turnResult) {
+      return Array.isArray(turnResult.toolCalls) ? turnResult.toolCalls : [];
+    },
+    appendFinalAssistantMessage({ messages, turnResult }) {
+      const assistantContent = Array.isArray(turnResult.assistantContent)
+        ? turnResult.assistantContent
+        : [];
+      if (assistantContent.length > 0) {
+        messages.push({
+          role: "assistant",
+          content: assistantContent,
+        });
+      } else if (String(turnResult.text || "").trim()) {
+        messages.push({
+          role: "assistant",
+          content: [
+            {
+              type: "text",
+              text: String(turnResult.text || ""),
+            },
+          ],
+        });
+      }
+    },
+    prepareToolCalls({ messages, turnResult, toolCalls }) {
+      const assistantContent = Array.isArray(turnResult.assistantContent)
+        ? turnResult.assistantContent
+        : [];
+
+      messages.push({
+        role: "assistant",
+        content: assistantContent,
+      });
+
+      return toolCalls.map((call) => ({
+        name: call.name,
+        args: call.args,
+        source: call,
+      }));
+    },
+    appendToolResult({ collected, call, toolResult }) {
+      collected.push({
+        type: "tool_result",
+        tool_use_id: String(call.source.id || ""),
+        content: clipText(toJsonString(toolResult), 12000),
+        is_error: Boolean(!toolResult || toolResult.ok === false),
+      });
+    },
+    flushToolResults({ messages, collected }) {
+      messages.push({
+        role: "user",
+        content: collected,
+      });
+    },
+  };
+
+  return assertTransport(transport, "anthropic-messages");
+}
+
+module.exports = {
+  createAnthropicMessagesTransport,
+};

package/src/code/providers/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  ...require("./transportContract"),
+  ...require("./openaiChatTransport"),
+  ...require("./anthropicMessagesTransport"),
+};

package/src/code/providers/openaiChatTransport.js

@@ -0,0 +1,98 @@
+"use strict";
+
+const { randomUUID } = require("crypto");
+const { assertTransport } = require("./transportContract");
+
+/**
+ * OpenAI-compatible chat-completions transport adapter.
+ * @param {{
+ *   resolveUrl: Function,
+ *   runTurn: Function,
+ *   normalizeToolName: Function,
+ *   normalizeToolCallArgs: Function,
+ *   toJsonString: Function,
+ *   clipText: Function,
+ * }} deps
+ */
+function createOpenAiChatTransport(deps = {}) {
+  const {
+    resolveUrl,
+    runTurn,
+    normalizeToolName,
+    normalizeToolCallArgs,
+    toJsonString,
+    clipText,
+  } = deps;
+
+  const transport = {
+    name: "openai-chat",
+    resolveUrl,
+    prepareMessages({ messages, systemPrompt, prompt }) {
+      const systemText = String(systemPrompt || "").trim();
+      const hasSystem = messages.some((entry) => String(entry.role || "").trim() === "system");
+      if (systemText && !hasSystem) {
+        messages.unshift({ role: "system", content: systemText });
+      }
+      messages.push({ role: "user", content: String(prompt || "") });
+    },
+    runTurn,
+    getToolCalls(turnResult) {
+      return Array.isArray(turnResult.toolCalls)
+        ? turnResult.toolCalls.filter((call) => call && call.function && typeof call.function === "object")
+        : [];
+    },
+    appendFinalAssistantMessage({ messages, turnResult }) {
+      const text = String(turnResult.text || "").trim();
+      if (text) {
+        messages.push({
+          role: "assistant",
+          content: text,
+        });
+      }
+    },
+    prepareToolCalls({ messages, toolCalls }) {
+      const assistantToolCalls = [];
+      for (const call of toolCalls) {
+        const callId = String(call.id || `call_${randomUUID()}`);
+        const name = normalizeToolName(call.function.name || "");
+        const args = normalizeToolCallArgs(call.function.arguments || "");
+
+        assistantToolCalls.push({
+          id: callId,
+          type: "function",
+          function: {
+            name: name || String(call.function.name || ""),
+            arguments: toJsonString(args),
+          },
+        });
+      }
+
+      if (assistantToolCalls.length === 0) return null;
+
+      messages.push({
+        role: "assistant",
+        content: null,
+        tool_calls: assistantToolCalls,
+      });
+
+      return assistantToolCalls.map((toolCall) => ({
+        name: toolCall.function.name,
+        args: normalizeToolCallArgs(toolCall.function.arguments),
+        source: toolCall,
+      }));
+    },
+    appendToolResult({ messages, call, toolResult }) {
+      messages.push({
+        role: "tool",
+        tool_call_id: call.source.id,
+        content: clipText(toJsonString(toolResult), 12000),
+      });
+    },
+  };
+
+  return assertTransport(transport, "openai-chat");
+}
+
+module.exports = {
+  createOpenAiChatTransport,
+};

package/src/code/providers/transportContract.js

@@ -0,0 +1,46 @@
+"use strict";
+
+/**
+ * Transport contract for native Agent Loop Provider adapters.
+ *
+ * Transports own wire-format conversion and turn execution only.
+ * They must not decide Plan Mode, write leases, or tool batch policy.
+ *
+ * Required methods:
+ * - resolveUrl(baseUrl) → string
+ * - prepareMessages({ messages, systemPrompt?, prompt })
+ * - runTurn(params) → Promise<turnResult>
+ * - getToolCalls(turnResult) → array
+ * - appendFinalAssistantMessage({ messages, turnResult })
+ * - prepareToolCalls({ messages, turnResult?, toolCalls }) → pendingCalls|null
+ * - appendToolResult({ messages?, collected?, call, toolResult })
+ * - flushToolResults?({ messages, collected })  // Anthropic-style batch
+ */
+
+const TRANSPORT_NAMES = Object.freeze(["openai-chat", "anthropic-messages"]);
+
+function assertTransport(transport = null, name = "") {
+  if (!transport || typeof transport !== "object") {
+    throw new Error(`missing transport${name ? `: ${name}` : ""}`);
+  }
+  const required = [
+    "resolveUrl",
+    "prepareMessages",
+    "runTurn",
+    "getToolCalls",
+    "appendFinalAssistantMessage",
+    "prepareToolCalls",
+    "appendToolResult",
+  ];
+  for (const key of required) {
+    if (typeof transport[key] !== "function") {
+      throw new Error(`transport ${name || "?"} missing ${key}`);
+    }
+  }
+  return transport;
+}
+
+module.exports = {
+  TRANSPORT_NAMES,
+  assertTransport,
+};

package/src/code/repl.js

@@ -24,17 +24,24 @@ const {
 const { summarizeSessionUsage, formatSessionUsageStatus } = require("./usageStore");
 const { listUcodeCommandsForHelp } = require("./commands");
 const { applyUcodeModelCommand, suggestUcodeModels } = require("./modelCommand");
+const { applyUcodePlanCommand } = require("./context/planMode");
 
 function printPrompt(stdout = process.stdout) {
   stdout.write("> ");
 }
 
-function printUcodeBanner(stdout = process.stdout, { model = "", workspaceRoot = process.cwd(), sessionId = "" } = {}) {
+function printUcodeBanner(stdout = process.stdout, {
+  model = "",
+  workspaceRoot = process.cwd(),
+  sessionId = "",
+  planMode = false,
+} = {}) {
   stdout.write(`${buildUcodeBannerLines({
     model,
     engine: "ufoo-core",
     workspaceRoot,
     sessionId,
+    planMode,
     width: (stdout && stdout.columns) || 0,
   }).join("\n")}\n`);
 }
@@ -123,6 +130,22 @@ function runSingleCommand(line = "", workspaceRoot = process.cwd()) {
       model: nextModel,
     };
   }
+  const planMatch = text.match(/^(?:\/plan|plan)(?:\s+(.*))?$/i);
+  if (planMatch) {
+    const arg = String(planMatch[1] || "").trim().toLowerCase();
+    if (!arg || arg === "show" || arg === "status") return { kind: "plan", action: "show" };
+    if (arg === "on" || arg === "enable") return { kind: "plan", action: "on" };
+    if (arg === "off" || arg === "disable") return { kind: "plan", action: "off" };
+    if (arg === "clear") return { kind: "plan", action: "clear" };
+    if (arg === "hide") return { kind: "plan", action: "hide" };
+    if (arg === "focus") return { kind: "plan", action: "focus" };
+    if (arg === "debug") return { kind: "plan", action: "debug" };
+    if (arg === "toggle") return { kind: "plan", action: "toggle" };
+    return {
+      kind: "error",
+      output: "usage: /plan [on|off|show|hide|focus|debug|clear]",
+    };
+  }
   const skillsMatch = text.match(/^(?:\/skills|skills)(?:\s+(.*))?$/i);
   if (skillsMatch) {
     const args = String(skillsMatch[1] || "").trim().split(/\s+/).filter(Boolean);
@@ -259,6 +282,8 @@ async function runUcodeCoreAgent({
     resolveNlTaskTimeoutMs,
     resolveUcodeProviderModel,
     runNaturalLanguageTask,
+    resumeAfterUserInteraction,
+    submitUserInteractionAnswer,
   } = require("./agent");
   const resolvedWorkspaceRoot = resolveUfooProjectRoot(workspaceRoot);
   const resolvedUcode = resolveUcodeProviderModel({
@@ -315,6 +340,7 @@ async function runUcodeCoreAgent({
     model: state.model || "default",
     workspaceRoot: workspaceRoot,
     sessionId: state.sessionId,
+    planMode: Boolean(state.executionState && state.executionState.planMode),
   });
   printPrompt(stdout);
   const rl = readline.createInterface({
@@ -333,6 +359,7 @@ async function runUcodeCoreAgent({
     let autoBusQueued = false;
     let autoBusError = "";
     let closing = false;
+    let taskInFlight = false;
 
     const runAutoBusOnce = async () => {
       if (!autoBusEnabled || closing) return;
@@ -433,6 +460,10 @@ async function runUcodeCoreAgent({
           sessionId: state.sessionId,
         });
         stdout.write(`${formatSessionUsageStatus(usageSummary)}\n`);
+        const { formatPlanModeStatus } = require("./context/planMode");
+        if (state.executionState) {
+          stdout.write(`${formatPlanModeStatus(state.executionState).split("\n").slice(0, 5).join("\n")}\n`);
+        }
       }
       if (result.kind === "model") {
         const applied = applyUcodeModelCommand(state, result);
@@ -441,6 +472,11 @@ async function runUcodeCoreAgent({
           persistSessionState(state);
         }
       }
+      if (result.kind === "plan") {
+        const applied = applyUcodePlanCommand(state, result);
+        stdout.write(`${applied.output}\n`);
+        if (applied.ok) persistSessionState(state);
+      }
       if (result.kind === "ubus") {
         const ubusResult = await runUbusCommand(state, {
           workspaceRoot: runtimeWorkspace,
@@ -488,23 +524,29 @@ async function runUcodeCoreAgent({
           });
         }
 
-        const nlResult = await runNaturalLanguageTask(result.task, state, {
-          onDelta: state.jsonOutput
-            ? null
-            : async (delta) => {
-              const text = escapeStripper.write(String(delta || ""));
-              const safeText = stripBlessedTags(stripLeakedEscapeTags(text));
-              if (!safeText) return;
-              if (/[^\s]/.test(safeText)) {
-                streamedVisible = true;
-              }
-              if (streamBuffer) {
-                await streamBuffer.write(safeText);
-              } else {
-                stdout.write(safeText);
-              }
-            },
-        });
+        taskInFlight = true;
+        let nlResult;
+        try {
+          nlResult = await runNaturalLanguageTask(result.task, state, {
+            onDelta: state.jsonOutput
+              ? null
+              : async (delta) => {
+                const text = escapeStripper.write(String(delta || ""));
+                const safeText = stripBlessedTags(stripLeakedEscapeTags(text));
+                if (!safeText) return;
+                if (/[^\s]/.test(safeText)) {
+                  streamedVisible = true;
+                }
+                if (streamBuffer) {
+                  await streamBuffer.write(safeText);
+                } else {
+                  stdout.write(safeText);
+                }
+              },
+          });
+        } finally {
+          taskInFlight = false;
+        }
 
         if (!state.jsonOutput) {
           const tail = escapeStripper.flush();
@@ -547,6 +589,92 @@ async function runUcodeCoreAgent({
     };
 
     rl.on("line", (line) => {
+      const trimmed = normalizeLine(line);
+
+      // Pending approval/choice/chat takes priority over nudge / new NL.
+      try {
+        const { hasPendingUserInteraction } = require("./context/userInteraction");
+        if (
+          trimmed
+          && state.executionState
+          && hasPendingUserInteraction(state.executionState)
+        ) {
+          chain = chain.then(async () => {
+            let streamBuffer = null;
+            let streamedVisible = false;
+            const escapeStripper = createEscapeTagStripper();
+            if (!state.jsonOutput) {
+              streamBuffer = new StreamBuffer(stdout.write.bind(stdout), {
+                delay: 10,
+                chunkSize: 4,
+              });
+            }
+            taskInFlight = true;
+            let resumeResult;
+            try {
+              resumeResult = await submitUserInteractionAnswer(trimmed, state, {
+                onDelta: state.jsonOutput
+                  ? null
+                  : async (delta) => {
+                    const text = escapeStripper.write(String(delta || ""));
+                    const safeText = stripBlessedTags(stripLeakedEscapeTags(text));
+                    if (!safeText) return;
+                    if (/[^\s]/.test(safeText)) {
+                      streamedVisible = true;
+                    }
+                    if (streamBuffer) {
+                      await streamBuffer.write(safeText);
+                    } else {
+                      stdout.write(safeText);
+                    }
+                  },
+              });
+            } finally {
+              taskInFlight = false;
+            }
+            if (streamBuffer) {
+              await streamBuffer.finish();
+            }
+            const streamed = !state.jsonOutput && Boolean(resumeResult && resumeResult.streamed);
+            if (streamed && streamedVisible && resumeResult && resumeResult.streamLastChar !== "\n") {
+              stdout.write("\n");
+            }
+            if (!resumeResult || resumeResult.ok === false) {
+              stdout.write(`Error: ${(resumeResult && resumeResult.error) || "resume failed"}\n`);
+            } else if (resumeResult.shouldEchoSummary && resumeResult.echoSummaryText) {
+              stdout.write(`${resumeResult.echoSummaryText}\n`);
+            } else if (resumeResult.waitingUserInteraction) {
+              stdout.write("Still waiting for your reply.\n");
+            }
+            const persisted = persistSessionState(state);
+            if (!state.jsonOutput && (!persisted || persisted.ok === false)) {
+              stdout.write(`Warning: failed to persist session ${state.sessionId}: ${(persisted && persisted.error) || "unknown error"}\n`);
+            }
+            printPrompt(stdout);
+          }).catch((err) => {
+            stdout.write(`${JSON.stringify({ ok: false, error: err && err.message ? err.message : "resume failed" })}\n`);
+            printPrompt(stdout);
+          });
+          return;
+        }
+      } catch (err) {
+        stdout.write(`Error: ${err && err.message ? err.message : "interaction failed"}\n`);
+        printPrompt(stdout);
+        return;
+      }
+
+      // Mid-task NL input becomes a pending user reminder for the next LLM turn.
+      if (taskInFlight && trimmed && !/^\//.test(trimmed)) {
+        const { enqueueUserPrompt } = require("./context/userNudge");
+        const { emptyExecutionState } = require("./context/executionSegment");
+        if (!state.executionState || typeof state.executionState !== "object") {
+          state.executionState = emptyExecutionState();
+        }
+        enqueueUserPrompt(state.executionState, trimmed);
+        stdout.write("Queued user reminder for next model turn.\n");
+        printPrompt(stdout);
+        return;
+      }
       chain = chain.then(() => handleLine(line)).catch((err) => {
         stdout.write(`${JSON.stringify({ ok: false, error: err && err.message ? err.message : "agent loop failed" })}\n`);
         printPrompt(stdout);
@@ -640,5 +768,6 @@ module.exports = {
   parseAgentArgs,
   formatSessionUsageStatus,
   applyUcodeModelCommand,
+  applyUcodePlanCommand,
   suggestUcodeModels,
 };

package/src/code/runtime/agentWakeup.js

@@ -0,0 +1,58 @@
+"use strict";
+
+/**
+ * Drain Agent Loop mailbox into a turnDynamic block (never as user role).
+ */
+
+const { drainAgentMailbox, ensureMailbox } = require("./loopMailbox");
+
+function formatAgentRuntimeEvents(events = []) {
+  const list = Array.isArray(events) ? events : [];
+  if (list.length === 0) return "";
+  const lines = ["Runtime events (Agent Loop mailbox; not user messages):"];
+  for (const entry of list) {
+    if (!entry) continue;
+    if (entry.kind === "user") {
+      lines.push(`- user_nudge: ${String(entry.text || "").slice(0, 400)}`);
+      continue;
+    }
+    if (entry.kind === "runtime" && entry.event) {
+      const ev = entry.event;
+      const bits = [`type=${ev.type}`];
+      if (ev.taskId) bits.push(`taskId=${ev.taskId}`);
+      if (ev.taskRunId) bits.push(`taskRunId=${ev.taskRunId}`);
+      if (ev.result && ev.result.summary) bits.push(`summary=${String(ev.result.summary).slice(0, 200)}`);
+      if (ev.error && (ev.error.message || ev.error)) {
+        bits.push(`error=${String(ev.error.message || ev.error).slice(0, 200)}`);
+      }
+      if (Array.isArray(ev.readyNodes) && ev.readyNodes.length) {
+        bits.push(`readyNodes=[${ev.readyNodes.join(",")}]`);
+      }
+      lines.push(`- ${bits.join(" ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Peek without drain — for inspect. Prefer drainForAgentTurn for consumption.
+ */
+function peekAgentMailboxText(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  const box = ensureMailbox(state, "agentMailbox");
+  return formatAgentRuntimeEvents(box.queue || []);
+}
+
+function drainAgentMailboxForTurn(executionState = null) {
+  const events = drainAgentMailbox(executionState);
+  return {
+    events,
+    text: formatAgentRuntimeEvents(events),
+  };
+}
+
+module.exports = {
+  formatAgentRuntimeEvents,
+  peekAgentMailboxText,
+  drainAgentMailboxForTurn,
+};

package/src/code/runtime/graphOwner.js

@@ -0,0 +1,41 @@
+"use strict";
+
+/**
+ * Graph ownership: which loop consumes waiting_llm / yields.
+ */
+
+function agentLoopOwner(agentLoopId = "agent") {
+  return {
+    kind: "agent_loop",
+    agentLoopId: String(agentLoopId || "agent").trim() || "agent",
+  };
+}
+
+function taskLoopOwner(taskRunId = "") {
+  return {
+    kind: "task_loop",
+    taskRunId: String(taskRunId || "").trim(),
+  };
+}
+
+function normalizeGraphOwner(source = null) {
+  if (!source || typeof source !== "object") return agentLoopOwner();
+  const kind = String(source.kind || "").trim();
+  if (kind === "task_loop") {
+    const taskRunId = String(source.taskRunId || "").trim();
+    if (!taskRunId) return agentLoopOwner();
+    return taskLoopOwner(taskRunId);
+  }
+  return agentLoopOwner(source.agentLoopId);
+}
+
+function isTaskLoopOwner(owner = null) {
+  return Boolean(owner && owner.kind === "task_loop" && owner.taskRunId);
+}
+
+module.exports = {
+  agentLoopOwner,
+  taskLoopOwner,
+  normalizeGraphOwner,
+  isTaskLoopOwner,
+};

package/src/code/runtime/graphYieldRouter.js

@@ -0,0 +1,42 @@
+"use strict";
+
+/**
+ * Route graph yields to the owning loop mailbox.
+ */
+
+const { isTaskLoopOwner } = require("./graphOwner");
+const { enqueueAgentRuntime, enqueueTaskEvent } = require("./loopMailbox");
+const { createRuntimeEvent } = require("./runtimeEvents");
+
+function routeGraphYield(executionState = null, {
+  graph = null,
+  reason = "",
+  waitingFor = null,
+} = {}) {
+  const owner = graph && graph.owner ? graph.owner : null;
+  const graphId = graph && graph.graphId ? graph.graphId : "";
+  const payload = {
+    graphId,
+    reason: String(reason || "").trim() || "llm_required",
+    waitingFor: waitingFor || null,
+  };
+
+  if (isTaskLoopOwner(owner)) {
+    return enqueueTaskEvent(executionState, owner.taskRunId, {
+      kind: "graph_yield",
+      ...payload,
+    });
+  }
+
+  // Parent / agent-owned graph: surface as runtime event (not user message).
+  return enqueueAgentRuntime(executionState, createRuntimeEvent("parent_graph_ready_changed", {
+    readyNodes: waitingFor && waitingFor.id ? [waitingFor.id] : [],
+    graphId,
+    yieldReason: payload.reason,
+    waitingFor,
+  }));
+}
+
+module.exports = {
+  routeGraphYield,
+};

package/src/code/runtime/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+module.exports = {
+  ...require("./runtimeEvents"),
+  ...require("./graphOwner"),
+  ...require("./loopMailbox"),
+  ...require("./taskRun"),
+  ...require("./workspaceLease"),
+  ...require("./taskFocus"),
+  ...require("./taskLoop"),
+  ...require("./taskControl"),
+  ...require("./toolProvenance"),
+  ...require("./graphYieldRouter"),
+  ...require("./agentWakeup"),
+};