u-foo 2.5.14 → 3.0.0

package/src/code/tools/artifactRead.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const { loadArtifact, readArtifactSlice } = require("../context/artifacts");
+
+function runArtifactReadTool(args = {}, options = {}) {
+  const workspaceRoot = options.workspaceRoot || process.cwd();
+  const sessionId = String(options.sessionId || args.sessionId || "").trim();
+  const artifactId = String(args.artifactId || args.id || "").trim();
+  if (!artifactId) {
+    return { ok: false, error: "artifactId is required" };
+  }
+  if (!sessionId) {
+    return { ok: false, error: "sessionId is required for artifact_read" };
+  }
+
+  const loaded = loadArtifact(workspaceRoot, sessionId, artifactId);
+  if (!loaded.ok || !loaded.artifact) {
+    return { ok: false, error: loaded.error || "artifact not found", artifactId };
+  }
+
+  const selector = {};
+  if (args.startLine !== undefined) selector.startLine = args.startLine;
+  if (args.endLine !== undefined) selector.endLine = args.endLine;
+  if (args.maxChars !== undefined) selector.maxChars = args.maxChars;
+  if (args.tailLines !== undefined) selector.tailLines = args.tailLines;
+
+  const slice = readArtifactSlice(loaded.artifact, selector);
+  return {
+    ok: slice.ok !== false,
+    artifactId,
+    content: slice.content || "",
+    range: slice.range,
+    truncated: Boolean(slice.truncated),
+    error: slice.error || "",
+  };
+}
+
+module.exports = {
+  runArtifactReadTool,
+};

package/src/code/tools/askUser.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const { runAskUserTool } = require("../context/userInteraction");
+
+function runAskUserToolDispatch(args = {}, options = {}) {
+  return runAskUserTool(args, options);
+}
+
+module.exports = {
+  runAskUserTool: runAskUserToolDispatch,
+};

package/src/code/tools/planGraph.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const {
+  runPlanGraphCommand,
+  normalizePlanGraphCommand,
+} = require("../context/planGraphService");
+
+function runPlanGraphTool(args = {}, options = {}) {
+  const command = normalizePlanGraphCommand(args) || args;
+  const result = runPlanGraphCommand(command, {
+    executionState: options.executionState,
+    runTool: options.runTool,
+    autoAdvance: options.autoAdvance !== false,
+    parallel: options.parallel !== false,
+    knownTools: options.knownTools,
+    maxNodeRuns: options.maxNodeRuns,
+  });
+
+  const payload = result.modelPayload || result;
+  return {
+    ok: payload.status === "accepted",
+    ...payload,
+    executionState: result.executionState,
+  };
+}
+
+module.exports = {
+  runPlanGraphTool,
+};

package/src/code/tui.js

