micro-models-agent 0.54.1 → 0.55.1

package/dist/tools/read-file.js

@@ -1,179 +0,0 @@
-import { readFileSync, existsSync, statSync, openSync, readSync, closeSync } from "fs";
-import { extname } from "path";
-import { t } from "../i18n/index";
-import { isPathInScope } from "../modules/security/path-validator";
-import { DEFAULT_SECURITY_CONFIG } from "../config/security";
-import { logSecurityBlock } from "../modules/security/audit-log";
-import { safeResolvePath } from "./path-utils";
-/**
- * Default lines per read_file call. Deliberately much larger than
- * MAX_PREVIEW_LINES (15): a 15-line default forces the model to issue 10-17
- * calls per file, which floods the context and drives compaction every 15
- * iterations (observed: 96 read_file calls, App.tsx read 23x, then 11
- * compactions in ~20 min that deleted the user's task mid-turn). 300 lines
- * covers typical component files in one call while still capping output.
- */
-const DEFAULT_LIMIT = 300;
-/**
- * Files larger than this are read through a bounded streaming path instead of
- * readFileSync (which loads the whole file into memory just to slice a few
- * hundred lines).
- */
-const LARGE_FILE_BYTES = 1024 * 1024;
-const STREAM_CHUNK = 256 * 1024;
-/**
- * Bounded line-slice read for large files: streams the file in chunks,
- * collects only the requested [offset, offset+limit) window, then counts the
- * remaining newlines raw (no decode) to produce the total. Memory stays
- * bounded regardless of file size.
- */
-function readLineSlice(path, offset, limit) {
-    const fd = openSync(path, "r");
-    try {
-        const buf = Buffer.alloc(STREAM_CHUNK);
-        let pos = 0;
-        let carry = "";
-        let lineNumber = 1;
-        let total = 0;
-        const collected = [];
-        const endLine = offset + limit; // exclusive
-        while (true) {
-            const bytes = readSync(fd, buf, 0, STREAM_CHUNK, pos);
-            if (bytes === 0)
-                break;
-            pos += bytes;
-            const chunk = carry + buf.toString("utf-8", 0, bytes);
-            const parts = chunk.split("\n");
-            carry = parts.pop() ?? "";
-            for (const line of parts) {
-                total++;
-                if (lineNumber >= offset && lineNumber < endLine)
-                    collected.push(line);
-                lineNumber++;
-            }
-            if (lineNumber >= endLine && collected.length >= limit) {
-                // Window complete — count remaining newlines without decoding.
-                const rest = [];
-                while (true) {
-                    const n = readSync(fd, buf, 0, STREAM_CHUNK, pos);
-                    if (n === 0)
-                        break;
-                    pos += n;
-                    rest.push(Buffer.from(buf.subarray(0, n)));
-                }
-                const tail = Buffer.concat([...rest, Buffer.from(carry, "utf-8")]);
-                for (let i = 0; i < tail.length; i++)
-                    if (tail[i] === 0x0a)
-                        total++;
-                total++; // last line has no trailing newline
-                return { selected: collected.join("\n"), total };
-            }
-        }
-        if (carry.length > 0 || total === 0) {
-            total++;
-            if (lineNumber >= offset && lineNumber < endLine)
-                collected.push(carry);
-        }
-        return { selected: collected.join("\n"), total };
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export const readFileTool = {
-    name: "read_file",
-    icon: "👀",
-    description: `Read a file from the filesystem. Reads up to ${DEFAULT_LIMIT} lines at a time by default; use offset to page through large files.`,
-    tags: ["file", "code"],
-    boundedOutput: true,
-    parameters: {
-        type: "object",
-        properties: {
-            path: { type: "string", description: "File path to read" },
-            offset: {
-                type: "number",
-                description: `Starting line (1-indexed). Use offset=<next> from a truncated result to continue reading.`,
-            },
-            limit: {
-                type: "number",
-                description: `Number of lines to read (default ${DEFAULT_LIMIT})`,
-            },
-        },
-        required: ["path"],
-    },
-    handler: async (ctx, args) => {
-        const path = String(args.path);
-        const resolved = safeResolvePath(ctx.baseDir, path);
-        const securityPaths = ctx.config?.security?.paths || DEFAULT_SECURITY_CONFIG.paths;
-        const scopeCheck = isPathInScope(ctx.baseDir, resolved, ctx.scope, securityPaths);
-        if (!scopeCheck.allowed) {
-            const pathStr = path;
-            logSecurityBlock(ctx.sessionId || undefined, "file_read", scopeCheck.reason || "Path not allowed", pathStr);
-            return {
-                success: false,
-                output: t("file.path_not_allowed", {
-                    path: `${path} — ${scopeCheck.reason}`,
-                }),
-            };
-        }
-        if (!existsSync(resolved)) {
-            // For relative paths, tell the model WHERE the path resolved — the
-            // "not found" alone is confusing (it cannot tell baseDir from cwd).
-            const output = resolved !== path
-                ? t("file.notfound_resolved", {
-                    path,
-                    resolved,
-                })
-                : t("file.notfound", { path });
-            return { success: false, output };
-        }
-        const offset = args.offset || 1;
-        const limit = args.limit || DEFAULT_LIMIT;
-        let lines;
-        let total;
-        let selected;
-        if (statSync(resolved).size > LARGE_FILE_BYTES) {
-            const slice = readLineSlice(resolved, offset, limit);
-            total = slice.total;
-            selected = slice.selected;
-        }
-        else {
-            const content = readFileSync(resolved, "utf-8");
-            lines = content.split("\n");
-            total = lines.length;
-            const end = Math.min(offset - 1 + limit, total);
-            selected = lines.slice(offset - 1, end).join("\n");
-        }
-        const end = Math.min(offset - 1 + limit, total);
-        const ext = extname(resolved) || "(no extension)";
-        const header = t("file.read_header", {
-            path,
-            ext,
-            total: String(total),
-            from: String(offset),
-            to: String(end),
-        });
-        const truncated = end < total
-            ? t("file.read_truncated", {
-                remaining: String(total - end),
-                next: String(end + 1),
-            })
-            : "";
-        // Compact user-facing display: the tool header already shows the path,
-        // so only a partial read needs extra info (the range within the file).
-        // A full read adds nothing — keeps the card to two lines.
-        const fullRead = offset === 1 && end >= total;
-        const display = fullRead
-            ? ""
-            : t("file.read_range", {
-                from: String(offset),
-                to: String(end),
-                total: String(total),
-            });
-        return {
-            success: true,
-            output: `${header}\n${selected}${truncated}`,
-            display,
-        };
-    },
-};

package/dist/tools/recall.js

@@ -1,118 +0,0 @@
-import { homedir } from "os";
-import { join } from "path";
-import { t } from "../i18n/index";
-import { MemoryStore } from "../modules/memory/store";
-const CATEGORIES = ["preferences", "conventions", "decisions", "errors", "facts"];
-export const recallTool = {
-    name: "recall",
-    icon: "💾",
-    description: "Recall stored information from memory. Search across preferences, facts, conventions, decisions, errors.",
-    tags: ["memory"],
-    parameters: {
-        type: "object",
-        properties: {
-            query: {
-                type: "string",
-                description: "Search query (full-text search across all memory)",
-            },
-            category: {
-                type: "string",
-                description: "Limit to specific category: preferences, conventions, decisions, errors, facts",
-                enum: CATEGORIES,
-            },
-        },
-    },
-    handler: async (_ctx, args) => {
-        const query = args.query ? String(args.query) : "";
-        const category = args.category ? String(args.category) : "";
-        const memoryDir = join(homedir(), ".mma", "memory");
-        const store = new MemoryStore(memoryDir);
-        try {
-            // No query, no category → show everything
-            if (!query && !category) {
-                return { success: true, output: formatAll(store) };
-            }
-            // Category only → show that category
-            if (!query && category) {
-                return { success: true, output: formatCategory(store, category) };
-            }
-            // Query with optional category → search
-            if (category) {
-                const results = searchCategory(store, category, query);
-                if (results.length === 0) {
-                    return { success: true, output: t("tool.recall.empty", { query }) };
-                }
-                return {
-                    success: true,
-                    output: t("tool.recall.search_results", { category, results: results.join("\n") }),
-                };
-            }
-            // Query across all
-            const results = store.search(query);
-            if (results.length === 0) {
-                return { success: true, output: t("tool.recall.empty", { query }) };
-            }
-            const formatted = results.map((r) => `[${r.file}] ${r.match}`).join("\n");
-            return {
-                success: true,
-                output: t("tool.recall.search_results", { category: "all", results: formatted }),
-            };
-        }
-        catch (err) {
-            return { success: true, output: t("tool.memory_error", { error: String(err) }) };
-        }
-    },
-};
-function formatAll(store) {
-    const parts = [];
-    const prefs = store.getPreferences();
-    if (Object.keys(prefs).length > 0) {
-        parts.push("Preferences:");
-        for (const [k, v] of Object.entries(prefs)) {
-            parts.push(`  ${k} = ${v}`);
-        }
-    }
-    for (const cat of ["facts", "conventions", "decisions", "errors"]) {
-        const content = store.read(cat);
-        const entries = content.split("\n").filter((l) => l.startsWith("- "));
-        if (entries.length > 0) {
-            parts.push(`\n${cat.charAt(0).toUpperCase() + cat.slice(1)} (last 5):`);
-            for (const e of entries.slice(-5)) {
-                parts.push(`  ${e}`);
-            }
-        }
-    }
-    return parts.length > 0 ? parts.join("\n") : t("tool.recall.no_memory");
-}
-function formatCategory(store, category) {
-    if (category === "preferences") {
-        const prefs = store.getPreferences();
-        if (Object.keys(prefs).length === 0)
-            return t("tool.recall.no_memory");
-        const lines = ["Preferences:"];
-        for (const [k, v] of Object.entries(prefs)) {
-            lines.push(`  ${k} = ${v}`);
-        }
-        return lines.join("\n");
-    }
-    const content = store.read(category);
-    const entries = content.split("\n").filter((l) => l.startsWith("- "));
-    if (entries.length === 0)
-        return t("tool.recall.no_memory");
-    return `${category.charAt(0).toUpperCase() + category.slice(1)} (${entries.length} entries):\n${entries.join("\n")}`;
-}
-function searchCategory(store, category, query) {
-    if (category === "preferences") {
-        const prefs = store.getPreferences();
-        const lower = query.toLowerCase();
-        return Object.entries(prefs)
-            .filter(([k, v]) => k.toLowerCase().includes(lower) || v.toLowerCase().includes(lower))
-            .map(([k, v]) => `  ${k} = ${v}`);
-    }
-    const content = store.read(category);
-    const lower = query.toLowerCase();
-    return content
-        .split("\n")
-        .filter((l) => l.startsWith("- ") && l.toLowerCase().includes(lower))
-        .map((l) => `  ${l}`);
-}

package/dist/tools/registry.js

@@ -1,47 +0,0 @@
-export class ToolRegistry {
-    tools = new Map();
-    register(tool) {
-        if (this.tools.has(tool.name)) {
-            throw new Error(`Tool already registered: ${tool.name}`);
-        }
-        this.tools.set(tool.name, tool);
-    }
-    get(name) {
-        return this.tools.get(name);
-    }
-    has(name) {
-        return this.tools.has(name);
-    }
-    list() {
-        return Array.from(this.tools.keys()).sort();
-    }
-    getAll() {
-        return Array.from(this.tools.values());
-    }
-    getByTags(tags) {
-        return this.getAll().filter((t) => {
-            if (!t.tags || t.tags.length === 0)
-                return false;
-            return tags.some((tag) => t.tags.includes(tag));
-        });
-    }
-    /**
-     * Tools to expose to the LLM. Always includes `alwaysOn` tools, then tools
-     * matching the given tags. When no tags are given, returns every registered
-     * tool (backward-compatible). Duplicates are impossible because the
-     * alwaysOn + tagged sets are unioned by name.
-     */
-    getAllForLLM(tags) {
-        const all = this.getAll();
-        const tagSet = new Set(tags ?? []);
-        const selected = tagSet.size === 0
-            ? all
-            : all.filter((t) => t.alwaysOn || (t.tags && t.tags.some((tag) => tagSet.has(tag))));
-        return selected.map((t) => ({
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters,
-            boundedOutput: t.boundedOutput,
-        }));
-    }
-}

package/dist/tools/remember.js

@@ -1,68 +0,0 @@
-import { homedir } from "os";
-import { join } from "path";
-import { t } from "../i18n/index";
-import { MemoryStore } from "../modules/memory/store";
-const CATEGORIES = ["preferences", "conventions", "decisions", "errors", "facts"];
-export const rememberTool = {
-    name: "remember",
-    icon: "🧠",
-    description: "Remember information across sessions. Use for user preferences, facts, conventions, decisions, or errors.",
-    tags: ["memory"],
-    parameters: {
-        type: "object",
-        properties: {
-            category: {
-                type: "string",
-                description: "Memory category: preferences, conventions, decisions, errors, facts",
-                enum: CATEGORIES,
-            },
-            key: {
-                type: "string",
-                description: 'Key name (required for preferences, e.g. "color", "language")',
-            },
-            value: {
-                type: "string",
-                description: "Value to store (required for preferences)",
-            },
-            entry: {
-                type: "string",
-                description: "Text entry to append (for conventions, decisions, errors, facts)",
-            },
-        },
-        required: ["category"],
-    },
-    handler: async (_ctx, args) => {
-        const category = String(args.category || "");
-        if (!CATEGORIES.includes(category)) {
-            return { success: false, output: t("tool.invalid_params") };
-        }
-        const memoryDir = join(homedir(), ".mma", "memory");
-        const store = new MemoryStore(memoryDir);
-        try {
-            if (category === "preferences") {
-                const key = String(args.key || "");
-                const value = String(args.value || "");
-                if (!key) {
-                    return { success: false, output: t("tool.remember.key_required") };
-                }
-                store.setPreference(key, value);
-                return {
-                    success: true,
-                    output: t("tool.remember.preference", { key, value }),
-                };
-            }
-            const entry = String(args.entry || "");
-            if (!entry) {
-                return { success: false, output: t("tool.remember.entry_required") };
-            }
-            store.append(category, entry);
-            return {
-                success: true,
-                output: t("tool.remember.entry", { category, entry }),
-            };
-        }
-        catch (err) {
-            return { success: true, output: t("tool.memory_error", { error: String(err) }) };
-        }
-    },
-};

package/dist/tools/scope-check.js

@@ -1,32 +0,0 @@
-import { resolve, normalize } from "path";
-import { isInsideDir, matchesScopeEntry } from "./path-utils";
-export function isPathInScope(baseDir, targetPath, scope) {
-    const baseResolved = resolve(baseDir);
-    const targetResolved = resolve(baseDir, normalize(targetPath));
-    // Separator- and case-safe containment (sibling prefixes cannot pass).
-    if (!isInsideDir(targetResolved, baseResolved)) {
-        return { allowed: false, reason: "Path is outside the base working directory" };
-    }
-    if (!scope)
-        return { allowed: true };
-    const isRead = scope.read_only_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
-    const isWrite = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
-    if (isWrite)
-        return { allowed: true };
-    if (isRead)
-        return { allowed: true, reason: "Read-only file" };
-    return { allowed: false, reason: "Path is not within the allowed scope for this sub-agent" };
-}
-export function isPathWritable(baseDir, targetPath, scope) {
-    const baseResolved = resolve(baseDir);
-    const targetResolved = resolve(baseDir, normalize(targetPath));
-    if (!isInsideDir(targetResolved, baseResolved)) {
-        return { allowed: false, reason: "Path is outside the base working directory" };
-    }
-    if (!scope)
-        return { allowed: true };
-    const isWrite = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
-    if (isWrite)
-        return { allowed: true };
-    return { allowed: false, reason: "Path is not within the writable scope for this sub-agent" };
-}

package/dist/tools/search-history.js

@@ -1,85 +0,0 @@
-import * as fs from "fs";
-import { join } from "path";
-import { homedir } from "os";
-import { t } from "../i18n/index";
-function searchFile(filePath, query, maxResults, results) {
-    if (!fs.existsSync(filePath))
-        return;
-    const content = fs.readFileSync(filePath, "utf-8");
-    for (const line of content.split("\n").filter(Boolean)) {
-        if (line.toLowerCase().includes(query)) {
-            try {
-                const entry = JSON.parse(line);
-                results.push(`[${filePath}] ${JSON.stringify(entry).slice(0, 200)}`);
-            }
-            catch {
-                /* skip */
-            }
-        }
-        if (results.length >= maxResults)
-            break;
-    }
-}
-export const searchHistoryTool = {
-    name: "search_history",
-    icon: "🕵️",
-    description: "Search through session history for past interactions across all sessions.",
-    tags: ["research"],
-    parameters: {
-        type: "object",
-        properties: {
-            query: { type: "string", description: "Search query" },
-            maxResults: {
-                type: "number",
-                description: "Maximum results (default 5)",
-            },
-            sessionId: {
-                type: "string",
-                description: "Optional: limit search to a specific session",
-            },
-        },
-        required: ["query"],
-    },
-    handler: async (_ctx, args) => {
-        const query = String(args.query || "").toLowerCase();
-        const maxResults = Number(args.maxResults) || 5;
-        const sessionId = args.sessionId ? String(args.sessionId) : null;
-        const sessionDir = join(homedir(), ".mma", "sessions");
-        const results = [];
-        try {
-            if (!fs.existsSync(sessionDir)) {
-                return {
-                    success: true,
-                    output: t("tool.no_sessions_dir", { dir: sessionDir }),
-                };
-            }
-            const entries = fs.readdirSync(sessionDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory())
-                    continue;
-                if (sessionId && entry.name !== sessionId)
-                    continue;
-                const historyFile = join(sessionDir, entry.name, "history.jsonl");
-                searchFile(historyFile, query, maxResults, results);
-                if (results.length >= maxResults)
-                    break;
-            }
-            if (results.length === 0) {
-                return { success: true, output: t("tool.no_history", { query }) };
-            }
-            return {
-                success: true,
-                output: t("tool.history_results", {
-                    query,
-                    results: results.join("\n"),
-                }),
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                output: t("tool.history_error", { error: String(err) }),
-            };
-        }
-    },
-};