micro-models-agent 0.57.0 → 0.57.2

package/dist/index.js

@@ -0,0 +1,22 @@
+export { DEFAULTS, loadConfig } from "./config/index";
+export { Logger } from "./logger/index";
+export { PromptBuilder } from "./core/index";
+export { OpenAICompatProvider, TokenCounter, parseChunks, OrchestratorClient } from "./llm/index";
+export { ToolRegistry, ToolExecutor, readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, webSearchTool, webFetchTool, webBrowseTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, registerAllTools, } from "./tools/index";
+export { MigrationDetector, BackupManager } from "./migration/index";
+import { MigrationDetector } from "./migration/detect";
+import { BackupManager } from "./migration/backup";
+import { t } from "./i18n/index";
+import { homedir } from "os";
+import { join } from "path";
+export function checkMigration(configDir) {
+    const dir = configDir || join(homedir(), ".mma");
+    const detector = new MigrationDetector(dir);
+    if (detector.needsMigration()) {
+        const backup = new BackupManager(dir);
+        backup.backupConfig();
+        backup.backupAll();
+        const summary = backup.getBackupSummary();
+        console.log(t("migration.summary", { summary }));
+    }
+}

package/dist/llm/image-utils.js

@@ -0,0 +1,143 @@
+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";
+}
+/**
+ * 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 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");
+    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, 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 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:image/png;base64,${b64}` };
+}
+/**
+ * Process a clipboard buffer (already resized by readClipboardImage)
+ * into a data URL. Used by Ctrl+V handler.
+ */
+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
+        }
+    }
+    const b64 = buf.toString("base64");
+    return { dataUrl: `data:image/png;base64,${b64}` };
+}

package/dist/llm/index.js

@@ -0,0 +1,4 @@
+export { OpenAICompatProvider } from "./openai-compat";
+export { TokenCounter } from "./token-counter";
+export { parseChunks } from "./response";
+export { OrchestratorClient } from "./orchestrator";

package/dist/llm/model-loader.js

@@ -0,0 +1,78 @@
+export class ModelLoader {
+    baseUrl;
+    logger;
+    constructor(baseUrl, logger) {
+        const url = baseUrl.replace(/\/$/, "");
+        this.baseUrl = url.replace(/\/v1\/?$/, "");
+        this.logger = logger;
+    }
+    async ensureModelLoaded(config) {
+        if (config.autoLoad === false) {
+            return { success: true, alreadyLoaded: true };
+        }
+        try {
+            const isLoaded = await this.isModelLoaded(config.model, config.contextLength);
+            if (isLoaded) {
+                this.logger.debug(`Model ${config.model} already loaded with correct context`);
+                return { success: true, alreadyLoaded: true };
+            }
+            return await this.loadModel(config);
+        }
+        catch (err) {
+            this.logger.error(`Model loader failed: ${err.message}`);
+            return { success: false, error: err.message };
+        }
+    }
+    async isModelLoaded(model, contextLength) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/v1/models`, {
+                signal: AbortSignal.timeout(3000),
+            });
+            if (!response.ok)
+                return false;
+            const data = (await response.json());
+            const models = data.models || [];
+            const found = models.find((m) => m.key === model || m.name === model);
+            if (!found)
+                return false;
+            const loadedInstances = found.loaded_instances || [];
+            return loadedInstances.some((inst) => inst.config?.context_length === contextLength);
+        }
+        catch {
+            return false;
+        }
+    }
+    async loadModel(config) {
+        const body = {
+            model: config.model,
+            context_length: config.contextLength,
+        };
+        if (config.flashAttention !== undefined)
+            body.flash_attention = config.flashAttention;
+        if (config.evalBatchSize !== undefined)
+            body.eval_batch_size = config.evalBatchSize;
+        if (config.offloadKvCacheToGpu !== undefined)
+            body.offload_kv_cache_to_gpu = config.offloadKvCacheToGpu;
+        this.logger.info(`Loading model ${config.model} with context_length=${config.contextLength}`);
+        this.logger.debug(`POST ${this.baseUrl}/api/v1/models/load`);
+        const response = await fetch(`${this.baseUrl}/api/v1/models/load`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(120000),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            this.logger.error(`Model load failed: HTTP ${response.status}: ${error}`);
+            return { success: false, error: `HTTP ${response.status}: ${error}` };
+        }
+        const result = (await response.json());
+        this.logger.debug(`Model load response: ${JSON.stringify(result)}`);
+        const loadTime = result.load_time_seconds ?? result.loadTime;
+        return {
+            success: true,
+            alreadyLoaded: false,
+            loadTime,
+        };
+    }
+}