u-foo 3.0.1 → 3.0.3

package/src/code/thinkingLevels.js

@@ -0,0 +1,132 @@
+"use strict";
+
+/**
+ * Ucode thinking-intensity levels.
+ *
+ * Used as the secondary `/model <id> <level>` menu after picking a model.
+ * Maps to Anthropic extended-thinking budget_tokens and OpenAI-compatible
+ * reasoning_effort where the transport supports it.
+ */
+
+const THINKING_LEVELS = Object.freeze([
+  {
+    id: "off",
+    desc: "disable extended thinking",
+    budgetTokens: 0,
+    reasoningEffort: "",
+  },
+  {
+    id: "low",
+    desc: "light thinking",
+    budgetTokens: 2048,
+    reasoningEffort: "low",
+  },
+  {
+    id: "medium",
+    desc: "default thinking",
+    budgetTokens: 10000,
+    reasoningEffort: "medium",
+  },
+  {
+    id: "high",
+    desc: "deeper thinking",
+    budgetTokens: 32000,
+    reasoningEffort: "high",
+  },
+  {
+    id: "max",
+    desc: "maximum thinking budget",
+    budgetTokens: 48000,
+    reasoningEffort: "high",
+  },
+]);
+
+const DEFAULT_THINKING_LEVEL = "medium";
+const THINKING_LEVEL_IDS = new Set(THINKING_LEVELS.map((item) => item.id));
+
+function normalizeThinkingLevel(value = "") {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw) return "";
+  if (raw === "none" || raw === "disable" || raw === "disabled" || raw === "0") return "off";
+  if (raw === "med" || raw === "default") return "medium";
+  if (raw === "maximum" || raw === "xhigh" || raw === "ultra") return "max";
+  if (THINKING_LEVEL_IDS.has(raw)) return raw;
+  return "";
+}
+
+function getThinkingLevel(id = "") {
+  const normalized = normalizeThinkingLevel(id) || DEFAULT_THINKING_LEVEL;
+  return THINKING_LEVELS.find((item) => item.id === normalized) || THINKING_LEVELS[2];
+}
+
+function suggestThinkingLevels(options = {}) {
+  const current = normalizeThinkingLevel(options.current || "") || DEFAULT_THINKING_LEVEL;
+  return THINKING_LEVELS.map((item) => ({
+    id: item.id,
+    desc: item.id === current ? `${item.desc} · current` : item.desc,
+  }));
+}
+
+function resolveThinkingFromEnvAndConfig({
+  env = process.env,
+  configLevel = "",
+} = {}) {
+  // Explicit numeric budget still wins (advanced override).
+  const rawBudget = env && env.UFOO_UCODE_THINKING_BUDGET_TOKENS;
+  if (rawBudget !== undefined && rawBudget !== null && String(rawBudget).trim() !== "") {
+    const parsed = Number.parseInt(String(rawBudget), 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      return {
+        level: "off",
+        budgetTokens: 0,
+        reasoningEffort: "",
+        source: "env-budget",
+      };
+    }
+    return {
+      level: "",
+      budgetTokens: Math.floor(parsed),
+      reasoningEffort: "",
+      source: "env-budget",
+    };
+  }
+
+  const fromEnv = normalizeThinkingLevel(env && env.UFOO_UCODE_THINKING);
+  const fromConfig = normalizeThinkingLevel(configLevel);
+  const level = fromEnv || fromConfig || DEFAULT_THINKING_LEVEL;
+  const spec = getThinkingLevel(level);
+  return {
+    level: spec.id,
+    budgetTokens: spec.budgetTokens,
+    reasoningEffort: spec.reasoningEffort,
+    source: fromEnv ? "env" : (fromConfig ? "config" : "default"),
+  };
+}
+
+function applyThinkingLevelToEnv(level = "", env = process.env) {
+  const normalized = normalizeThinkingLevel(level);
+  if (!normalized) return "";
+  const spec = getThinkingLevel(normalized);
+  try {
+    env.UFOO_UCODE_THINKING = spec.id;
+    if (spec.budgetTokens > 0) {
+      env.UFOO_UCODE_THINKING_BUDGET_TOKENS = String(spec.budgetTokens);
+    } else {
+      env.UFOO_UCODE_THINKING_BUDGET_TOKENS = "0";
+    }
+  } catch {
+    // ignore env write failures
+  }
+  return spec.id;
+}
+
+module.exports = {
+  THINKING_LEVELS,
+  THINKING_LEVEL_IDS,
+  DEFAULT_THINKING_LEVEL,
+  normalizeThinkingLevel,
+  getThinkingLevel,
+  suggestThinkingLevels,
+  resolveThinkingFromEnvAndConfig,
+  applyThinkingLevelToEnv,
+};

