micro-models-agent 0.50.4 → 0.51.2

package/dist/tools/remember.js

@@ -1,67 +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",
-    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,30 +0,0 @@
-import { resolve, normalize } from "path";
-export function isPathInScope(baseDir, targetPath, scope) {
-    const baseResolved = resolve(baseDir);
-    const targetResolved = resolve(baseDir, normalize(targetPath));
-    if (!targetResolved.startsWith(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) => targetResolved.startsWith(resolve(baseDir, f)));
-    const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(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 (!targetResolved.startsWith(baseResolved)) {
-        return { allowed: false, reason: "Path is outside the base working directory" };
-    }
-    if (!scope)
-        return { allowed: true };
-    const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(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,84 +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",
-    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) }),
-            };
-        }
-    },
-};

package/dist/tools/subagent.js

@@ -1,196 +0,0 @@
-import { t } from "../i18n/index";
-import { Agent } from "../core/agent";
-import { ContextManager } from "../modules/context/manager";
-import { HallucinationDetector } from "../modules/hallucination/detector";
-import { PluginManager } from "../modules/plugins/manager";
-import { logSecurityBlock } from "../modules/security/audit-log";
-import { getSessionSecurityConfig } from "../modules/security/session-isolation";
-import { ArtifactStore } from "../modules/artifacts/store";
-/** Fixed system prompt (KV-cache friendly when stableSystemPrompt is on). */
-export const SUBAGENT_SYSTEM_PROMPT_TEMPLATE = `You are a sub-agent working on a specific task. You have your own context window and tool set.
-
-Workflow rules:
-- Prefer small, focused steps. Verify your own work (typecheck/tests) before finishing.
-- For large outputs, write the result to a file with write_file instead of reproducing it in your answer.
-- If the task is big and decomposable, delegate parts to the subagent tool instead of doing everything in one context.
-- When you finish, return a concise final answer; do not repeat file contents verbatim if you already wrote them to disk.`;
-function buildSubagentSystemPrompt(context, stable) {
-    if (stable)
-        return SUBAGENT_SYSTEM_PROMPT_TEMPLATE;
-    return `You are a sub-agent working on a specific task. ${context ? `Context: ${context}` : ""}`;
-}
-export const subagentTool = {
-    name: "subagent",
-    description: "Spawn an isolated sub-agent to work on a task independently. The sub-agent has its own context and executes autonomously. Use for parallel work or complex sub-tasks.",
-    tags: ["code"],
-    parameters: {
-        type: "object",
-        properties: {
-            task: {
-                type: "string",
-                description: "Task description for the sub-agent",
-            },
-            context: {
-                type: "string",
-                description: "Optional context or constraints",
-            },
-            expert_tag: {
-                type: "string",
-                description: "Expert tag for tool filtering and model selection",
-            },
-            allowed_files: {
-                type: "array",
-                items: { type: "string" },
-                description: "Files/directories the sub-agent can read and write",
-            },
-            read_only_files: {
-                type: "array",
-                items: { type: "string" },
-                description: "Files/directories the sub-agent can read but not write",
-            },
-            shared_context: {
-                type: "string",
-                description: "Shared context/rules passed to the sub-agent",
-            },
-            max_tokens: {
-                type: "number",
-                description: "Maximum tokens for the sub-agent response",
-            },
-            tool_tags: {
-                type: "array",
-                items: { type: "string" },
-                description: "Tool tags to expose to the sub-agent",
-            },
-            result_mode: {
-                type: "string",
-                enum: ["text", "file"],
-                description: '"file": persist the full result to an artifact and return a path + summary (pass-by-reference). "text" (default): return the full text into context.',
-            },
-            artifact_name: {
-                type: "string",
-                description: "Artifact file name (sanitized). Default: subagent-<timestamp>.",
-            },
-        },
-        required: ["task"],
-    },
-    handler: async (ctx, args) => {
-        const task = String(args.task || "");
-        const context = String(args.context || "");
-        if (!task) {
-            return { success: false, output: t("tool.name_or_task") };
-        }
-        // Get session-specific security config
-        const securityConfig = ctx.sessionContext
-            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
-            : ctx.config.security;
-        // Security check: limit recursion depth
-        const maxDepth = securityConfig?.maxRecursionDepth ?? 3;
-        const currentDepth = ctx.recursionDepth ?? 0;
-        if (currentDepth >= maxDepth) {
-            logSecurityBlock(ctx.sessionId, "bash_command", `Maximum recursion depth (${maxDepth}) exceeded`, task);
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] Maximum sub-agent recursion depth (${maxDepth}) exceeded`,
-            };
-        }
-        const scope = args.allowed_files || args.read_only_files
-            ? {
-                allowed_files: args.allowed_files || [],
-                read_only_files: args.read_only_files || [],
-            }
-            : ctx.scope;
-        const toolTags = args.tool_tags ? args.tool_tags : undefined;
-        if (!ctx.llmProvider || !ctx.toolExecutor) {
-            return {
-                success: false,
-                output: "Sub-agent cannot run: missing llmProvider or toolExecutor in context",
-            };
-        }
-        // Defensive guard: if the caller requested specific tool tags but none of the
-        // registered tools match, the sub-agent would have zero tools and would
-        // hallucinate instead of acting. Warn the caller so it can correct the tags.
-        // Uses getByTags (not getAllForLLM) because alwaysOn tools always match the
-        // latter — the guard must test real tag coverage, not schema presence.
-        if (toolTags && toolTags.length > 0) {
-            const matched = ctx.toolExecutor.getRegistry().getByTags(toolTags);
-            if (matched.length === 0) {
-                return {
-                    success: false,
-                    output: `[SECURITY BLOCKED] No tools match the requested tool_tags: [${toolTags.join(", ")}]. Check the subagent tool_tags parameter and retry with valid tags (e.g. "file", "code", "shell", "research").`,
-                };
-            }
-        }
-        try {
-            const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
-            const subPluginManager = new PluginManager();
-            const hallucinationDetector = new HallucinationDetector(ctx.baseDir, ctx.llmProvider);
-            // Save/restore the shared executor scope so the sub-agent doesn't
-            // permanently mutate the parent's scope.
-            const parentScope = ctx.scope;
-            ctx.toolExecutor.setScope(scope || { allowed_files: [], read_only_files: [] });
-            const systemPrompt = {
-                content: buildSubagentSystemPrompt(context, ctx.config.subagent?.stableSystemPrompt !== false),
-                priority: "critical",
-                essential: true,
-                estimatedTokens: 150,
-            };
-            const subDeps = {
-                config: ctx.config,
-                llmProvider: ctx.llmProvider,
-                toolExecutor: ctx.toolExecutor,
-                pluginManager: subPluginManager,
-                contextManager: subContextManager,
-                hallucinationDetector,
-                logger: ctx.logger,
-                baseDir: ctx.baseDir,
-                scope,
-                toolTags,
-                promptBlocks: [systemPrompt],
-                recursionDepth: currentDepth + 1, // Increment recursion depth for sub-agent
-            };
-            const subAgent = new Agent(subDeps);
-            const fullTask = context ? `${task}\n\nContext: ${context}` : task;
-            let scopeRestored = false;
-            try {
-                const result = await subAgent.run(fullTask);
-                if (!result.success) {
-                    return {
-                        success: false,
-                        output: `Sub-agent failed: ${result.error}\nPartial output: ${result.text}`,
-                    };
-                }
-                const resultMode = args.result_mode || ctx.config.subagent?.resultMode || "text";
-                if (resultMode === "file") {
-                    const store = new ArtifactStore({
-                        baseDir: ctx.baseDir,
-                        sessionId: ctx.sessionId || "default",
-                        artifactsDir: ctx.config.subagent?.artifactsDir,
-                    });
-                    const abs = store.save(args.artifact_name || `subagent-${Date.now()}`, result.text, "md");
-                    const summary = store.summary(result.text, ctx.config.subagent?.maxSummaryChars ?? 2000);
-                    ctx.logger.debug(`subagent result persisted to artifact ${abs} (${result.text.length} chars, ${result.iterationCount} iterations)`);
-                    return {
-                        success: true,
-                        output: t("tool.subagent_artifact", {
-                            path: abs,
-                            iterations: String(result.iterationCount),
-                            summary,
-                        }),
-                    };
-                }
-                return {
-                    success: true,
-                    output: `Sub-agent completed:\n${result.text}\n\nIterations: ${result.iterationCount}`,
-                };
-            }
-            finally {
-                if (!scopeRestored) {
-                    ctx.toolExecutor.setScope(parentScope || { allowed_files: [], read_only_files: [] });
-                }
-            }
-        }
-        catch (e) {
-            return { success: false, output: `Sub-agent error: ${e.message}` };
-        }
-    },
-};

package/dist/tools/types.js

@@ -1 +0,0 @@
-export {};

package/dist/tools/user-input.js

@@ -1,123 +0,0 @@
-import * as readline from "readline";
-import { t } from "../i18n/index";
-/** Index returned by askChoice when the user picks the "custom answer" entry. */
-export const CUSTOM_INDEX = -1;
-/**
- * Parse user input like "1" or "1,3" into 0-based option indexes.
- * Returns null on invalid input (empty, non-numeric, out of range,
- * duplicates, or multiple values when multiple is false).
- */
-export function parseSelection(input, optionCount, multiple) {
-    const trimmed = input.trim();
-    if (!trimmed)
-        return null;
-    const parts = trimmed.split(",").map((p) => p.trim());
-    if (!multiple && parts.length > 1)
-        return null;
-    const indexes = [];
-    for (const part of parts) {
-        if (!/^\d+$/.test(part))
-            return null;
-        const idx = Number(part) - 1;
-        if (idx < 0 || idx >= optionCount)
-            return null;
-        if (indexes.includes(idx))
-            return null;
-        indexes.push(idx);
-    }
-    return indexes.length ? indexes : null;
-}
-/** Render question + numbered option list as a single string. */
-export function formatMenu(question, options, opts = {}) {
-    const lines = [question];
-    options.forEach((opt, i) => {
-        lines.push(`  [${i + 1}] ${opt.label} — ${opt.description}`);
-    });
-    if (opts.allowCustom) {
-        lines.push(`  [${options.length + 1}] ${t("tool.user_input.custom_option")}`);
-    }
-    return lines.join("\n");
-}
-/** Prompt text for the choice input. */
-export function choicePrompt(optionCount, multiple) {
-    return multiple
-        ? t("tool.user_input.choice_multiple")
-        : t("tool.user_input.choice_single", { max: optionCount });
-}
-function createRl() {
-    return readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-}
-function promptLine(rl, prompt) {
-    return new Promise((resolve) => {
-        rl.question(prompt, (answer) => resolve(answer));
-    });
-}
-/** Free-text question. Returns trimmed answer (may be empty). */
-export async function askText(question) {
-    const rl = createRl();
-    try {
-        const answer = await promptLine(rl, `${question} `);
-        return answer.trim();
-    }
-    finally {
-        rl.close();
-    }
-}
-/**
- * Choice question: shows a numbered menu and waits for a valid selection.
- * Returns selected 0-based indexes; CUSTOM_INDEX marks the custom entry.
- * Re-asks until the input is valid.
- */
-export async function askChoice(question, options, opts = {}) {
-    const multiple = opts.multiple ?? false;
-    const entryCount = options.length + (opts.allowCustom ? 1 : 0);
-    const customEntry = options.length; // index of the custom entry, if enabled
-    const rl = createRl();
-    try {
-        console.log(formatMenu(question, options, opts));
-        for (;;) {
-            const answer = await promptLine(rl, choicePrompt(entryCount, multiple));
-            const parsed = parseSelection(answer, entryCount, multiple);
-            if (parsed) {
-                return parsed.map((i) => (opts.allowCustom && i === customEntry ? CUSTOM_INDEX : i));
-            }
-            console.log(t("tool.user_input.invalid"));
-        }
-    }
-    finally {
-        rl.close();
-    }
-}
-/**
- * High-level helper used by the question tool.
- * - No options: free-text input, returns [text] or [] when empty.
- * - With options: returns selected labels; custom entry resolves to typed text.
- */
-export async function askUser(question, opts = {}) {
-    const header = [opts.progress, opts.header].filter(Boolean).join(" — ");
-    const text = header ? `${header}\n${question}` : question;
-    if (!opts.options || opts.options.length === 0) {
-        const answer = await askText(text);
-        return answer ? [answer] : [];
-    }
-    const allowCustom = opts.custom ?? true;
-    const indexes = await askChoice(text, opts.options, {
-        multiple: opts.multiple,
-        allowCustom,
-    });
-    const labels = [];
-    for (const idx of indexes) {
-        if (idx === CUSTOM_INDEX) {
-            const custom = await askText(t("tool.user_input.custom_prompt"));
-            if (custom)
-                labels.push(custom);
-        }
-        else {
-            labels.push(opts.options[idx].label);
-        }
-    }
-    return labels;
-}

package/dist/tools/web-browse.js

@@ -1,86 +0,0 @@
-import { t } from "../i18n/index";
-import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
-import { logNetworkRequest, logSecurityBlock } from "../modules/security/audit-log";
-import { getSessionSecurityConfig } from "../modules/security/session-isolation";
-import { MAX_PREVIEW_LINES } from "./preview";
-const MAX_CHARS = 3000;
-export const webBrowseTool = {
-    name: "web_browse",
-    description: `Fetch and read a web page. Returns the page content as plain text (max ${MAX_PREVIEW_LINES} lines / ${MAX_CHARS} chars). This is a plain HTTP request — it does NOT execute JavaScript, so JS-rendered single-page apps (weather sites, dashboards, modern SPAs) return empty or near-empty content. For such pages use the "browser" tool instead.`,
-    tags: ["research"],
-    parameters: {
-        type: "object",
-        properties: {
-            url: { type: "string", description: "URL to fetch" },
-        },
-        required: ["url"],
-    },
-    handler: async (ctx, args) => {
-        const url = String(args.url || "");
-        // Get session-specific security config
-        const securityConfig = ctx.sessionContext
-            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
-            : ctx.config.security?.network;
-        const validation = isUrlAllowed(url, securityConfig);
-        if (!validation.allowed) {
-            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
-            return {
-                success: false,
-                output: `[SECURITY BLOCKED] URL is not allowed: ${validation.reason}`,
-            };
-        }
-        try {
-            const response = await fetch(url, {
-                signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
-            });
-            const text = await response.text();
-            const stripped = text
-                .replace(/<script[\s\S]*?<\/script>/gi, "")
-                .replace(/<style[\s\S]*?<\/style>/gi, "")
-                .replace(/<[^>]+>/g, "")
-                .replace(/&[^;]+;/g, " ")
-                .replace(/\s+/g, " ")
-                .trim();
-            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
-            const fullChars = stripped.length;
-            const fullLines = stripped.split("\n").length;
-            const maxChars = securityConfig?.maxResponseSize || MAX_CHARS;
-            let content;
-            if (stripped.length > maxChars) {
-                content = stripped.slice(0, maxChars) + t("file.truncated");
-            }
-            else {
-                content = stripped;
-            }
-            const contentLines = content.split("\n");
-            if (contentLines.length > MAX_PREVIEW_LINES) {
-                content =
-                    contentLines.slice(0, MAX_PREVIEW_LINES).join("\n") +
-                        `\n... (${contentLines.length - MAX_PREVIEW_LINES} more lines)`;
-            }
-            const truncated = stripped.length > maxChars || fullLines > MAX_PREVIEW_LINES
-                ? t("file.truncated").trim()
-                : "";
-            return {
-                success: true,
-                output: content || t("file.empty_page"),
-                display: t("tool.web_browse_result", {
-                    url: sanitizeUrl(url),
-                    chars: String(fullChars),
-                    lines: String(fullLines),
-                    truncated,
-                }),
-            };
-        }
-        catch (err) {
-            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
-            return {
-                success: false,
-                output: t("error.fetch_url_failed", {
-                    url: sanitizeUrl(url),
-                    message: err.message,
-                }),
-            };
-        }
-    },
-};