@@ -27,6 +27,7 @@ const {
   normalizeToolMergeEntry,
   parseActiveAgentsFromBusStatus,
   renderLogLinesWithMarkdown,
+  renderLogLinesWithMarkdownAnsi,
   resolveAgentSelectionOnDown,
   resolveHistoryDownTransition,
   shouldClearAgentSelectionOnUp,
@@ -51,6 +52,7 @@ module.exports = {
   parseActiveAgentsFromBusStatus,
   shouldUseUcodeTui,
   renderLogLinesWithMarkdown,
+  renderLogLinesWithMarkdownAnsi,
   shouldEnterAgentSelection,
   resolveAgentSelectionOnDown,
   cycleAgentSelectionIndex,

package/src/code/usageStore.js

@@ -92,10 +92,25 @@ function summarizeSessionUsage({ workspaceRoot = process.cwd(), sessionId = "" }
   return summary;
 }
 
+function formatSessionUsageStatus(summary = {}) {
+  const source = summary && typeof summary === "object" ? summary : {};
+  const input = Number(source.input) || 0;
+  const output = Number(source.output) || 0;
+  const cacheRead = Number(source.cacheRead) || 0;
+  const cacheCreation = Number(source.cacheCreation) || 0;
+  const denominator = cacheRead + input;
+  const hitRate = denominator > 0 ? (cacheRead / denominator) * 100 : 0;
+  return [
+    `Session tokens: input=${input} output=${output} cache_read=${cacheRead} cache_creation=${cacheCreation}`,
+    `Cache hit rate: ${hitRate.toFixed(1)}% (cache_read/(cache_read+input))`,
+  ].join("\n");
+}
+
 module.exports = {
   getUsageFilePath,
   buildUsageRecord,
   appendUsageRecord,
   createUsageSummary,
   summarizeSessionUsage,
+  formatSessionUsageStatus,
 };

package/src/ui/format/index.js

@@ -41,6 +41,7 @@ const TOOL_LABELS = {
   write: "Writing file",
   edit: "Editing file",
   bash: "Running command",
+  artifact_read: "Reading artifact",
 };
 
 const ANSI_PATTERN = /\x1B\[[0-9;?]*[ -/]*[@-~]/g;
@@ -128,7 +129,16 @@ function normalizeModelLabel(model = "") {
   return "default";
 }
 
-function buildUcodeBannerLines({ model = "", engine = "ufoo-core", nickname = "", agentId = "", workspaceRoot = "", sessionId = "", width = 0 } = {}) {
+function buildUcodeBannerLines({
+  model = "",
+  engine = "ufoo-core",
+  nickname = "",
+  agentId = "",
+  workspaceRoot = "",
+  sessionId = "",
+  width = 0,
+  planMode = false,
+} = {}) {
   const modelLabel = normalizeModelLabel(model);
   void width;
   void engine;
@@ -150,6 +160,9 @@ function buildUcodeBannerLines({ model = "", engine = "ufoo-core", nickname = ""
   const infoLines = [];
   infoLines.push(`${chalk.dim("Version:")} ${chalk.cyan.bold(UCODE_VERSION)}`);
   infoLines.push(`${chalk.dim("Model:")} ${chalk.yellow(modelLabel)}`);
+  if (planMode) {
+    infoLines.push(`${chalk.dim("Mode:")} ${chalk.magenta.bold("PLAN")}`);
+  }
   infoLines.push(`${chalk.dim("Dictionary:")} ${chalk.gray(shortPath)}`);
   const normalizedSessionId = String(sessionId || "").trim();
   if (normalizedSessionId) {
@@ -248,6 +261,130 @@ function renderLogLinesWithMarkdown(text = "", state = {}, escapeFn = (value) =>
   return renderMarkdownLines(text, state, escapeFn);
 }
 
+function renderLogLinesWithMarkdownAnsi(text = "", state = {}) {
+  const { renderMarkdownLinesAnsi } = require("./markdownRenderer");
+  return renderMarkdownLinesAnsi(text, state);
+}
+
+function createMarkdownTableBuffer() {
+  const { createMarkdownTableBuffer: create } = require("./markdownRenderer");
+  return create();
+}
+
+function isTableRowLine(line = "") {
+  const { isTableRowLine: check } = require("./markdownRenderer");
+  return check(line);
+}
+
+function messageContentText(message = {}) {
+  if (!message || typeof message !== "object") return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === "string") return part;
+      if (part && typeof part === "object" && part.text != null) return String(part.text);
+      return "";
+    }).join("");
+  }
+  return "";
+}
+
+function toolMessagePreview(message = {}) {
+  const raw = messageContentText(message).trim();
+  if (!raw) return "";
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      if (parsed.preview) return String(parsed.preview);
+      if (parsed.artifactId) return `artifact:${parsed.artifactId}`;
+    }
+  } catch {
+    // plain tool text
+  }
+  return raw;
+}
+
+/**
+ * Convert persisted nlMessages into ucode TUI log rows for resume/history.
+ * Applies the shared ANSI markdown renderer so restored assistant text matches
+ * live streaming output.
+ */
+function buildUcodeSessionLogEntries(messages = [], options = {}) {
+  const list = Array.isArray(messages) ? messages : [];
+  const markdownState = options.markdownState && typeof options.markdownState === "object"
+    ? options.markdownState
+    : { inCodeBlock: false };
+  const idPrefix = String(options.idPrefix || "h");
+  let seq = Number.isFinite(options.startSeq) ? Math.max(0, Math.floor(options.startSeq)) : 0;
+  const maxToolPreviewLines = Number.isFinite(options.maxToolPreviewLines)
+    ? Math.max(1, Math.floor(options.maxToolPreviewLines))
+    : 4;
+  const entries = [];
+
+  const pushLines = (text, kind) => {
+    const source = String(text == null ? "" : text);
+    let lines;
+    if (kind === "assistant" || kind === "error") {
+      try {
+        lines = renderLogLinesWithMarkdownAnsi(source, markdownState);
+        if (!Array.isArray(lines) || lines.length === 0) lines = source.split(/\r?\n/);
+      } catch {
+        lines = source.split(/\r?\n/);
+      }
+    } else {
+      lines = source.split(/\r?\n/);
+    }
+    for (const line of lines) {
+      entries.push({
+        id: `${idPrefix}-${seq}`,
+        text: String(line || ""),
+        kind,
+      });
+      seq += 1;
+    }
+  };
+
+  for (const message of list) {
+    if (!message || typeof message !== "object") continue;
+    const role = String(message.role || "").trim().toLowerCase();
+    if (role === "user") {
+      const text = messageContentText(message);
+      if (!text.trim()) continue;
+      const lines = text.split(/\r?\n/);
+      lines.forEach((line, index) => {
+        pushLines(index === 0 ? `› ${line}` : line, "user");
+      });
+      continue;
+    }
+    if (role === "assistant") {
+      const text = messageContentText(message);
+      if (text) pushLines(text, "assistant");
+      const calls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+      if (calls.length > 0) {
+        const names = calls
+          .map((call) => {
+            if (!call || typeof call !== "object") return "";
+            if (call.function && call.function.name) return String(call.function.name);
+            return String(call.name || "");
+          })
+          .map((name) => name.trim())
+          .filter(Boolean);
+        if (names.length > 0) pushLines(`⚙ ${names.join(" · ")}`, "system");
+      }
+      continue;
+    }
+    if (role === "tool") {
+      const preview = toolMessagePreview(message);
+      if (!preview.trim()) continue;
+      const clipped = preview.split(/\r?\n/).slice(0, maxToolPreviewLines).join("\n");
+      pushLines(clipped, "toolDetail");
+    }
+  }
+
+  return { entries, nextSeq: seq, markdownState };
+}
+
 function shouldEnterAgentSelection(inputValue = "") {
   const text = String(inputValue || "");
   const trimmed = text.trim();
@@ -514,6 +651,39 @@ function normalizeBashToolCommand(args = {}, payload = {}) {
   return [command, code].filter(Boolean).join(" · ");
 }
 
+function shortenPathDetail(value = "", maxChars = 72) {
+  const text = String(value || "").trim().replace(/\\/g, "/");
+  if (!text) return "";
+  const limit = Number.isFinite(maxChars) && maxChars > 8 ? Math.floor(maxChars) : 72;
+  if (text.length <= limit) return text;
+  return `…${text.slice(-(limit - 1))}`;
+}
+
+function normalizeToolLogDetail(tool = "", args = {}, payload = {}) {
+  const name = String(tool || "").trim().toLowerCase();
+  const argObj = args && typeof args === "object" ? args : {};
+  const resObj = payload && typeof payload === "object" ? payload : {};
+
+  if (name === "bash") return normalizeBashToolCommand(argObj, resObj);
+
+  if (name === "read" || name === "write" || name === "edit") {
+    const pathText = String(argObj.path || resObj.path || "").trim();
+    return shortenPathDetail(pathText);
+  }
+
+  if (name === "artifact_read") {
+    const artifactId = String(argObj.artifactId || argObj.id || resObj.artifactId || "").trim();
+    const rangeBits = [];
+    if (argObj.startLine != null) rangeBits.push(`L${argObj.startLine}`);
+    if (argObj.endLine != null) rangeBits.push(`L${argObj.endLine}`);
+    const range = rangeBits.length > 0 ? rangeBits.join("-") : "";
+    return [artifactId, range].filter(Boolean).join(" · ");
+  }
+
+  const fallback = String(argObj.path || argObj.command || argObj.cmd || "").trim();
+  return shortenPathDetail(fallback);
+}
+
 function normalizeToolMergeEntry(entry = {}) {
   const source = entry && typeof entry === "object" ? entry : {};
   const tool = String(source.tool || "").trim().toLowerCase() || "tool";
@@ -822,6 +992,7 @@ function buildCompletions({
   commandTree = null,
   groupTemplates = [],
   soloProfiles = [],
+  argumentLists = null,
   limit = 8,
 } = {}) {
   const raw = String(text || "");
@@ -830,9 +1001,14 @@ function buildCompletions({
   const endsWithWhitespace = /\s$/.test(trimmed);
 
   if (trimmed.startsWith("/")) {
-    const parts = trimmed.split(/\s+/);
-    const head = parts[0]; // "/launch"
-    const tail = parts.slice(1);
+    const tokenParts = trimmed.trimEnd().split(/\s+/).filter(Boolean);
+    const head = tokenParts[0] || ""; // "/launch"
+    const tail = tokenParts.slice(1);
+    const headKey = head.startsWith("/") ? head : `/${head}`;
+    const headNode = commandTree && typeof commandTree === "object" ? commandTree[headKey] : null;
+    const argListForHead = argumentLists && typeof argumentLists === "object"
+      ? argumentLists[headKey]
+      : null;
 
     // Dynamic argument completion for /group run <alias> and
     // /solo run <profile>. These pull from runtime sources (group
@@ -842,7 +1018,7 @@ function buildCompletions({
       : (head === "/solo" && tail[0] === "run")
           ? soloProfiles
           : null;
-    if (dynList && (tail.length >= 2 || trimmed.endsWith(" "))) {
+    if (dynList && (tail.length >= 2 || (tail[0] === "run" && endsWithWhitespace))) {
       const partial = String(tail[1] || "").toLowerCase();
       const out = [];
       for (const item of (Array.isArray(dynList) ? dynList : [])) {
@@ -867,49 +1043,91 @@ function buildCompletions({
     }
 
     // Sub-command completion: "/cmd <prefix>" or "/cmd sub <prefix>".
-    if (tail.length >= 1 && commandTree) {
-      const headKey = head.startsWith("/") ? head : `/${head}`;
-      let node = commandTree[headKey];
-      if (!node || typeof node !== "object") return [];
-      // Walk into nested children for everything but the last token.
-      for (let i = 0; i < tail.length - 1; i += 1) {
-        const segment = tail[i];
-        if (!segment) return [];
-        const next = node && node.children && node.children[segment];
-        if (!next) return [];
-        node = next;
+    if ((tail.length >= 1 || (endsWithWhitespace && headNode && headNode.children)) && commandTree) {
+      let node = headNode;
+      if (!node || typeof node !== "object") {
+        // fall through
+      } else if (node.children && typeof node.children === "object") {
+        const walkTail = endsWithWhitespace && tail.length === 0
+          ? []
+          : (endsWithWhitespace ? tail : tail.slice(0, -1));
+        const partial = endsWithWhitespace && tail.length === 0
+          ? ""
+          : (endsWithWhitespace ? "" : String(tail[tail.length - 1] || "").toLowerCase());
+        let walkNode = node;
+        let walkOk = true;
+        for (const segment of walkTail) {
+          const next = walkNode.children && walkNode.children[segment];
+          if (!next) {
+            walkOk = false;
+            break;
+          }
+          walkNode = next;
+        }
+        const children = walkOk ? (walkNode && walkNode.children) : null;
+        if (children && typeof children === "object") {
+          const prefixSoFar = walkTail.length > 0
+            ? `${head} ${walkTail.join(" ")}`
+            : head;
+          const entries = Object.keys(children).map((name) => ({
+            name,
+            ...children[name],
+          }));
+          entries.sort((a, b) => {
+            const orderA = Number.isFinite(a.order) ? a.order : 999;
+            const orderB = Number.isFinite(b.order) ? b.order : 999;
+            if (orderA !== orderB) return orderA - orderB;
+            return a.name.localeCompare(b.name);
+          });
+          const out = [];
+          for (const entry of entries) {
+            if (partial && !entry.name.toLowerCase().startsWith(partial)) continue;
+            const hasDynamicArguments = (head === "/group" && entry.name === "run")
+              || (head === "/solo" && entry.name === "run")
+              || Boolean(entry.hasArguments);
+            out.push({
+              kind: "subcommand",
+              label: `${prefixSoFar} ${entry.name}`.trim(),
+              replace: `${prefixSoFar} ${entry.name} `.replace(/^\s+/, ""),
+              description: String(entry.desc || entry.summary || entry.description || ""),
+              hasChildren: Boolean((entry.children && typeof entry.children === "object") || hasDynamicArguments),
+            });
+            if (out.length >= limit) break;
+          }
+          if (!endsWithWhitespace && out.length === 1) {
+            const candidate = String(out[0].replace || "").trim().split(/\s+/).pop() || "";
+            if (candidate.toLowerCase() === partial && !out[0].hasChildren) return [];
+          }
+          return out;
+        }
       }
-      const children = node && node.children;
-      if (!children || typeof children !== "object") return [];
-      const partial = String(tail[tail.length - 1] || "").toLowerCase();
-      const prefixSoFar = `${head} ${tail.slice(0, -1).join(" ")}`.replace(/\s+$/, "");
-      // Sort by `order` (when present) then alphabetically — matches the
-      // sortCommands helper used by the blessed completion popup.
-      const entries = Object.keys(children).map((name) => ({
-        name,
-        ...children[name],
-      }));
-      entries.sort((a, b) => {
-        const orderA = Number.isFinite(a.order) ? a.order : 999;
-        const orderB = Number.isFinite(b.order) ? b.order : 999;
-        if (orderA !== orderB) return orderA - orderB;
-        return a.name.localeCompare(b.name);
-      });
+    }
+
+    // Generic top-level argument lists (e.g. /resume <session-id>).
+    if (
+      Array.isArray(argListForHead)
+      && argListForHead.length > 0
+      && !(headNode && headNode.children)
+      && (endsWithWhitespace || tail.length >= 1)
+    ) {
+      if (tail.length > 1) return [];
+      const partial = String(tail[0] || "").toLowerCase();
       const out = [];
-      for (const entry of entries) {
-        if (!entry.name.toLowerCase().startsWith(partial)) continue;
-        const hasDynamicArguments = (head === "/group" && entry.name === "run")
-          || (head === "/solo" && entry.name === "run");
+      for (const item of argListForHead) {
+        const id = String((item && (item.alias || item.cmd || item.id || item.name)) || item || "");
+        if (!id) continue;
+        if (partial && !id.toLowerCase().startsWith(partial)) continue;
+        const desc = String((item && (item.desc || item.summary || item.description || item.source)) || "");
         out.push({
-          kind: "subcommand",
-          label: `${prefixSoFar} ${entry.name}`.trim(),
-          replace: `${prefixSoFar} ${entry.name} `.replace(/^\s+/, ""),
-          description: String(entry.desc || entry.summary || entry.description || ""),
-          hasChildren: Boolean((entry.children && typeof entry.children === "object") || hasDynamicArguments),
+          kind: "argument",
+          label: `${head} ${id}`,
+          replace: `${head} ${id} `,
+          description: desc,
+          hasChildren: false,
         });
         if (out.length >= limit) break;
       }
-      if (!endsWithWhitespace && out.length === 1) {
+      if (partial && out.length === 1) {
         const candidate = String(out[0].replace || "").trim().split(/\s+/).pop() || "";
         if (candidate.toLowerCase() === partial && !out[0].hasChildren) return [];
       }
@@ -920,8 +1138,16 @@ function buildCompletions({
     const after = trimmed.slice(1);
     const prefix = after.toLowerCase();
     const list = Array.isArray(commands) ? commands : [];
+    const sorted = list.slice().sort((a, b) => {
+      const orderA = Number.isFinite(a && a.order) ? a.order : 999;
+      const orderB = Number.isFinite(b && b.order) ? b.order : 999;
+      if (orderA !== orderB) return orderA - orderB;
+      const nameA = String((a && a.cmd) || a || "");
+      const nameB = String((b && b.cmd) || b || "");
+      return nameA.localeCompare(nameB);
+    });
     const out = [];
-    for (const item of list) {
+    for (const item of sorted) {
       // Registry entries already include the leading '/' in `cmd`. Strip
       // it before matching the user's prefix and put it back when we
       // render so we don't end up with '//cron'.
@@ -930,18 +1156,27 @@ function buildCompletions({
       const lower = bare.toLowerCase();
       if (!bare) continue;
       if (!lower.startsWith(prefix)) continue;
+      const node = commandTree && commandTree[`/${bare}`];
+      const hasChildren = Boolean(
+        (node && node.children && typeof node.children === "object")
+        || (node && node.hasArguments)
+        || (argumentLists && Array.isArray(argumentLists[`/${bare}`]) && argumentLists[`/${bare}`].length > 0),
+      );
       out.push({
         kind: "command",
         label: `/${bare}`,
         replace: `/${bare} `,
         description: String((item && (item.desc || item.summary || item.description)) || ""),
-        hasChildren: Boolean(commandTree && commandTree[`/${bare}`] && commandTree[`/${bare}`].children),
+        hasChildren,
+        optionalArguments: Boolean(node && node.optionalArguments),
       });
       if (out.length >= limit) break;
     }
     if (!endsWithWhitespace && out.length === 1) {
       const candidate = String(out[0].replace || "").trim().replace(/^\//, "").toLowerCase();
-      if (candidate === prefix && !out[0].hasChildren) return [];
+      // Exact bare command: close the popup so Enter submits. Commands with
+      // optionalArguments (e.g. /model) are valid both bare and with an arg.
+      if (candidate === prefix && (!out[0].hasChildren || out[0].optionalArguments)) return [];
     }
     return out;
   }
@@ -994,6 +1229,7 @@ module.exports = {
   buildToolMergeRowText,
   buildCompletions,
   buildUcodeBannerLines,
+  buildUcodeSessionLogEntries,
   charDisplayWidth,
   clampCursorPos,
   createEscapeTagStripper,
@@ -1012,11 +1248,15 @@ module.exports = {
   moveCursorVertically,
   normalizeBashToolCommand,
   normalizeModelLabel,
+  normalizeToolLogDetail,
   normalizeToolMergeEntry,
   parseActiveAgentsFromBusStatus,
   planAgentsFooter,
   planProjectsRail,
   renderLogLinesWithMarkdown,
+  renderLogLinesWithMarkdownAnsi,
+  createMarkdownTableBuffer,
+  isTableRowLine,
   resolveAgentSelectionOnDown,
   resolveHistoryDownTransition,
   shouldClearAgentSelectionOnUp,