package/src/code/tools/readImage.js

@@ -0,0 +1,110 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { resolveWorkspacePath } = require("./common");
+
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+
+const EXT_MEDIA = Object.freeze({
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+});
+
+function sniffMediaType(buffer = Buffer.alloc(0)) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 12) return "";
+  if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) {
+    return "image/png";
+  }
+  if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+    return "image/jpeg";
+  }
+  if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {
+    return "image/gif";
+  }
+  if (
+    buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46
+    && buffer[8] === 0x57 && buffer[9] === 0x45 && buffer[10] === 0x42 && buffer[11] === 0x50
+  ) {
+    return "image/webp";
+  }
+  return "";
+}
+
+function mediaTypeFromPath(filePath = "") {
+  const ext = path.extname(String(filePath || "")).toLowerCase();
+  return EXT_MEDIA[ext] || "";
+}
+
+function runReadImageTool(input = {}, options = {}) {
+  try {
+    const filePath = String(input.path || input.file || "").trim();
+    if (!filePath) {
+      return { ok: false, error: "path is required" };
+    }
+    const { workspaceRoot, resolved } = resolveWorkspacePath(
+      options.workspaceRoot,
+      filePath,
+      options.cwd,
+    );
+    const stat = fs.statSync(resolved);
+    if (!stat.isFile()) {
+      return { ok: false, error: `not a file: ${resolved}` };
+    }
+    if (stat.size > MAX_IMAGE_BYTES) {
+      return {
+        ok: false,
+        error: `image too large (${stat.size} bytes); max ${MAX_IMAGE_BYTES} bytes — compress or resize first`,
+        path: resolved,
+        bytes: stat.size,
+      };
+    }
+
+    const buffer = fs.readFileSync(resolved);
+    const sniffed = sniffMediaType(buffer);
+    const fromExt = mediaTypeFromPath(resolved);
+    const mediaType = sniffed || fromExt;
+    if (!mediaType) {
+      return {
+        ok: false,
+        error: "unsupported image type (use png, jpeg, gif, or webp)",
+        path: resolved,
+        bytes: buffer.length,
+      };
+    }
+    if (fromExt && sniffed && fromExt !== sniffed) {
+      return {
+        ok: false,
+        error: `image type mismatch: extension suggests ${fromExt}, bytes are ${sniffed}`,
+        path: resolved,
+        bytes: buffer.length,
+      };
+    }
+
+    return {
+      ok: true,
+      kind: "image",
+      workspaceRoot,
+      path: resolved,
+      mediaType,
+      bytes: buffer.length,
+      base64: buffer.toString("base64"),
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "read_image failed",
+    };
+  }
+}
+
+module.exports = {
+  MAX_IMAGE_BYTES,
+  EXT_MEDIA,
+  sniffMediaType,
+  mediaTypeFromPath,
+  runReadImageTool,
+};

package/src/code/tools/taskRun.js

