u-foo 3.0.2 → 3.0.4

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/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 = [];
@@ -1295,6 +1345,9 @@ module.exports = {
   normalizeModelLabel,
   normalizeToolLogDetail,
   normalizeToolMergeEntry,
+  messageContentText,
+  toolMessagePreview,
+  redactUserMessageForLog,
   parseActiveAgentsFromBusStatus,
   planAgentsFooter,
   planProjectsRail,

package/src/ui/ink/MultilineInput.js

@@ -25,6 +25,11 @@
  *                               component (e.g. completion popup) can
  *                               handle them. Plain editing keys still work.
  *   placeholder (string)        rendered in gray when value is empty
+ *   onPasteText(filtered)       optional. Called for non-empty paste/insert
+ *                               chunks before insertText. May return:
+ *                                 string — insert that text instead
+ *                                 { text } — insert text (may be "")
+ *                                 null/undefined — fall back to filtered text
  *
  * Newlines: Enter submits. Use Alt+Enter (delivered as meta+Return) or end the
  * line with `\` (the legacy continuation trick) to insert a literal newline.
@@ -32,7 +37,8 @@
  * plain Enter, so it would silently submit.
  *
  * Bracketed paste arrives as a multi-byte `input` chunk in useInput; we route
- * it through insertText, so multi-line paste already works without extra code.
+ * it through insertText (or onPasteText), so multi-line paste already works
+ * without extra code.
  */
 
 const fmt = require("../format");
@@ -167,6 +173,7 @@ function createMultilineInput({ React, ink }) {
     // the IME composition window pops up at the visible (inverse) cursor
     // instead of at the bottom of the screen.
     linesBelowInput = 0,
+    onPasteText = null,
   }) {
     // Cursor is owned by this component. preferredCol tracks the visual
     // column we want to keep when bouncing across lines of different widths
@@ -392,7 +399,36 @@ function createMultilineInput({ React, ink }) {
       // Plain character / paste. Filter control bytes.
       if (input && !key.ctrl && !key.meta) {
         const filtered = input.replace(/[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]/g, "");
-        if (filtered) insertText(filtered);
+        // Binary clipboard paste can strip to empty — still notify parent so
+        // it can try macOS PNGf clipboard ingest.
+        if (!filtered) {
+          if (typeof onPasteText === "function") {
+            try { onPasteText(""); } catch { /* ignore */ }
+          }
+          return;
+        }
+        if (typeof onPasteText === "function" && (filtered.length > 1 || filtered.includes("\n"))) {
+          let rewritten;
+          try {
+            rewritten = onPasteText(filtered);
+          } catch {
+            rewritten = filtered;
+          }
+          if (rewritten == null) {
+            insertText(filtered);
+            return;
+          }
+          if (typeof rewritten === "string") {
+            if (rewritten) insertText(rewritten);
+            return;
+          }
+          if (rewritten && typeof rewritten === "object") {
+            const nextText = rewritten.text == null ? filtered : String(rewritten.text);
+            if (nextText) insertText(nextText);
+            return;
+          }
+        }
+        insertText(filtered);
       }
     }, { isActive: interactive });
 

package/src/ui/ink/UcodeApp.js

@@ -17,6 +17,11 @@
 const { runInk } = require("../runInk");
 const fmt = require("../format");
 const { createMultilineInput } = require("./MultilineInput");
+const {
+  handleImagePaste,
+  formatUserLogWithAttachments,
+  buildAttachedImagesPromptPrefix,
+} = require("../../code/imageIngest");
 
 // Throttle for the live thinking-chain status line: rapid thinking_delta
 // chunks would otherwise re-render the footer on every SSE event.
@@ -70,6 +75,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
     );
     const [draft, setDraft] = useState("");
     const [draftVersion, setDraftVersion] = useState(0);
+    const [imageAttachments, setImageAttachments] = useState([]);
     // status: idle when message === "". `type` picks a STATUS_INDICATORS
     // bucket; `showTimer` and `startedAt` reproduce the blessed spinner
     // controls. The BG suffix is computed from backgroundTasksRef and
@@ -510,12 +516,20 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
 
     const runChainRef = useRef(Promise.resolve());
 
-    const executeLine = useCallback(async (rawValue) => {
-      const normalized = String(rawValue || "").replace(/\r?\n/g, " ").trim();
-      if (!normalized) return;
+    const executeLine = useCallback(async (rawValue, options = {}) => {
+      const modelSource = options.modelText != null ? options.modelText : rawValue;
+      const logSource = options.logText != null ? options.logText : modelSource;
+      const preserveNewlines = Boolean(options.preserveNewlines);
+      const modelNormalized = preserveNewlines
+        ? String(modelSource || "").trim()
+        : String(modelSource || "").replace(/\r?\n/g, " ").trim();
+      const logNormalized = fmt.redactUserMessageForLog(
+        String(logSource || "").replace(/\r?\n/g, " ").trim(),
+      );
+      if (!modelNormalized && !logNormalized) return;
       toolMergeScopeRef.current += 1;
       flushActiveMerge();
-      appendLogLine(`› ${normalized}`, "user");
+      appendLogLine(`› ${logNormalized || modelNormalized}`, "user");
 
       const runtimeWorkspace = String(
         (props.state && props.state.workspaceRoot) || props.workspaceRoot || process.cwd()
@@ -523,7 +537,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
 
       let result;
       try {
-        result = props.runSingleCommand(normalized, runtimeWorkspace);
+        result = props.runSingleCommand(modelNormalized, runtimeWorkspace);
       } catch (err) {
         appendLogText(`Error: ${err && err.message ? err.message : "command parse failed"}`, "error");
         return;
@@ -963,21 +977,27 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
 
     const submit = useCallback((submitted) => {
       const value = String(submitted == null ? draft : submitted);
+      const attachments = Array.isArray(imageAttachments) ? imageAttachments.slice() : [];
       const trimmed = value.trim();
-      if (!trimmed) return;
+      if (!trimmed && attachments.length === 0) return;
       setDraft("");
       setDraftVersion((v) => v + 1);
+      setImageAttachments([]);
       setInputHistory((prev) => {
-        const next = prev.concat([trimmed]).slice(-200);
+        const historyValue = formatUserLogWithAttachments(trimmed, attachments) || trimmed;
+        const next = prev.concat([historyValue]).slice(-200);
         setHistoryIndex(next.length);
         return next;
       });
 
+      const modelText = `${buildAttachedImagesPromptPrefix(attachments)}${trimmed}`.trim();
+      const logText = formatUserLogWithAttachments(trimmed, attachments);
+
       // Pending approval/choice/chat takes priority over nudge / new NL.
       try {
         const { hasPendingUserInteraction } = require("../../code/context/userInteraction");
         if (props.state && props.state.executionState && hasPendingUserInteraction(props.state.executionState)) {
-          appendLogText(`› ${trimmed}`, "user");
+          appendLogText(`› ${logText}`, "user");
           const startedAt = Date.now();
           setStatus({
             message: "Applying your reply...",
@@ -1053,10 +1073,11 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
         if (!props.state.executionState || typeof props.state.executionState !== "object") {
           props.state.executionState = emptyExecutionState();
         }
-        const queued = enqueueUserPrompt(props.state.executionState, trimmed);
+        const queued = enqueueUserPrompt(props.state.executionState, modelText);
+        const reminderPreview = logText.slice(0, 120) + (logText.length > 120 ? "…" : "");
         appendLogText(
           queued.enqueued
-            ? `Queued user reminder for next model turn: ${trimmed.slice(0, 120)}${trimmed.length > 120 ? "…" : ""}`
+            ? `Queued user reminder for next model turn: ${reminderPreview}`
             : "Could not queue user reminder (empty).",
           "system",
         );
@@ -1065,10 +1086,15 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
 
       // Serialize executions so streaming tasks don't interleave.
       runChainRef.current = runChainRef.current
-        .then(() => executeLine(value))
+        .then(() => executeLine(modelText, {
+          modelText,
+          logText,
+          preserveNewlines: attachments.length > 0,
+        }))
         .catch((err) => appendLogText(`Error: ${err && err.message ? err.message : err}`, "error"));
     }, [
       draft,
+      imageAttachments,
       executeLine,
       appendLogText,
       appendLogLine,
@@ -1282,6 +1308,16 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
           }),
         );
       })() : null,
+      imageAttachments.length > 0
+        ? h(Box, { flexDirection: "column", width: "100%", marginBottom: 0 },
+          h(Text, { color: "cyan", dimColor: true },
+            imageAttachments.map((item) => {
+              const name = item.fileName || require("path").basename(String(item.relPath || "image"));
+              return `[img] ${name}`;
+            }).join("  "),
+          ),
+        )
+        : null,
       h(Box, { width: "100%" },
         h(MultilineInput, {
           value: draft,
@@ -1292,6 +1328,33 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
             }
             setDraft(next);
           },
+          onPasteText: (filtered) => {
+            const workspaceRoot = String(
+              (props.state && props.state.workspaceRoot) || props.workspaceRoot || process.cwd(),
+            );
+            const sessionId = String((props.state && props.state.sessionId) || "session");
+            const outcome = handleImagePaste(filtered, {
+              workspaceRoot,
+              sessionId,
+              tryClipboard: true,
+            });
+            if (Array.isArray(outcome.attachments) && outcome.attachments.length > 0) {
+              setImageAttachments((prev) => {
+                const next = prev.slice();
+                for (const item of outcome.attachments) {
+                  if (!item || !item.relPath) continue;
+                  if (next.some((existing) => existing.relPath === item.relPath)) continue;
+                  next.push(item);
+                }
+                return next;
+              });
+            }
+            if (Array.isArray(outcome.errors) && outcome.errors.length > 0 && outcome.attachments.length === 0) {
+              // Soft notice only when nothing was ingested.
+              appendLogText(`Image paste: ${outcome.errors[0]}`, "system");
+            }
+            return { text: outcome.text == null ? filtered : outcome.text };
+          },
           onSubmit: (value) => {
             setCompletionSuppressedDraft(null);
             submit(value);