micro-models-agent 0.57.0 → 0.57.1

package/dist/tools/read-file.js

@@ -0,0 +1,179 @@
+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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,85 @@
+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) }),
+            };
+        }
+    },
+};