u-foo 3.0.1 → 3.0.3

package/src/code/imageIngest.js

@@ -0,0 +1,367 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFileSync } = require("child_process");
+const { mediaTypeFromPath, sniffMediaType, MAX_IMAGE_BYTES } = require("./tools/readImage");
+
+const IMAGE_EXT_RE = /\.(png|jpe?g|gif|webp)$/i;
+const FILE_URL_RE = /^file:\/\//i;
+
+function uploadsDir(workspaceRoot = "", sessionId = "") {
+  const root = path.resolve(String(workspaceRoot || process.cwd()));
+  const sid = String(sessionId || "session").trim().replace(/[^a-zA-Z0-9._-]+/g, "_") || "session";
+  return path.join(root, ".ufoo", "agent", "ucode", "uploads", sid);
+}
+
+function safeBaseName(filePath = "") {
+  const base = path.basename(String(filePath || "image.png"));
+  const cleaned = base.replace(/[^\w.\-()+ ]+/g, "_").replace(/\s+/g, " ").trim();
+  if (!cleaned) return "image.png";
+  if (!IMAGE_EXT_RE.test(cleaned)) return `${cleaned}.png`;
+  return cleaned.slice(0, 120);
+}
+
+function decodeFileUrl(value = "") {
+  const text = String(value || "").trim();
+  if (!FILE_URL_RE.test(text)) return text;
+  try {
+    const parsed = new URL(text);
+    if (parsed.protocol !== "file:") return text;
+    return decodeURIComponent(parsed.pathname || "");
+  } catch {
+    return text.replace(FILE_URL_RE, "");
+  }
+}
+
+function looksLikeImagePath(candidate = "") {
+  const text = decodeFileUrl(String(candidate || "").trim().replace(/^['"]|['"]$/g, ""));
+  if (!text || !IMAGE_EXT_RE.test(text)) return false;
+  if (text.startsWith("/") || /^[A-Za-z]:[\\/]/.test(text) || text.startsWith("~")) return true;
+  // Relative paths ending in image ext (drag from cwd listings)
+  if (!/\s/.test(text) && IMAGE_EXT_RE.test(text)) return true;
+  return false;
+}
+
+function expandHome(filePath = "") {
+  const text = String(filePath || "");
+  if (text.startsWith("~/")) return path.join(os.homedir(), text.slice(2));
+  return text;
+}
+
+/**
+ * Extract image file paths from terminal paste / drag-drop text.
+ * Supports file://, quoted paths with spaces, and bare absolute paths.
+ */
+function extractImagePathsFromPaste(text = "") {
+  const raw = String(text || "");
+  if (!raw.trim()) return [];
+  const found = [];
+  const seen = new Set();
+
+  function pushPath(candidate) {
+    let next = decodeFileUrl(String(candidate || "").trim());
+    next = next.replace(/^['"]|['"]$/g, "");
+    if (!looksLikeImagePath(next)) return;
+    next = expandHome(next);
+    const key = path.resolve(next);
+    if (seen.has(key)) return;
+    seen.add(key);
+    found.push(next);
+  }
+
+  // Quoted paths (possibly with spaces)
+  const quoted = /["']([^"']+\.(?:png|jpe?g|gif|webp))["']/gi;
+  let match;
+  while ((match = quoted.exec(raw))) {
+    pushPath(match[1]);
+  }
+
+  // file:// URLs
+  const fileUrls = /file:\/\/[^\s"'<>]+/gi;
+  while ((match = fileUrls.exec(raw))) {
+    pushPath(match[0]);
+  }
+
+  // Bare tokens / lines
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (looksLikeImagePath(trimmed)) {
+      pushPath(trimmed);
+      continue;
+    }
+    for (const token of trimmed.split(/\s+/)) {
+      if (looksLikeImagePath(token)) pushPath(token);
+    }
+  }
+
+  return found;
+}
+
+function stripExtractedPathsFromText(text = "", paths = []) {
+  let out = String(text || "");
+  for (const p of paths) {
+    const variants = [
+      `"${p}"`,
+      `'${p}'`,
+      p,
+      p.startsWith("/") ? `file://${p}` : "",
+      p.startsWith("/") ? `file://${encodeURI(p)}` : "",
+    ].filter(Boolean);
+    for (const v of variants) {
+      out = out.split(v).join(" ");
+    }
+  }
+  return out
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .replace(/[ \t]{2,}/g, " ")
+    .replace(/\s+"/g, " ")
+    .replace(/"\s+/g, " ")
+    .replace(/\s+'/g, " ")
+    .replace(/'\s+/g, " ")
+    .trim();
+}
+
+function formatImageLogLabel({ relPath = "", fileName = "", path: pathText = "" } = {}) {
+  const name = String(fileName || "").trim()
+    || path.basename(String(relPath || pathText || "").trim())
+    || "image";
+  return `[image: ${name}]`;
+}
+
+function formatUserLogWithAttachments(userText = "", attachments = []) {
+  const labels = (Array.isArray(attachments) ? attachments : [])
+    .map((item) => formatImageLogLabel(item))
+    .filter(Boolean);
+  const body = String(userText || "").trim();
+  if (labels.length === 0) return body;
+  if (!body) return labels.join(" ");
+  return `${labels.join(" ")} ${body}`;
+}
+
+function buildAttachedImagesPromptPrefix(attachments = []) {
+  const list = Array.isArray(attachments) ? attachments : [];
+  if (list.length === 0) return "";
+  const lines = [
+    "[Attached images — call read_image on each path]",
+    ...list.map((item) => `- ${item.relPath || item.path || ""}`).filter((line) => line !== "- "),
+    "",
+  ];
+  return lines.join("\n");
+}
+
+function ingestImageFile({
+  sourcePath = "",
+  workspaceRoot = process.cwd(),
+  sessionId = "",
+  buffer = null,
+  preferredName = "",
+} = {}) {
+  const root = path.resolve(String(workspaceRoot || process.cwd()));
+  let data = buffer;
+  let fromPath = String(sourcePath || "").trim();
+
+  if (!data) {
+    if (!fromPath) {
+      return { ok: false, error: "sourcePath or buffer required" };
+    }
+    fromPath = expandHome(decodeFileUrl(fromPath));
+    try {
+      const stat = fs.statSync(fromPath);
+      if (!stat.isFile()) return { ok: false, error: `not a file: ${fromPath}` };
+      if (stat.size > MAX_IMAGE_BYTES) {
+        return {
+          ok: false,
+          error: `image too large (${stat.size} bytes); max ${MAX_IMAGE_BYTES}`,
+        };
+      }
+      data = fs.readFileSync(fromPath);
+    } catch (err) {
+      return { ok: false, error: err && err.message ? err.message : "read failed" };
+    }
+  }
+
+  if (!Buffer.isBuffer(data)) {
+    return { ok: false, error: "image buffer required" };
+  }
+  if (data.length > MAX_IMAGE_BYTES) {
+    return {
+      ok: false,
+      error: `image too large (${data.length} bytes); max ${MAX_IMAGE_BYTES}`,
+    };
+  }
+
+  const sniffed = sniffMediaType(data);
+  const fromName = mediaTypeFromPath(preferredName || fromPath);
+  const mediaType = sniffed || fromName;
+  if (!mediaType) {
+    return { ok: false, error: "unsupported image type (use png, jpeg, gif, or webp)" };
+  }
+
+  const ext = mediaType === "image/jpeg"
+    ? ".jpg"
+    : mediaType === "image/gif"
+      ? ".gif"
+      : mediaType === "image/webp"
+        ? ".webp"
+        : ".png";
+
+  let base = safeBaseName(preferredName || fromPath || `clipboard${ext}`);
+  if (!IMAGE_EXT_RE.test(base)) base = `${base}${ext}`;
+  // Normalize extension to sniffed type
+  base = `${path.basename(base, path.extname(base))}${ext}`;
+
+  const dir = uploadsDir(root, sessionId);
+  fs.mkdirSync(dir, { recursive: true });
+  const stamp = Date.now().toString(36);
+  const destName = `${stamp}-${base}`;
+  const absPath = path.join(dir, destName);
+  fs.writeFileSync(absPath, data);
+
+  const relPath = path.relative(root, absPath).split(path.sep).join("/");
+  return {
+    ok: true,
+    relPath,
+    absPath,
+    fileName: base,
+    mediaType,
+    bytes: data.length,
+  };
+}
+
+function tryIngestClipboardImage({
+  workspaceRoot = process.cwd(),
+  sessionId = "",
+  platform = process.platform,
+  execFile = execFileSync,
+} = {}) {
+  if (platform !== "darwin") {
+    return { ok: false, error: "clipboard image ingest is only supported on macOS" };
+  }
+
+  const tmpPath = path.join(
+    os.tmpdir(),
+    `ufoo-clipboard-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.png`,
+  );
+  // AppleScript: write clipboard PNGf to a temp file.
+  const script = [
+    `set outPath to POSIX file ${JSON.stringify(tmpPath)}`,
+    "try",
+    "  set pngData to the clipboard as «class PNGf»",
+    "  set fileRef to open for access outPath with write permission",
+    "  set eof of fileRef to 0",
+    "  write pngData to fileRef",
+    "  close access fileRef",
+    '  return "ok"',
+    "on error errMsg number errNum",
+    "  try",
+    "    close access outPath",
+    "  end try",
+    '  return "err:" & errMsg',
+    "end try",
+  ].join("\n");
+
+  let resultText = "";
+  try {
+    resultText = String(execFile("osascript", ["-e", script], {
+      encoding: "utf8",
+      timeout: 5000,
+      maxBuffer: 1024 * 1024,
+    }) || "").trim();
+  } catch (err) {
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "clipboard read failed",
+    };
+  }
+
+  if (!resultText.startsWith("ok")) {
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+    return {
+      ok: false,
+      error: resultText.replace(/^err:/, "").trim() || "no PNG image on clipboard",
+    };
+  }
+
+  try {
+    const ingested = ingestImageFile({
+      sourcePath: tmpPath,
+      workspaceRoot,
+      sessionId,
+      preferredName: `clipboard-${Date.now().toString(36)}.png`,
+    });
+    return ingested;
+  } finally {
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Handle a paste chunk: ingest image paths and/or macOS clipboard bitmap.
+ * Returns text to insert into the editor (paths removed) plus attachments.
+ */
+function handleImagePaste(text = "", {
+  workspaceRoot = process.cwd(),
+  sessionId = "",
+  tryClipboard = true,
+  platform = process.platform,
+  execFile = execFileSync,
+} = {}) {
+  const raw = String(text || "");
+  const paths = extractImagePathsFromPaste(raw);
+  const attachments = [];
+  const errors = [];
+
+  for (const sourcePath of paths) {
+    const ingested = ingestImageFile({ sourcePath, workspaceRoot, sessionId });
+    if (ingested.ok) attachments.push(ingested);
+    else errors.push(ingested.error || "ingest failed");
+  }
+
+  let remaining = stripExtractedPathsFromText(raw, paths);
+
+  // If paste had no usable text/paths, try clipboard PNG (Cmd+V of a screenshot).
+  const trimmedRemaining = remaining.trim();
+  const looksEmptyOrBinary = !trimmedRemaining
+    || /[\x00-\x08\x0e-\x1f]/.test(raw)
+    || (Buffer.byteLength(raw, "utf8") > 200 && paths.length === 0 && !/\s/.test(raw.slice(0, 40)));
+
+  if (tryClipboard && attachments.length === 0 && looksEmptyOrBinary) {
+    const clip = tryIngestClipboardImage({
+      workspaceRoot,
+      sessionId,
+      platform,
+      execFile,
+    });
+    if (clip.ok) {
+      attachments.push(clip);
+      remaining = "";
+    } else if (paths.length === 0 && !trimmedRemaining) {
+      errors.push(clip.error || "clipboard ingest failed");
+    }
+  }
+
+  return {
+    text: remaining,
+    attachments,
+    errors,
+  };
+}
+
+module.exports = {
+  IMAGE_EXT_RE,
+  uploadsDir,
+  safeBaseName,
+  extractImagePathsFromPaste,
+  stripExtractedPathsFromText,
+  formatImageLogLabel,
+  formatUserLogWithAttachments,
+  buildAttachedImagesPromptPrefix,
+  ingestImageFile,
+  tryIngestClipboardImage,
+  handleImagePaste,
+};

package/src/code/modelCommand.js

@@ -1,37 +1,176 @@
 "use strict";
 
-const { saveGlobalUcodeConfig } = require("../config");
+const { saveGlobalUcodeConfig, loadGlobalUcodeConfig } = require("../config");
+const {
+  listProviderModels,
+  confirmModelSupported,
+} = require("./providers/modelsCatalog");
+const {
+  normalizeThinkingLevel,
+  suggestThinkingLevels,
+  applyThinkingLevelToEnv,
+  resolveThinkingFromEnvAndConfig,
+  DEFAULT_THINKING_LEVEL,
+} = require("./thinkingLevels");
+
+function fallbackModelSuggestions(provider = "") {
+  const text = String(provider || "").trim().toLowerCase();
+  if (text.includes("anthropic") || text.includes("claude")) {
+    return ["claude-opus-4-5", "claude-sonnet-4-5", "claude-haiku-4-5"];
+  }
+  if (text.includes("kimi") || text.includes("moonshot")) {
+    return ["k3", "kimi-k2.5", "moonshot-v1-128k"];
+  }
+  return ["gpt-5.4", "gpt-5.3", "o3", "o4-mini"];
+}
+
+function resolveModelRuntime(state = {}, options = {}) {
+  // Lazy require: nativeRunner pulls agent/repl paths that can load modelCommand.
+  const { resolveRuntimeConfig } = require("./nativeRunner");
+  return resolveRuntimeConfig({
+    workspaceRoot: options.workspaceRoot || process.cwd(),
+    provider: options.provider || (state && state.provider) || "",
+    model: options.model || (state && state.model) || "",
+  });
+}
+
+function currentThinkingLevel(state = {}) {
+  let configLevel = "";
+  try {
+    configLevel = String((loadGlobalUcodeConfig() || {}).ucodeThinking || "").trim();
+  } catch {
+    configLevel = "";
+  }
+  const fromState = normalizeThinkingLevel(state && state.thinking);
+  const resolved = resolveThinkingFromEnvAndConfig({
+    env: process.env,
+    configLevel: fromState || configLevel,
+  });
+  if (resolved.level) return resolved.level;
+  if (resolved.source === "env-budget") {
+    // Approximate a named level for the secondary menu highlight.
+    const budget = Number(resolved.budgetTokens) || 0;
+    if (budget <= 0) return "off";
+    if (budget <= 3000) return "low";
+    if (budget <= 16000) return "medium";
+    if (budget <= 40000) return "high";
+    return "max";
+  }
+  return DEFAULT_THINKING_LEVEL;
+}
+
+function persistThinkingLevel(state = {}, level = "") {
+  const normalized = normalizeThinkingLevel(level);
+  if (!normalized) return "";
+  if (state && typeof state === "object") state.thinking = normalized;
+  try {
+    saveGlobalUcodeConfig({ ucodeThinking: normalized });
+  } catch {
+    // best-effort
+  }
+  applyThinkingLevelToEnv(normalized, process.env);
+  return normalized;
+}
+
+/**
+ * Fetch models from the configured provider's /models route.
+ */
+async function listUcodeModels(state = {}, options = {}) {
+  const runtime = resolveModelRuntime(state, options);
+  const listed = await listProviderModels({
+    ...runtime,
+    fetchImpl: options.fetchImpl,
+    timeoutMs: options.timeoutMs,
+    skipCache: options.skipCache === true,
+  });
+  return {
+    ...listed,
+    provider: runtime.provider,
+    transport: runtime.transport,
+    baseUrl: runtime.baseUrl,
+  };
+}
 
 /**
  * Apply /model show|set against the live session state.
- * Persists ucodeModel to the global config so the next launch keeps it.
+ * Persists ucodeModel / ucodeThinking so the next launch keeps them.
+ * Set validates against the provider models route when available.
+ *
+ * result.shape:
+ *   { action: "show" }
+ *   { action: "set", model, thinking? }
  */
-function applyUcodeModelCommand(state = {}, result = {}) {
+async function applyUcodeModelCommand(state = {}, result = {}, options = {}) {
   const action = String((result && result.action) || "").trim().toLowerCase();
   if (action === "show") {
     const model = String((state && state.model) || "").trim() || "(unset)";
     const provider = String((state && state.provider) || "").trim() || "(unset)";
+    const thinking = currentThinkingLevel(state);
+    const lines = [
+      `model: ${model}`,
+      `provider: ${provider}`,
+      `thinking: ${thinking}`,
+      "usage: /model <model-id> [off|low|medium|high|max]",
+    ];
+    try {
+      const listed = await listUcodeModels(state, options);
+      if (listed.ok && listed.models.length > 0) {
+        const sample = listed.models.slice(0, 12);
+        lines.push(`models route: ${listed.url}`);
+        lines.push(`available (${listed.models.length}): ${sample.join(", ")}${listed.models.length > 12 ? "…" : ""}`);
+      } else if (listed.error) {
+        lines.push(`models route: ${listed.error}`);
+      }
+    } catch (err) {
+      lines.push(`models route: ${err && err.message ? err.message : "unavailable"}`);
+    }
     return {
       ok: true,
       error: "",
-      output: [
-        `model: ${model}`,
-        `provider: ${provider}`,
-        "usage: /model <model-id>",
-      ].join("\n"),
+      output: lines.join("\n"),
       model: String((state && state.model) || "").trim(),
+      thinking,
     };
   }
   if (action === "set") {
     const next = String((result && result.model) || "").trim();
+    const thinkingRaw = String((result && result.thinking) || "").trim();
+    const thinkingNext = normalizeThinkingLevel(thinkingRaw);
     if (!next) {
       return {
         ok: false,
-        error: "usage: /model [model-id]",
-        output: "usage: /model [model-id]",
+        error: "usage: /model [model-id] [off|low|medium|high|max]",
+        output: "usage: /model [model-id] [off|low|medium|high|max]",
       };
     }
+    if (thinkingRaw && !thinkingNext) {
+      return {
+        ok: false,
+        error: `unknown thinking level "${thinkingRaw}" (use off|low|medium|high|max)`,
+        output: `unknown thinking level "${thinkingRaw}" (use off|low|medium|high|max)`,
+      };
+    }
+
+    const runtime = resolveModelRuntime(state, { ...options, model: next });
+    const confirmation = await confirmModelSupported({
+      ...runtime,
+      model: next,
+      fetchImpl: options.fetchImpl,
+      timeoutMs: options.timeoutMs,
+      skipCache: options.skipCache === true,
+      strict: options.strict === true,
+    });
+    if (!confirmation.allowed) {
+      return {
+        ok: false,
+        error: confirmation.error || `model "${next}" is not supported`,
+        output: confirmation.error || `model "${next}" is not supported`,
+        models: confirmation.models,
+      };
+    }
+
     const previous = String((state && state.model) || "").trim();
+    const previousThinking = currentThinkingLevel(state);
     if (state && typeof state === "object") state.model = next;
     try {
       saveGlobalUcodeConfig({ ucodeModel: next });
@@ -43,45 +182,82 @@ function applyUcodeModelCommand(state = {}, result = {}) {
     } catch {
       // ignore env write failures
     }
-    const output = previous && previous !== next
+
+    const lines = [];
+    const modelOutput = previous && previous !== next
       ? `model switched: ${previous} → ${next}`
       : `model set: ${next}`;
+    lines.push(modelOutput);
+
+    let appliedThinking = "";
+    if (thinkingNext) {
+      appliedThinking = persistThinkingLevel(state, thinkingNext);
+      if (previousThinking && previousThinking !== appliedThinking) {
+        lines.push(`thinking: ${previousThinking} → ${appliedThinking}`);
+      } else {
+        lines.push(`thinking: ${appliedThinking}`);
+      }
+    }
+
+    if (confirmation.warning) lines.push(`note: ${confirmation.warning}`);
+    if (confirmation.ok && confirmation.models.length > 0) {
+      lines.push(`confirmed via models route (${confirmation.models.length} available)`);
+    }
     return {
       ok: true,
       error: "",
-      output,
+      output: lines.join("\n"),
       model: next,
       previous,
+      thinking: appliedThinking || previousThinking,
+      warning: confirmation.warning || "",
+      models: confirmation.models,
     };
   }
   return {
     ok: false,
-    error: "usage: /model [model-id]",
-    output: "usage: /model [model-id]",
+    error: "usage: /model [model-id] [off|low|medium|high|max]",
+    output: "usage: /model [model-id] [off|low|medium|high|max]",
   };
 }
 
-function suggestUcodeModels(state = {}) {
+/**
+ * Build /model completion rows. Prefer a live models-route catalog when
+ * provided; otherwise fall back to a small hardcoded list.
+ * Models are marked hasChildren so the TUI opens a thinking-intensity
+ * secondary menu after the id is chosen.
+ */
+function suggestUcodeModels(state = {}, options = {}) {
   const current = String((state && state.model) || "").trim();
   const provider = String((state && state.provider) || "").trim().toLowerCase();
-  let defaults = ["gpt-5.4", "gpt-5.3", "o3", "o4-mini"];
-  if (provider.includes("anthropic") || provider.includes("claude")) {
-    defaults = ["claude-opus-4-5", "claude-sonnet-4-5", "claude-haiku-4-5"];
-  } else if (provider.includes("kimi") || provider.includes("moonshot")) {
-    defaults = ["kimi-k2.5", "moonshot-v1-128k"];
-  }
+  const remote = Array.isArray(options.models)
+    ? options.models.map((item) => String(item || "").trim()).filter(Boolean)
+    : [];
+  const defaults = remote.length > 0 ? remote : fallbackModelSuggestions(provider);
   const ids = [];
   if (current) ids.push(current);
   for (const id of defaults) {
     if (id && !ids.includes(id)) ids.push(id);
   }
-  return ids.map((id) => ({
+  return ids.slice(0, 40).map((id) => ({
     id,
-    desc: id === current ? "current" : "",
+    desc: id === current
+      ? "current · pick thinking next"
+      : (remote.length > 0 ? "models route · pick thinking next" : "pick thinking next"),
+    hasChildren: true,
   }));
 }
 
+function suggestUcodeThinkingLevels(state = {}) {
+  return suggestThinkingLevels({ current: currentThinkingLevel(state) });
+}
+
 module.exports = {
   applyUcodeModelCommand,
   suggestUcodeModels,
+  suggestUcodeThinkingLevels,
+  listUcodeModels,
+  fallbackModelSuggestions,
+  currentThinkingLevel,
+  persistThinkingLevel,
 };