micro-models-agent 0.16.8 → 0.17.0

package/dist/cli/repl.js

@@ -161,17 +161,16 @@ export class Repl {
                     const { resolve } = await import("path");
                     let dataUrl;
                     let label;
-                    let warning;
                     if (source.toLowerCase() === "clipboard") {
-                        const clipPath = await readClipboardImage();
-                        if (!clipPath) {
+                        const clipBuf = await readClipboardImage();
+                        if (!clipBuf) {
                             console.log(pc.yellow(t("image.clipboard_empty")));
                             return;
                         }
-                        const result = loadFileAsDataUrl(clipPath);
+                        const { bufferToDataUrl } = await import("../llm/image-utils");
+                        const result = await bufferToDataUrl(clipBuf);
                         dataUrl = result.dataUrl;
                         label = "clipboard";
-                        warning = result.warning;
                     }
                     else if (source.startsWith("http://") || source.startsWith("https://")) {
                         const result = await loadUrlAsDataUrl(source);
@@ -184,10 +183,9 @@ export class Repl {
                             console.log(pc.red(t("image.not_found", { path: source })));
                             return;
                         }
-                        const result = loadFileAsDataUrl(absPath);
+                        const result = await loadFileAsDataUrl(absPath);
                         dataUrl = result.dataUrl;
                         label = source;
-                        warning = result.warning;
                     }
                     // Store the image data on the agent's context manager for the next message
                     const contextManager = this.agent.contextManager;
@@ -201,8 +199,6 @@ export class Repl {
                     });
                     const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
                     console.log(pc.green(t("image.attached", { source: label, size: `${sizeKb} KB` })));
-                    if (warning)
-                        console.log(pc.yellow(`  ${warning}`));
                 }
                 catch (err) {
                     console.log(pc.red(t("image.error", { message: err.message })));
@@ -760,15 +756,13 @@ export class Repl {
                 // Ctrl+V: try to paste image from clipboard
                 if (key.ctrl && key.name === "v" && !this.agentRunning) {
                     try {
-                        const { readClipboardImage, loadFileAsDataUrl } = await import("../llm/image-utils");
-                        const clipPath = await readClipboardImage();
-                        if (clipPath) {
-                            const { dataUrl, warning } = loadFileAsDataUrl(clipPath);
+                        const { readClipboardImage, bufferToDataUrl } = await import("../llm/image-utils");
+                        const clipBuf = await readClipboardImage();
+                        if (clipBuf) {
+                            const { dataUrl } = await bufferToDataUrl(clipBuf);
                             this.pendingClipboardImage = dataUrl;
                             const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
                             console.log(pc.green(`\n${t("image.attached", { source: "clipboard", size: `${sizeKb} KB` })}`));
-                            if (warning)
-                                console.log(pc.yellow(`  ${warning}`));
                             this.rl.prompt();
                         }
                     }

package/dist/llm/image-utils.js

@@ -9,97 +9,136 @@ const MIME_MAP = {
     ".bmp": "image/bmp",
     ".svg": "image/svg+xml",
 };
-/**
- * Detect MIME type from file extension.
- */
+/** Detect MIME type from file extension. */
 export function detectMime(filePath) {
     const ext = extname(filePath).toLowerCase();
     return MIME_MAP[ext] ?? "image/png";
 }
 /**
- * Load an image from a file path and return as base64 data URL.
- * Resizes if raw data exceeds maxBytes. Default max: 50KB (~16K tokens in base64).
+ * Read image from system clipboard using Bun.Image (macOS/Windows).
+ * Falls back to platform-specific commands on Linux.
+ * Returns null if clipboard has no image.
  */
-export function loadFileAsDataUrl(filePath, maxBytes = 50 * 1024) {
-    const mime = detectMime(filePath);
-    let buf = readFileSync(filePath);
-    let resized = false;
-    let warning;
-    if (buf.length > maxBytes) {
-        const ratio = maxBytes / buf.length;
-        warning = `Image ${Math.round(buf.length / 1024)}KB exceeds ${Math.round(maxBytes / 1024)}KB limit — resized to ~${Math.round(maxBytes / 1024)}KB (quality may reduce). Tip: crop the image before pasting.`;
-        buf = buf.subarray(0, maxBytes); // naive truncation — better than nothing
-        resized = true;
+export async function readClipboardImage() {
+    // Bun.Image.fromClipboard() works on macOS and Windows
+    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+        try {
+            const img = Bun.Image.fromClipboard();
+            if (img) {
+                const buf = await img
+                    .resize(800, 800, { fit: "inside" })
+                    .jpeg({ quality: 60 })
+                    .buffer();
+                return Buffer.from(buf);
+            }
+        }
+        catch {
+            // Bun.Image.fromClipboard() failed — fall through to platform fallback
+        }
     }
+    // Linux fallback: xclip/wl-paste → temp file → read
+    return readClipboardFallback();
+}
+async function readClipboardFallback() {
+    const { platform } = await import("os");
+    const { execSync } = await import("child_process");
+    const { readFileSync, unlinkSync } = await import("fs");
+    const { join } = await import("path");
+    const tmpPath = join(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
+    try {
+        if (platform() === "linux") {
+            execSync(`xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`, { timeout: 5000 });
+        }
+        else {
+            return null; // macOS/Windows should use Bun.Image
+        }
+        const buf = readFileSync(tmpPath);
+        unlinkSync(tmpPath);
+        return buf.length > 0 ? buf : null;
+    }
+    catch {
+        try {
+            unlinkSync(tmpPath);
+        }
+        catch { }
+        return null;
+    }
+}
+/**
+ * Load an image from a file path, resize via Bun.Image, return as JPEG data URL.
+ * Target: ~800px wide, JPEG quality 60 — typically 5-15KB (~2-4K tokens).
+ */
+export async function loadFileAsDataUrl(filePath) {
+    const buf = readFileSync(filePath);
+    // Use Bun.Image if available — resize + convert to JPEG
+    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+        try {
+            const img = new Bun.Image(buf);
+            const { width } = await img.metadata();
+            const targetWidth = Math.min(800, width || 800);
+            const dataUrl = await img
+                .resize(targetWidth, 800, { fit: "inside" })
+                .jpeg({ quality: 60 })
+                .dataurl();
+            return { dataUrl };
+        }
+        catch {
+            // Bun.Image failed — fall through to raw base64
+        }
+    }
+    // Fallback: raw base64 (no resize)
     const b64 = buf.toString("base64");
-    return { dataUrl: `data:${mime};base64,${b64}`, mime, resized, warning };
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    const mime = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "webp" ? "image/webp" : "image/png";
+    return { dataUrl: `data:${mime};base64,${b64}` };
 }
 /**
- * Load an image from a URL, return as base64 data URL.
+ * Load an image from a URL, resize, return as JPEG data URL.
  */
 export async function loadUrlAsDataUrl(url) {
     const resp = await fetch(url);
     if (!resp.ok) {
         throw new Error(`Failed to fetch image: ${resp.status} ${resp.statusText}`);
     }
-    const contentType = resp.headers.get("content-type") ?? "image/png";
-    const mime = contentType.split(";")[0].trim();
     const buf = Buffer.from(await resp.arrayBuffer());
+    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+        try {
+            const img = new Bun.Image(buf);
+            const { width } = await img.metadata();
+            const targetWidth = Math.min(800, width || 800);
+            const dataUrl = await img
+                .resize(targetWidth, 800, { fit: "inside" })
+                .jpeg({ quality: 60 })
+                .dataurl();
+            return { dataUrl };
+        }
+        catch {
+            // fall through
+        }
+    }
     const b64 = buf.toString("base64");
-    return { dataUrl: `data:${mime};base64,${b64}`, mime };
+    return { dataUrl: `data:image/png;base64,${b64}` };
 }
 /**
- * Read image from system clipboard (platform-specific).
- * Returns null if clipboard has no image.
+ * Process a clipboard buffer (already resized by readClipboardImage)
+ * into a data URL. Used by Ctrl+V handler.
  */
-export async function readClipboardImage() {
-    const { platform } = await import("os");
-    if (platform() === "win32") {
-        return readClipboardWindows();
-    }
-    if (platform() === "darwin") {
-        return readClipboardMacos();
-    }
-    return readClipboardLinux();
-}
-async function readClipboardWindows() {
-    try {
-        const { execSync } = await import("child_process");
-        const tmpPath = `${process.env.TEMP || process.env.TMP || "/tmp"}\\mma-clip-${Date.now()}.png`;
-        // Use single quotes in PowerShell to avoid backslash issues
-        const psScript = `Add-Type -AssemblyName System.Windows.Forms; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img -ne $null) { $img.Save('${tmpPath}'); Write-Output 'OK' } else { Write-Output 'EMPTY' }`;
-        const out = execSync(`powershell -NoProfile -Command "${psScript}"`, {
-            timeout: 5000,
-            encoding: "utf-8",
-        });
-        if (out.includes("OK")) {
-            return tmpPath;
+export async function bufferToDataUrl(buf) {
+    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
+        try {
+            const img = new Bun.Image(buf);
+            const { width } = await img.metadata();
+            const targetWidth = Math.min(800, width || 800);
+            const dataUrl = await img
+                .resize(targetWidth, 800, { fit: "inside" })
+                .jpeg({ quality: 60 })
+                .dataurl();
+            return { dataUrl };
+        }
+        catch {
+            // fall through
         }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-async function readClipboardMacos() {
-    try {
-        const { execSync } = await import("child_process");
-        const tmpPath = `/tmp/mma-clip-${Date.now()}.png`;
-        execSync(`pngpaste "${tmpPath}"`, { timeout: 5000 });
-        return tmpPath;
-    }
-    catch {
-        return null;
-    }
-}
-async function readClipboardLinux() {
-    try {
-        const { execSync } = await import("child_process");
-        const tmpPath = `/tmp/mma-clip-${Date.now()}.png`;
-        execSync(`xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`, { timeout: 5000 });
-        return tmpPath;
-    }
-    catch {
-        return null;
     }
+    const b64 = buf.toString("base64");
+    return { dataUrl: `data:image/png;base64,${b64}` };
 }

package/dist/tools/attach-image.js

@@ -1,9 +1,8 @@
 import { existsSync } from "fs";
 import { resolve } from "path";
 import { t } from "../i18n/index";
-import { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage } from "../llm/image-utils";
+import { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage, bufferToDataUrl } from "../llm/image-utils";
 import { logSecurityBlock } from "../modules/security/audit-log";
-const MAX_IMAGE_BYTES = 10 * 1024 * 1024; // 10 MB
 export const attachImageTool = {
     name: "attach_image",
     description: "Attach an image to the conversation from a file path, URL, or clipboard. The image will be included in the next message sent to the model. Supports PNG, JPEG, GIF, WebP.",
@@ -26,14 +25,14 @@ export const attachImageTool = {
         try {
             let dataUrl;
             if (source.toLowerCase() === "clipboard") {
-                const clipPath = await readClipboardImage();
-                if (!clipPath) {
+                const clipBuf = await readClipboardImage();
+                if (!clipBuf) {
                     return {
                         success: false,
                         output: t("image.clipboard_empty"),
                     };
                 }
-                const result = loadFileAsDataUrl(clipPath, MAX_IMAGE_BYTES);
+                const result = await bufferToDataUrl(clipBuf);
                 dataUrl = result.dataUrl;
             }
             else if (source.startsWith("http://") || source.startsWith("https://")) {
@@ -60,7 +59,7 @@ export const attachImageTool = {
                         };
                     }
                 }
-                const result = loadFileAsDataUrl(absPath, MAX_IMAGE_BYTES);
+                const result = await loadFileAsDataUrl(absPath);
                 dataUrl = result.dataUrl;
             }
             // Add the image as a pending content part on the context manager

package/package.json

@@ -1,43 +1,44 @@
-{
-  "name": "micro-models-agent",
-  "version": "0.16.8",
-  "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
-  "type": "module",
-  "bin": {
-    "mma": "bin/mma.mjs"
-  },
-  "files": [
-    "dist/",
-    "bin/"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "mma": "bun run src/cli/main.ts",
-    "build": "bun run build:tsc && bun run build:copy-assets",
-    "build:tsc": "tsc -p tsconfig.build.json",
-    "build:copy-assets": "powershell -Command \"Copy-Item -Recurse -Force 'src/modules/skills/builtin' 'dist/skills/builtin'\"",
-    "build:prod": "bun run 'build:bundle' && bun run 'build:copy-assets'",
-    "build:clean": "cmd /c \"if exist dist rmdir /s /q dist\"",
-    "build:bundle": "bun build ./src/cli/main.ts --outfile ./dist/main.js --target node --format esm --external playwright",
-    "dev": "bun --watch src/cli/main.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:integration": "vitest run --config vitest.integration.config.ts"
-  },
-  "dependencies": {
-    "commander": "^12.0.0",
-    "js-tiktoken": "^1.0.0",
-    "jsonrepair": "^3.15.0",
-    "picocolors": "^1.1.1",
-    "playwright": "^1.62.0",
-    "string-width": "^8.2.2"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.8.0",
-    "vitest": "^3.0.0"
-  }
-}
+{
+  "name": "micro-models-agent",
+  "version": "0.17.0",
+  "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
+  "type": "module",
+  "bin": {
+    "mma": "bin/mma.mjs"
+  },
+  "files": [
+    "dist/",
+    "bin/"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "mma": "bun run src/cli/main.ts",
+    "build": "bun run build:tsc && bun run build:copy-assets",
+    "build:tsc": "tsc -p tsconfig.build.json",
+    "build:copy-assets": "powershell -Command \"Copy-Item -Recurse -Force 'src/modules/skills/builtin' 'dist/skills/builtin'\"",
+    "build:prod": "bun run 'build:bundle' && bun run 'build:copy-assets'",
+    "build:clean": "cmd /c \"if exist dist rmdir /s /q dist\"",
+    "build:bundle": "bun build ./src/cli/main.ts --outfile ./dist/main.js --target node --format esm --external playwright",
+    "dev": "bun --watch src/cli/main.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration": "vitest run --config vitest.integration.config.ts"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "js-tiktoken": "^1.0.0",
+    "jsonrepair": "^3.15.0",
+    "picocolors": "^1.1.1",
+    "playwright": "^1.62.0",
+    "string-width": "^8.2.2"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.0.0"
+  }
+}