micro-models-agent 0.13.3 → 0.14.1

package/dist/cli/repl.js

@@ -10,11 +10,13 @@ import { renderTable } from "../ui/table";
 import { t } from "../i18n/index";
 import { runSetup } from "./setup";
 import { saveConfig } from "../config/config";
+import { getMessageText } from "../llm/provider";
 const COMMAND_GROUPS = {
     help: "general",
     exit: "general",
     clear: "general",
     run: "general",
+    image: "general",
     config: "agent",
     status: "agent",
     reasoning: "agent",
@@ -141,6 +143,66 @@ export class Repl {
                 await this.runAgent(prompt);
             },
         });
+        this.registerCommand({
+            name: "image",
+            description: t("repl.image"),
+            aliases: ["img"],
+            usage: t("repl.image_usage"),
+            action: async (args) => {
+                const source = args.join(" ");
+                if (!source) {
+                    console.log(t("repl.image_usage"));
+                    return;
+                }
+                try {
+                    const { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage } = await import("../llm/image-utils");
+                    const { existsSync } = await import("fs");
+                    const { resolve } = await import("path");
+                    let dataUrl;
+                    let label;
+                    if (source.toLowerCase() === "clipboard") {
+                        const clipPath = await readClipboardImage();
+                        if (!clipPath) {
+                            console.log(pc.yellow(t("image.clipboard_empty")));
+                            return;
+                        }
+                        const result = loadFileAsDataUrl(clipPath);
+                        dataUrl = result.dataUrl;
+                        label = "clipboard";
+                    }
+                    else if (source.startsWith("http://") || source.startsWith("https://")) {
+                        const result = await loadUrlAsDataUrl(source);
+                        dataUrl = result.dataUrl;
+                        label = source;
+                    }
+                    else {
+                        const absPath = resolve(process.cwd(), source);
+                        if (!existsSync(absPath)) {
+                            console.log(pc.red(t("image.not_found", { path: source })));
+                            return;
+                        }
+                        const result = loadFileAsDataUrl(absPath);
+                        dataUrl = result.dataUrl;
+                        label = source;
+                    }
+                    // Store the image data on the agent's context manager for the next message
+                    const contextManager = this.agent.contextManager;
+                    if (!contextManager) {
+                        console.log(pc.red(t("image.no_context")));
+                        return;
+                    }
+                    contextManager.addPendingImage({
+                        type: "image_url",
+                        image_url: { url: dataUrl },
+                    });
+                    const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
+                    console.log(pc.green(t("image.attached", { source: label, size: `${sizeKb} KB` })));
+                }
+                catch (err) {
+                    console.log(pc.red(t("image.error", { message: err.message })));
+                }
+            },
+        });
         this.registerCommand({
             name: "config",
             description: t("repl.config"),
@@ -444,12 +506,12 @@ export class Repl {
                     for (const msg of history) {
                         if (msg.role === "user") {
                             console.log(pc.cyan(t("session.user_label") + ":"));
-                            console.log(msg.content);
+                            console.log(getMessageText(msg.content));
                             console.log();
                         }
                         else if (msg.role === "assistant") {
                             console.log(pc.green(t("session.assistant_label") + ":"));
-                            console.log(msg.content);
+                            console.log(getMessageText(msg.content));
                             console.log();
                         }
                     }

package/dist/core/agent.js

@@ -12,6 +12,10 @@ export class Agent {
     constructor(deps) {
         this.deps = deps;
     }
+    /** Expose context manager for REPL image attachment and other direct access. */
+    get contextManager() {
+        return this.deps.contextManager;
+    }
     setScope() {
         if (this.deps.scope) {
             this.deps.toolExecutor.setScope(this.deps.scope);

package/dist/i18n/en.json

@@ -431,5 +431,14 @@
     "indexer.no_matches": "No matching files for \"{query}\"",
     "tool.friendly.project_map": "Project map",
     "config.decryption_warning": "Warning: Failed to decrypt config: {error}",
-    "config.encryption_warning": "Warning: Failed to encrypt config: {error}"
+    "config.encryption_warning": "Warning: Failed to encrypt config: {error}",
+    "image.source_required": "Image source is required. Provide a file path, URL, or \"clipboard\".",
+    "image.clipboard_empty": "Clipboard does not contain an image. Copy an image first (e.g. screenshot with Win+Shift+S).",
+    "image.not_found": "Image file not found: {path}",
+    "image.no_context": "No context manager available. Image can only be attached during an active session.",
+    "image.attached": "Image attached from {source} ({size}). It will be included in the next message.",
+    "image.error": "Failed to load image: {message}",
+    "tool.friendly.attach_image": "Attach image",
+    "repl.image": "Attach image",
+    "repl.image_usage": "/image <path|url|clipboard> — attach an image to the next message"
 }

package/dist/i18n/ru.json

@@ -431,5 +431,14 @@
     "indexer.no_matches": "Нет совпадающих файлов для \"{query}\"",
     "tool.friendly.project_map": "Карта проекта",
     "config.decryption_warning": "Предупреждение: не удалось расшифровать конфигурацию: {error}",
-    "config.encryption_warning": "Предупреждение: не удалось зашифровать конфигурацию: {error}"
+    "config.encryption_warning": "Предупреждение: не удалось зашифровать конфигурацию: {error}",
+    "image.source_required": "Укажите источник изображения: путь к файлу, URL или \"clipboard\".",
+    "image.clipboard_empty": "Буфер обмена не содержит изображение. Скопируйте изображение (например, скриншот через Win+Shift+S).",
+    "image.not_found": "Файл изображения не найден: {path}",
+    "image.no_context": "Менеджер контекста недоступен. Изображение можно прикрепить только во время активной сессии.",
+    "image.attached": "Изображение прикреплено из {source} ({size}). Оно будет включено в следующее сообщение.",
+    "image.error": "Не удалось загрузить изображение: {message}",
+    "tool.friendly.attach_image": "Прикрепить изображение",
+    "repl.image": "Прикрепить изображение",
+    "repl.image_usage": "/image <путь|URL|clipboard> — прикрепить изображение к следующему сообщению"
 }

package/dist/llm/image-utils.js

@@ -0,0 +1,121 @@
+import { readFileSync } from "fs";
+import { extname } from "path";
+const MIME_MAP = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".svg": "image/svg+xml",
+};
+/**
+ * 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.
+ * Optionally resize if the raw data exceeds maxBytes.
+ */
+export function loadFileAsDataUrl(filePath, maxBytes) {
+    const mime = detectMime(filePath);
+    let buf = readFileSync(filePath);
+    let resized = false;
+    if (maxBytes && buf.length > maxBytes) {
+        buf = resizePngBuffer(buf, maxBytes);
+        resized = true;
+    }
+    const b64 = buf.toString("base64");
+    return { dataUrl: `data:${mime};base64,${b64}`, mime, resized };
+}
+/**
+ * Load an image from a URL, return as base64 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());
+    const b64 = buf.toString("base64");
+    return { dataUrl: `data:${mime};base64,${b64}`, mime };
+}
+/**
+ * Read image from system clipboard (platform-specific).
+ * Returns null if clipboard has no image.
+ */
+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`;
+        const ps = [
+            "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"',
+            "}",
+        ].join("; ");
+        const out = execSync(`powershell -NoProfile -Command "${ps}"`, {
+            timeout: 5000,
+            encoding: "utf-8",
+        });
+        if (out.includes("OK")) {
+            return tmpPath;
+        }
+        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;
+    }
+}
+/**
+ * Rough PNG resize by reducing dimensions.
+ * This is a naive approach — for production, use sharp or jimp.
+ * For now, we just warn if image is too large and return as-is.
+ */
+function resizePngBuffer(buf, _maxBytes) {
+    // Without a native image library, we can't reliably resize.
+    // Return as-is and let the model handle it (or fail gracefully).
+    // TODO: integrate sharp for proper resize
+    return buf;
+}

package/dist/llm/provider.js

@@ -1,2 +1,10 @@
 // src/llm/provider.ts
-export {};
+/** Helper: extract plain text from message content (for token counting, logging, etc.) */
+export function getMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((p) => p.type === "text")
+        .map((p) => p.text)
+        .join("");
+}

package/dist/llm/token-counter.js

@@ -1,5 +1,6 @@
 // src/llm/token-counter.ts
 import { encodingForModel, getEncoding } from "js-tiktoken";
+import { getMessageText } from "./provider";
 export class TokenCounter {
     encoder;
     constructor(model = "gpt-4o") {
@@ -21,7 +22,8 @@ export class TokenCounter {
         for (const msg of messages) {
             // ~4 tokens per message overhead (role, boundaries)
             total += 4;
-            total += this.count(msg.content);
+            const text = getMessageText(msg.content);
+            total += this.count(text);
             if (msg.role === "tool")
                 total += 2; // tool_call_id
         }

package/dist/modules/context/manager.js

@@ -1,3 +1,4 @@
+import { getMessageText } from "../../llm/provider";
 const COMPACTION_INTERVAL = 15;
 const KEEP_LAST_N = 6;
 export class ContextManager {
@@ -11,6 +12,7 @@ export class ContextManager {
     decisionFacts = [];
     errorFacts = [];
     tokenCounter;
+    pendingImageParts = [];
     onCompact = null;
     constructor(contextWindow, contextBudget, tokenCounter) {
         this.contextWindow = contextWindow;
@@ -36,15 +38,64 @@ export class ContextManager {
         return { ...this.budget };
     }
     addMessage(msg) {
+        // Auto-attach pending images to the next user message
+        if (msg.role === "user" && this.pendingImageParts.length > 0) {
+            const textPart = {
+                type: "text",
+                text: typeof msg.content === "string" ? msg.content : getMessageText(msg.content),
+            };
+            msg = {
+                ...msg,
+                content: [textPart, ...this.pendingImageParts],
+            };
+            this.pendingImageParts = [];
+        }
         this.messages.push(msg);
         this.iterationsSinceCompaction++;
     }
+    /**
+     * Queue an image part to be attached to the next user message.
+     */
+    addPendingImage(part) {
+        this.pendingImageParts.push(part);
+    }
+    /**
+     * Check if there are pending images waiting to be attached.
+     */
+    hasPendingImages() {
+        return this.pendingImageParts.length > 0;
+    }
+    /**
+     * Get pending image parts without clearing them.
+     */
+    getPendingImages() {
+        return [...this.pendingImageParts];
+    }
+    /**
+     * Clear pending images (e.g., if user sends a text-only message).
+     */
+    clearPendingImages() {
+        this.pendingImageParts = [];
+    }
     getMessageCount() {
         return this.messages.length;
     }
     estimateMessageTokens(m) {
+        const text = getMessageText(m.content);
         if (this.tokenCounter) {
-            let t = this.tokenCounter.count(m.content);
+            let t = this.tokenCounter.count(text);
+            // Image tokens: base64 ~130 tokens per 512x512 tile; rough estimate
+            if (Array.isArray(m.content)) {
+                for (const part of m.content) {
+                    if (part.type === "image_url" && part.image_url?.url) {
+                        const b64Len = part.image_url.url.includes(",")
+                            ? part.image_url.url.split(",")[1]?.length ?? 0
+                            : part.image_url.url.length;
+                        // ~130 tokens per 512 bytes of base64
+                        t += Math.ceil(b64Len / 512) * 130;
+                    }
+                }
+            }
             if (m.tool_calls) {
                 for (const tc of m.tool_calls) {
                     t += this.tokenCounter.count(tc.id);
@@ -55,7 +106,17 @@ export class ContextManager {
             }
             return t;
         }
-        let t = Math.ceil(m.content.length / 2);
+        let t = Math.ceil(text.length / 2);
+        if (Array.isArray(m.content)) {
+            for (const part of m.content) {
+                if (part.type === "image_url" && part.image_url?.url) {
+                    const b64Len = part.image_url.url.includes(",")
+                        ? part.image_url.url.split(",")[1]?.length ?? 0
+                        : part.image_url.url.length;
+                    t += Math.ceil(b64Len / 512) * 130;
+                }
+            }
+        }
         if (m.tool_calls) {
             for (const tc of m.tool_calls) {
                 t += Math.ceil(tc.id.length / 2);
@@ -113,7 +174,7 @@ export class ContextManager {
             /file (?:created|updated|written|deleted|moved):? ([\w./\\-]+\.[a-z]+)/gi,
         ];
         for (const msg of turns) {
-            const content = msg.content;
+            const content = getMessageText(msg.content);
             if (msg.role === "tool") {
                 for (const pattern of filePatterns) {
                     for (const match of content.matchAll(pattern)) {

package/dist/tools/attach-image.js

@@ -0,0 +1,90 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { t } from "../i18n/index";
+import { loadFileAsDataUrl, loadUrlAsDataUrl, readClipboardImage } 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.",
+    tags: ["vision", "image"],
+    parameters: {
+        type: "object",
+        properties: {
+            source: {
+                type: "string",
+                description: 'Image source: file path (e.g. "./screenshot.png"), URL (e.g. "https://example.com/img.png"), or "clipboard" to read from system clipboard.',
+            },
+        },
+        required: ["source"],
+    },
+    handler: async (ctx, args) => {
+        const source = String(args.source ?? "").trim();
+        if (!source) {
+            return { success: false, output: t("image.source_required") };
+        }
+        try {
+            let dataUrl;
+            if (source.toLowerCase() === "clipboard") {
+                const clipPath = await readClipboardImage();
+                if (!clipPath) {
+                    return {
+                        success: false,
+                        output: t("image.clipboard_empty"),
+                    };
+                }
+                const result = loadFileAsDataUrl(clipPath, MAX_IMAGE_BYTES);
+                dataUrl = result.dataUrl;
+            }
+            else if (source.startsWith("http://") || source.startsWith("https://")) {
+                const result = await loadUrlAsDataUrl(source);
+                dataUrl = result.dataUrl;
+            }
+            else {
+                const absPath = resolve(ctx.baseDir, source);
+                if (!existsSync(absPath)) {
+                    return {
+                        success: false,
+                        output: t("image.not_found", { path: source }),
+                    };
+                }
+                // Security: check path scope
+                if (ctx.scope) {
+                    const { isPathInScope } = await import("../modules/security/path-validator");
+                    const validation = isPathInScope(ctx.baseDir, absPath, ctx.scope);
+                    if (!validation.allowed) {
+                        logSecurityBlock(ctx.sessionId, "file_read", validation.reason ?? "attach_image out of scope", absPath);
+                        return {
+                            success: false,
+                            output: t("file.path_not_allowed", { path: source }),
+                        };
+                    }
+                }
+                const result = loadFileAsDataUrl(absPath, MAX_IMAGE_BYTES);
+                dataUrl = result.dataUrl;
+            }
+            // Add the image as a pending content part on the context manager
+            if (!ctx.contextManager) {
+                return {
+                    success: false,
+                    output: t("image.no_context"),
+                };
+            }
+            ctx.contextManager.addPendingImage({
+                type: "image_url",
+                image_url: { url: dataUrl },
+            });
+            const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
+            return {
+                success: true,
+                output: t("image.attached", { source, size: `${sizeKb} KB` }),
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: t("image.error", { message: err.message }),
+            };
+        }
+    },
+};

package/dist/tools/index.js

@@ -25,9 +25,10 @@ import { pipelineRunTool } from './pipeline-run';
 import { mcpCallTool } from './mcp-call';
 import { searchHistoryTool } from './search-history';
 import { createBrowserTool } from './browser';
+import { attachImageTool } from './attach-image';
 export { ToolRegistry, ToolExecutor };
 export { filterToolsByTags } from './filter-tools';
-export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, questionTool, approveTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, createBrowserTool, };
+export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, questionTool, approveTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, createBrowserTool, attachImageTool, };
 export function registerAllTools(registry, skillsModule) {
     const tools = [
         readFileTool, writeFileTool, editFileTool,
@@ -38,6 +39,7 @@ export function registerAllTools(registry, skillsModule) {
         webSearchTool, webFetchTool, webBrowseTool,
         questionTool, approveTool,
         pipelineRunTool, mcpCallTool, searchHistoryTool,
+        attachImageTool,
     ];
     if (skillsModule) {
         tools.push(createLoadSkillTool(skillsModule));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micro-models-agent",
-  "version": "0.13.3",
+  "version": "0.14.1",
   "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
   "type": "module",
   "bin": {