@@ -0,0 +1,118 @@
+"use strict";
+
+const {
+  startStandaloneTask,
+  cancelTask,
+  failTask,
+  completeTaskFromLoop,
+} = require("../runtime/taskControl");
+const { getTaskRun } = require("../runtime/taskRun");
+const { emptyExecutionState } = require("../context/executionSegment");
+
+function normalizeTaskRunCommand(args = {}) {
+  if (!args || typeof args !== "object") return null;
+  const operation = String(args.operation || args.op || "").trim().toLowerCase();
+  if (!operation) return null;
+  return {
+    operation,
+    objective: args.objective,
+    title: args.title,
+    taskRunId: args.taskRunId || args.task_run_id,
+    nodeId: args.nodeId || args.node_id,
+    reason: args.reason,
+    result: args.result,
+    commandId: args.commandId || args.command_id,
+  };
+}
+
+function runTaskRunTool(args = {}, options = {}) {
+  const command = normalizeTaskRunCommand(args) || args;
+  const operation = String(command.operation || "").trim().toLowerCase();
+  const executionState = options.executionState && typeof options.executionState === "object"
+    ? options.executionState
+    : emptyExecutionState();
+  const commandId = String(command.commandId || "").trim();
+  const runTool = options.runTool || null;
+  const knownTools = options.knownTools || null;
+
+  let payload;
+  if (operation === "start") {
+    payload = startStandaloneTask(executionState, {
+      objective: command.objective,
+      title: command.title,
+      commandId,
+      runTool,
+      knownTools,
+      processImmediately: options.processImmediately !== false,
+    });
+  } else if (operation === "cancel") {
+    payload = cancelTask(executionState, {
+      taskRunId: command.taskRunId,
+      nodeId: command.nodeId,
+      reason: command.reason,
+      commandId,
+    });
+  } else if (operation === "fail") {
+    payload = failTask(executionState, {
+      taskRunId: command.taskRunId,
+      nodeId: command.nodeId,
+      reason: command.reason,
+      commandId,
+    });
+  } else if (operation === "complete") {
+    payload = completeTaskFromLoop(executionState, {
+      taskRunId: command.taskRunId,
+      result: command.result,
+      commandId,
+    });
+  } else if (operation === "inspect") {
+    const run = getTaskRun(executionState, command.taskRunId);
+    if (!run) {
+      payload = {
+        status: "rejected",
+        ok: false,
+        errors: [{ code: "TASK_RUN_NOT_FOUND", message: "task run missing" }],
+      };
+    } else {
+      payload = {
+        status: "accepted",
+        ok: true,
+        taskRun: {
+          id: run.id,
+          kind: run.kind || "",
+          status: run.status,
+          phase: run.phase,
+          objective: run.objective || "",
+          title: run.title || "",
+          parentGraphId: run.parentGraphId || "",
+          parentNodeId: run.parentNodeId || "",
+          childGraphId: run.childGraphId || "",
+          result: run.result,
+          error: run.error,
+          changedFiles: Array.isArray(run.changedFiles) ? run.changedFiles.slice() : [],
+        },
+      };
+    }
+  } else {
+    payload = {
+      status: "rejected",
+      ok: false,
+      errors: [{
+        code: "UNKNOWN_TASK_RUN_OP",
+        message: `unknown task_run operation: ${operation || "(empty)"}`,
+      }],
+    };
+  }
+
+  const ok = payload && payload.ok !== false && payload.status !== "rejected";
+  return {
+    ok,
+    ...payload,
+    executionState,
+  };
+}
+
+module.exports = {
+  normalizeTaskRunCommand,
+  runTaskRunTool,
+};

package/src/config.js

@@ -2,7 +2,14 @@ const fs = require("fs");
 const os = require("os");
 const path = require("path");
 
-const UCODE_FIELDS = ["ucodeProvider", "ucodeModel", "ucodeBaseUrl", "ucodeApiKey", "ucodeAgentDir"];
+const UCODE_FIELDS = [
+  "ucodeProvider",
+  "ucodeModel",
+  "ucodeBaseUrl",
+  "ucodeApiKey",
+  "ucodeAgentDir",
+  "ucodeThinking",
+];
 
 const SETTINGS_MODEL_DEFAULTS = Object.freeze({
   agent: Object.freeze({
@@ -47,6 +54,7 @@ const DEFAULT_UCODE_CONFIG = {
   ucodeBaseUrl: "",
   ucodeApiKey: "",
   ucodeAgentDir: "",
+  ucodeThinking: "",
 };
 
 function normalizeLaunchMode(value) {
@@ -251,6 +259,7 @@ function loadGlobalUcodeConfig() {
     ucodeBaseUrl: typeof raw.ucodeBaseUrl === "string" ? raw.ucodeBaseUrl : "",
     ucodeApiKey: typeof raw.ucodeApiKey === "string" ? raw.ucodeApiKey : "",
     ucodeAgentDir: typeof raw.ucodeAgentDir === "string" ? raw.ucodeAgentDir : "",
+    ucodeThinking: typeof raw.ucodeThinking === "string" ? raw.ucodeThinking : "",
   };
 }
 

package/src/ui/format/index.js

@@ -38,10 +38,14 @@ const STATUS_INDICATORS = {
 // Keep this list in sync with the keys handled by buildMergedToolSummaryText.
 const TOOL_LABELS = {
   read: "Reading file",
+  read_image: "Reading image",
   write: "Writing file",
   edit: "Editing file",
   bash: "Running command",
   artifact_read: "Reading artifact",
+  plan_graph: "Updating plan",
+  task_run: "Managing task",
+  ask_user: "Asking user",
 };
 
 const ANSI_PATTERN = /\x1B\[[0-9;?]*[ -/]*[@-~]/g;
@@ -283,7 +287,15 @@ function messageContentText(message = {}) {
   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);
+      if (!part || typeof part !== "object") return "";
+      const type = String(part.type || "").trim().toLowerCase();
+      if (type === "image" || type === "image_url") {
+        const name = part.fileName
+          || (part.path ? require("path").basename(String(part.path)) : "")
+          || "image";
+        return `[image: ${name}]`;
+      }
+      if (part.text != null) return String(part.text);
       return "";
     }).join("");
   }
@@ -296,15 +308,47 @@ function toolMessagePreview(message = {}) {
   try {
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") {
+      if (parsed.kind === "image" || parsed.base64 || parsed.mediaType) {
+        const name = require("path").basename(String(parsed.path || parsed.fileName || "image"));
+        return parsed.preview || `[image: ${name}]`;
+      }
       if (parsed.preview) return String(parsed.preview);
       if (parsed.artifactId) return `artifact:${parsed.artifactId}`;
+      if (parsed.base64) {
+        const clone = { ...parsed };
+        delete clone.base64;
+        return JSON.stringify(clone);
+      }
     }
   } catch {
     // plain tool text
   }
+  if (/data:image\/[a-zA-Z+]+;base64,/.test(raw) || /"base64"\s*:/.test(raw)) {
+    return "[image]";
+  }
   return raw;
 }
 
+/**
+ * Collapse attached-image prompt prefixes / base64 blobs for TUI log display.
+ */
+function redactUserMessageForLog(text = "") {
+  let out = String(text || "");
+  out = out.replace(
+    /\[Attached images[^\]]*\]\s*(?:-\s*.+\n?)*/gi,
+    (block) => {
+      const paths = [...block.matchAll(/^\s*-\s*(.+)$/gm)].map((m) => String(m[1] || "").trim());
+      if (paths.length === 0) return "[image]";
+      return paths
+        .map((p) => `[image: ${require("path").basename(p)}]`)
+        .join(" ");
+    },
+  );
+  out = out.replace(/data:image\/[a-zA-Z+]+;base64,[A-Za-z0-9+/=\s]+/g, "[image]");
+  out = out.replace(/"base64"\s*:\s*"[^"]*"/g, '"base64":"[redacted]"');
+  return out.replace(/\n{3,}/g, "\n\n").trim();
+}
+
 /**
  * Convert persisted nlMessages into ucode TUI log rows for resume/history.
  * Applies the shared ANSI markdown renderer so restored assistant text matches
@@ -349,7 +393,7 @@ function buildUcodeSessionLogEntries(messages = [], options = {}) {
     if (!message || typeof message !== "object") continue;
     const role = String(message.role || "").trim().toLowerCase();
     if (role === "user") {
-      const text = messageContentText(message);
+      const text = redactUserMessageForLog(messageContentText(message));
       if (!text.trim()) continue;
       const lines = text.split(/\r?\n/);
       lines.forEach((line, index) => {
@@ -671,6 +715,12 @@ function normalizeToolLogDetail(tool = "", args = {}, payload = {}) {
     return shortenPathDetail(pathText);
   }
 
+  if (name === "read_image") {
+    const pathText = String(argObj.path || resObj.path || resObj.fileName || "").trim();
+    const base = pathText ? require("path").basename(pathText) : "image";
+    return `[image: ${base}]`;
+  }
+
   if (name === "artifact_read") {
     const artifactId = String(argObj.artifactId || argObj.id || resObj.artifactId || "").trim();
     const rangeBits = [];
@@ -1103,13 +1153,52 @@ function buildCompletions({
       }
     }
 
-    // Generic top-level argument lists (e.g. /resume <session-id>).
+    // Generic top-level argument lists (e.g. /resume <session-id>,
+    // /model <id> [thinking]). /model supports a secondary intensity menu.
     if (
       Array.isArray(argListForHead)
       && argListForHead.length > 0
       && !(headNode && headNode.children)
       && (endsWithWhitespace || tail.length >= 1)
     ) {
+      const secondaryList = argumentLists && typeof argumentLists === "object"
+        ? argumentLists[`${headKey}/thinking`] || argumentLists[`${headKey}/think`]
+        : null;
+      const supportsThinkingMenu = head === "/model" && Array.isArray(secondaryList) && secondaryList.length > 0;
+
+      // Secondary menu: "/model <id> " or "/model <id> <partial>"
+      if (supportsThinkingMenu && (
+        (tail.length === 1 && endsWithWhitespace)
+        || tail.length >= 2
+      )) {
+        if (tail.length > 2) return [];
+        const modelId = String(tail[0] || "").trim();
+        if (!modelId) return [];
+        const partial = tail.length >= 2 && !endsWithWhitespace
+          ? String(tail[1] || "").toLowerCase()
+          : "";
+        const out = [];
+        for (const item of secondaryList) {
+          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: "argument",
+            label: `${head} ${modelId} ${id}`,
+            replace: `${head} ${modelId} ${id}`,
+            description: desc,
+            hasChildren: false,
+          });
+          if (out.length >= limit) break;
+        }
+        if (partial && out.length === 1) {
+          const candidate = String(out[0].replace || "").trim().split(/\s+/).pop() || "";
+          if (candidate.toLowerCase() === partial && !out[0].hasChildren) return [];
+        }
+        return out;
+      }
+
       if (tail.length > 1) return [];
       const partial = String(tail[0] || "").toLowerCase();
       const out = [];
@@ -1118,17 +1207,23 @@ function buildCompletions({
         if (!id) continue;
         if (partial && !id.toLowerCase().startsWith(partial)) continue;
         const desc = String((item && (item.desc || item.summary || item.description || item.source)) || "");
+        const hasChildren = Boolean(
+          (item && item.hasChildren)
+          || supportsThinkingMenu
+        );
         out.push({
           kind: "argument",
           label: `${head} ${id}`,
-          replace: `${head} ${id} `,
+          // Trailing space keeps the popup open for the thinking submenu.
+          replace: hasChildren ? `${head} ${id} ` : `${head} ${id} `,
           description: desc,
-          hasChildren: false,
+          hasChildren,
         });
         if (out.length >= limit) break;
       }
       if (partial && out.length === 1) {
         const candidate = String(out[0].replace || "").trim().split(/\s+/).pop() || "";
+        // Keep the popup open when the sole match still has a submenu.
         if (candidate.toLowerCase() === partial && !out[0].hasChildren) return [];
       }
       return out;
@@ -1250,6 +1345,9 @@ module.exports = {
   normalizeModelLabel,
   normalizeToolLogDetail,
   normalizeToolMergeEntry,
+  messageContentText,
+  toolMessagePreview,
+  redactUserMessageForLog,
   parseActiveAgentsFromBusStatus,
   planAgentsFooter,
   planProjectsRail,