micro-models-agent 0.57.0 → 0.57.2

package/dist/tools/file-info.js

@@ -0,0 +1,47 @@
+import { statSync, existsSync } from "fs";
+import { t } from "../i18n/index";
+import { isPathInScope } from "../modules/security/path-validator";
+import { safeResolvePath } from "./path-utils";
+export const fileInfoTool = {
+    name: "file_info",
+    icon: "ℹ️",
+    description: "Get metadata about a file or directory (size, creation date, modification date).",
+    tags: ["file"],
+    boundedOutput: true,
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path" },
+        },
+        required: ["path"],
+    },
+    handler: async (ctx, args) => {
+        const path = String(args.path);
+        const resolved = safeResolvePath(ctx.baseDir, path);
+        // Check path permissions
+        const scopeCheck = isPathInScope(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
+        if (!scopeCheck.allowed) {
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        if (!existsSync(resolved)) {
+            return { success: false, output: t("file.not_found_short", { path }) };
+        }
+        const stat = statSync(resolved);
+        return {
+            success: true,
+            output: JSON.stringify({
+                path,
+                size: stat.size,
+                isDirectory: stat.isDirectory(),
+                isFile: stat.isFile(),
+                created: stat.birthtime,
+                modified: stat.mtime,
+            }, null, 2),
+        };
+    },
+};

package/dist/tools/filter-tools.js

@@ -0,0 +1,17 @@
+/**
+ * Filter tools by a tag set, always keeping `alwaysOn` tools. Used by MoE
+ * expert routing and subagent tool_tags so structural tools (plan/todo/verify,
+ * project_map, lsp_check, enable_tools) survive narrowing.
+ */
+export function filterToolsByTags(tools, toolTags) {
+    if (!toolTags || toolTags.length === 0)
+        return tools;
+    const tagSet = new Set(toolTags);
+    return tools.filter((t) => {
+        if (t.alwaysOn)
+            return true;
+        if (!t.tags || t.tags.length === 0)
+            return false;
+        return t.tags.some((tag) => tagSet.has(tag));
+    });
+}

package/dist/tools/glob-tool.js

@@ -0,0 +1,27 @@
+import { globSync } from "fs";
+import { t } from "../i18n/index";
+import { MAX_PREVIEW_LINES } from "./preview";
+export const globTool = {
+    name: "glob",
+    icon: "🔎",
+    description: `Search for files matching a glob pattern. Shows up to ${MAX_PREVIEW_LINES} results by default. Uses standard glob syntax (e.g., **/*.ts, src/**/*.test.ts).`,
+    tags: ["file", "code", "research"],
+    parameters: {
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "Glob pattern" },
+        },
+        required: ["pattern"],
+    },
+    handler: async (ctx, args) => {
+        const pattern = String(args.pattern);
+        const results = globSync(pattern, { cwd: ctx.baseDir });
+        if (results.length === 0) {
+            return { success: true, output: t("file.no_matches") };
+        }
+        const truncated = results.length > MAX_PREVIEW_LINES
+            ? `\n... (${results.length - MAX_PREVIEW_LINES} more files)`
+            : "";
+        return { success: true, output: results.slice(0, MAX_PREVIEW_LINES).join("\n") + truncated };
+    },
+};

package/dist/tools/grep-tool.js

@@ -0,0 +1,125 @@
+import { spawn } from "child_process";
+import { resolve } from "path";
+import { t } from "../i18n/index";
+import { logBashCommand } from "../modules/security/audit-log";
+import { MAX_PREVIEW_LINES } from "./preview";
+function truncateLines(output) {
+    const lines = output.split("\n");
+    if (lines.length <= MAX_PREVIEW_LINES)
+        return output;
+    return (lines.slice(0, MAX_PREVIEW_LINES).join("\n") +
+        `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`);
+}
+/**
+ * Run a search command asynchronously with kill-on-timeout.
+ * Exit code 1 (no matches) resolves to an empty string, like execFileSync semantics.
+ */
+export function runSearch(bin, args, cwd, timeoutMs = 30000) {
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn(bin, args, { cwd, windowsHide: true });
+        let out = "";
+        let err = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill();
+        }, timeoutMs);
+        child.stdout?.on("data", (d) => {
+            out += d;
+        });
+        child.stderr?.on("data", (d) => {
+            err += d;
+        });
+        child.on("error", (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (timedOut) {
+                reject(new Error(`search timed out after ${timeoutMs}ms`));
+            }
+            else if (code === 1) {
+                resolvePromise("");
+            }
+            else if (code === 0) {
+                resolvePromise(out);
+            }
+            else {
+                reject(new Error(err || `exit ${code}`));
+            }
+        });
+    });
+}
+export const grepTool = {
+    name: "grep",
+    icon: "🔍",
+    description: `Search file contents using a regular expression. Shows up to ${MAX_PREVIEW_LINES} matching lines by default. Uses ripgrep (rg) if available, otherwise falls back to grep -r.`,
+    tags: ["file", "code", "research"],
+    parameters: {
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "Regex pattern to search" },
+            include: {
+                type: "string",
+                description: "File pattern to filter (e.g. *.ts)",
+            },
+            path: {
+                type: "string",
+                description: "Directory to search (defaults to baseDir)",
+            },
+        },
+        required: ["pattern"],
+    },
+    handler: async (ctx, args) => {
+        const pattern = String(args.pattern);
+        const searchPath = args.path ? resolve(ctx.baseDir, String(args.path)) : ctx.baseDir;
+        // Build rg arguments as an array to avoid shell interpretation of regex
+        // metacharacters like |, (, ) — these are regex patterns, not shell operators.
+        const rgArgs = ["-n", "--with-filename", pattern, searchPath];
+        if (args.include) {
+            rgArgs.push("-g", String(args.include));
+        }
+        // Log the search (sanitized) for audit purposes
+        logBashCommand(ctx.sessionId, `rg ${rgArgs.join(" ")}`, false, "grep-tool");
+        try {
+            const output = await runSearch("rg", rgArgs, ctx.baseDir);
+            return {
+                success: true,
+                output: truncateLines(output || t("file.no_matches")),
+            };
+        }
+        catch (e) {
+            if (e.code === "ENOENT") {
+                // fall through to grep fallback
+            }
+            else if (/timed out/.test(e.message)) {
+                return { success: false, output: t("error.grep_failed", { message: e.message }) };
+            }
+            else if (e.status === 1) {
+                return { success: true, output: t("file.no_matches") };
+            }
+            // Fall back to plain grep -r when rg is not available or fails.
+            // Using array args avoids shell injection.
+            try {
+                const grepArgs = ["-rn", pattern, searchPath];
+                if (args.include) {
+                    grepArgs.push("--include", String(args.include));
+                }
+                const output = await runSearch("grep", grepArgs, ctx.baseDir);
+                return {
+                    success: true,
+                    output: truncateLines(output || t("file.no_matches")),
+                };
+            }
+            catch (e2) {
+                if (e2.status === 1)
+                    return { success: true, output: t("file.no_matches") };
+                return {
+                    success: false,
+                    output: t("error.grep_failed", { message: e2.message }),
+                };
+            }
+        }
+    },
+};

package/dist/tools/hidden-tools-block.js

@@ -0,0 +1,37 @@
+import { t } from "../i18n/index";
+/**
+ * Build a compact system-prompt block listing the tools hidden by the current
+ * tag filter. The model must know these tools exist (and how to reach them)
+ * even though they are absent from the LLM tool schema. Grouped by tag with
+ * short purposes; capped to keep the block small.
+ */
+export function buildHiddenToolsBlock(allTools, activeTags) {
+    if (!allTools.length)
+        return "";
+    const activeSet = new Set(activeTags);
+    const visible = new Set();
+    for (const tool of allTools) {
+        if (tool.alwaysOn || (tool.tags && tool.tags.some((tag) => activeSet.has(tag)))) {
+            visible.add(tool.name);
+        }
+    }
+    const hidden = allTools.filter((tool) => !visible.has(tool.name));
+    if (hidden.length === 0)
+        return "";
+    // Group by tag → tools, then by tool name alphabetically within a tag.
+    const byTag = new Map();
+    for (const tool of hidden) {
+        const tags = tool.tags && tool.tags.length > 0 ? tool.tags : ["other"];
+        for (const tag of tags) {
+            if (!byTag.has(tag))
+                byTag.set(tag, []);
+            byTag.get(tag).push(tool);
+        }
+    }
+    const lines = [t("tools.hidden_header")];
+    for (const [tag, tools] of [...byTag.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        const names = [...new Set(tools.map((tool) => tool.name))].sort().join(", ");
+        lines.push(`- [${tag}] ${names}`);
+    }
+    return lines.join("\n");
+}

package/dist/tools/index.js

@@ -0,0 +1,78 @@
+import { ToolRegistry } from "./registry";
+import { ToolExecutor } from "./executor";
+import { readFileTool } from "./read-file";
+import { writeFileTool } from "./write-file";
+import { editFileTool } from "./edit-file";
+import { globTool } from "./glob-tool";
+import { grepTool } from "./grep-tool";
+import { listDirTool } from "./list-dir";
+import { createDirTool } from "./create-dir";
+import { deleteFileTool } from "./delete-file";
+import { moveFileTool } from "./move-file";
+import { fileInfoTool } from "./file-info";
+import { bashTool } from "./bash";
+import { processListTool } from "./process-list";
+import { processLogTool } from "./process-log";
+import { processKillTool } from "./process-kill";
+import { subagentTool } from "./subagent";
+import { chunkQueryTool } from "./chunk-query";
+import { webSearchTool } from "./web-search";
+import { webFetchTool } from "./web-fetch";
+import { webBrowseTool } from "./web-browse";
+import { downloadFileTool } from "./download-file";
+// questionTool and approveTool removed — interactive menus are too disruptive for small models.
+// The model should ask questions as plain text in its response instead.
+// import { questionTool } from './question'
+// import { approveTool } from './approve'
+import { createLoadSkillTool } from "./load-skill";
+import { pipelineRunTool } from "./pipeline-run";
+import { mcpCallTool } from "./mcp-call";
+import { searchHistoryTool } from "./search-history";
+import { rememberTool } from "./remember";
+import { recallTool } from "./recall";
+import { createBrowserTool } from "./browser";
+import { attachImageTool } from "./attach-image";
+import { enableToolsTool } from "./enable-tools";
+export { ToolRegistry, ToolExecutor };
+export { filterToolsByTags } from "./filter-tools";
+export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, chunkQueryTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, downloadFileTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, rememberTool, recallTool, createBrowserTool, attachImageTool, enableToolsTool, };
+export function registerAllTools(registry, skillsModule, opts) {
+    const tools = [
+        readFileTool,
+        writeFileTool,
+        editFileTool,
+        globTool,
+        grepTool,
+        listDirTool,
+        createDirTool,
+        deleteFileTool,
+        moveFileTool,
+        fileInfoTool,
+        bashTool,
+        subagentTool,
+        chunkQueryTool,
+        processListTool,
+        processLogTool,
+        processKillTool,
+        webSearchTool,
+        webFetchTool,
+        webBrowseTool,
+        downloadFileTool,
+        pipelineRunTool,
+        mcpCallTool,
+        searchHistoryTool,
+        attachImageTool,
+    ];
+    // On-demand tool activation is the default. When explicitly disabled
+    // (enableOnDemand: false), the tool is not registered at all — combined
+    // with an empty defaultTags this restores the legacy all-tools behavior.
+    if (opts?.enableOnDemand !== false) {
+        tools.push(enableToolsTool);
+    }
+    if (skillsModule) {
+        tools.push(createLoadSkillTool(skillsModule));
+    }
+    for (const tool of tools) {
+        registry.register(tool);
+    }
+}

package/dist/tools/list-dir.js

@@ -0,0 +1,49 @@
+import { readdirSync, statSync, existsSync } from "fs";
+import { resolve } from "path";
+import { t } from "../i18n/index";
+import { isPathInScope } from "../modules/security/path-validator";
+import { safeResolvePath } from "./path-utils";
+import { MAX_PREVIEW_LINES } from "./preview";
+export const listDirTool = {
+    name: "list_dir",
+    icon: "📂",
+    description: `List files and directories in a given path. Shows up to ${MAX_PREVIEW_LINES} entries by default.`,
+    tags: ["file"],
+    boundedOutput: true,
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Directory path" },
+        },
+        required: ["path"],
+    },
+    handler: async (ctx, args) => {
+        const path = String(args.path);
+        const resolved = safeResolvePath(ctx.baseDir, path);
+        // Check path permissions
+        const scopeCheck = isPathInScope(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
+        if (!scopeCheck.allowed) {
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        if (!existsSync(resolved)) {
+            return { success: false, output: t("file.dir_notfound", { path }) };
+        }
+        const entries = readdirSync(resolved);
+        const lines = entries.map((e) => {
+            const full = resolve(resolved, e);
+            return statSync(full).isDirectory() ? `${e}/` : e;
+        });
+        if (lines.length === 0) {
+            return { success: true, output: t("file.empty") };
+        }
+        const truncated = lines.length > MAX_PREVIEW_LINES
+            ? `\n... (${lines.length - MAX_PREVIEW_LINES} more entries)`
+            : "";
+        return { success: true, output: lines.slice(0, MAX_PREVIEW_LINES).join("\n") + truncated };
+    },
+};

package/dist/tools/load-skill.js

@@ -0,0 +1,43 @@
+import { t } from "../i18n/index";
+export function createLoadSkillTool(skillsModule) {
+    return {
+        name: "load_skill",
+        icon: "🎯",
+        tags: ["core"],
+        description: "Load a skill by name. Skills provide specialized instructions and workflows. When loaded, the skill content is injected into the system prompt (not conversation history) so it persists through context compaction. Only use when the task clearly requires domain-specific knowledge.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Exact skill name to load (see [Available Skills] for names)",
+                },
+            },
+            required: ["name"],
+        },
+        handler: async (_ctx, args) => {
+            const name = args.name ? String(args.name) : undefined;
+            if (!name) {
+                return { success: false, output: t("tool.invalid_params") };
+            }
+            const result = skillsModule.loadByName(name);
+            if (!result.success) {
+                const available = skillsModule.getAvailable();
+                const hint = available.length > 0
+                    ? `\n\n${t("tool.skill_available_hint")}: ${available.map((s) => s.name).join(", ")}`
+                    : "";
+                return { success: false, output: result.message + hint };
+            }
+            const budget = skillsModule.getBudget();
+            const tokens = result.skill ? Math.ceil(result.skill.content.length / 4) : 0;
+            return {
+                success: true,
+                output: t("tool.skill_budget", {
+                    name,
+                    tokens,
+                    remaining: budget.remaining,
+                }),
+            };
+        },
+    };
+}

package/dist/tools/mcp-call.js

@@ -0,0 +1,69 @@
+import { MCPClient } from "../modules/mcp/client";
+import { MCPRegistry } from "../modules/mcp/registry";
+const registry = new MCPRegistry();
+let initialized = false;
+function ensureInitialized(ctx) {
+    if (initialized)
+        return;
+    initialized = true;
+    const servers = ctx.config.mcpServers || {};
+    for (const [name, cfg] of Object.entries(servers)) {
+        if (cfg.enabled !== false) {
+            registry.register({
+                name: cfg.name || name,
+                command: cfg.command,
+                args: cfg.args,
+                env: cfg.env,
+                transport: cfg.transport,
+                url: cfg.url,
+                headers: cfg.headers,
+                timeout: cfg.timeout,
+            });
+        }
+    }
+}
+export const mcpCallTool = {
+    name: "mcp_call",
+    icon: "🔗",
+    description: "Call a tool on an MCP (Model Context Protocol) server. MCP servers provide external capabilities like databases, APIs, or specialized tools.",
+    tags: ["code", "research"],
+    parameters: {
+        type: "object",
+        properties: {
+            server: { type: "string", description: "MCP server name" },
+            tool: { type: "string", description: "Tool name on the server" },
+            args: { type: "object", description: "Arguments to pass to the tool" },
+        },
+        required: ["server", "tool"],
+    },
+    handler: async (ctx, args) => {
+        const serverName = String(args.server || "");
+        const toolName = String(args.tool || "");
+        const toolArgs = (args.args || {});
+        if (!serverName || !toolName) {
+            return { success: false, output: "Server and tool names are required" };
+        }
+        ensureInitialized(ctx);
+        const serverConfig = registry.get(serverName);
+        if (!serverConfig) {
+            const available = registry.list();
+            return {
+                success: false,
+                output: `MCP server "${serverName}" not found. Available: ${available.join(", ") || "(none)"}`,
+            };
+        }
+        try {
+            const client = new MCPClient(serverConfig);
+            await client.connect();
+            const result = await client.callTool(toolName, toolArgs);
+            await client.disconnect();
+            return {
+                success: true,
+                output: `MCP call result:\n${JSON.stringify(result, null, 2)}`,
+            };
+        }
+        catch (e) {
+            return { success: false, output: `MCP call failed: ${e.message}` };
+        }
+    },
+};

package/dist/tools/move-file.js

@@ -0,0 +1,86 @@
+import { renameSync, existsSync, mkdirSync } from "fs";
+import { resolve, normalize, dirname } from "path";
+import { t } from "../i18n/index";
+import { isPathWritable } from "../modules/security/path-validator";
+import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+import { generateMoveDiff } from "../ui/diff";
+import { safeResolvePath } from "./path-utils";
+export const moveFileTool = {
+    name: "move_file",
+    icon: "📦",
+    description: "Move or rename a file or directory.",
+    tags: ["file"],
+    parameters: {
+        type: "object",
+        properties: {
+            from: { type: "string", description: "Source path" },
+            to: { type: "string", description: "Destination path" },
+        },
+        required: ["from", "to"],
+    },
+    handler: async (ctx, args) => {
+        const fromPath = String(args.from);
+        const toPath = String(args.to);
+        const baseDir = resolve(ctx.baseDir);
+        const fromResolved = safeResolvePath(baseDir, normalize(fromPath));
+        const toResolved = safeResolvePath(baseDir, normalize(toPath));
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        // Check file operations limit
+        const maxFileOps = securityConfig?.maxFileOperations ?? 100;
+        const currentCount = ctx.fileOperationsCount ?? 0;
+        if (currentCount >= maxFileOps) {
+            logSecurityBlock(ctx.sessionId, "file_write", `Maximum file operations (${maxFileOps}) exceeded`, `${fromPath} -> ${toPath}`);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
+            };
+        }
+        // Check source path permissions
+        const fromCheck = isPathWritable(ctx.baseDir, fromPath, ctx.scope, ctx.config.security?.paths);
+        if (!fromCheck.allowed) {
+            logSecurityBlock(ctx.sessionId, "file_write", fromCheck.reason || "Source path not allowed", fromPath);
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${fromPath} — ${fromCheck.reason}`,
+                }),
+            };
+        }
+        // Check destination path permissions
+        const toCheck = isPathWritable(ctx.baseDir, toPath, ctx.scope, ctx.config.security?.paths);
+        if (!toCheck.allowed) {
+            logSecurityBlock(ctx.sessionId, "file_write", toCheck.reason || "Destination path not allowed", toPath);
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${toPath} — ${toCheck.reason}`,
+                }),
+            };
+        }
+        if (!existsSync(fromResolved)) {
+            return {
+                success: false,
+                output: t("file.not_found_short", { path: fromPath }),
+            };
+        }
+        const toDir = dirname(toResolved);
+        if (!existsSync(toDir)) {
+            mkdirSync(toDir, { recursive: true });
+        }
+        renameSync(fromResolved, toResolved);
+        const diff = generateMoveDiff(fromPath, toPath);
+        // Increment file operations counter
+        ctx.fileOperationsCount = currentCount + 1;
+        // Log file move
+        logFileWrite(ctx.sessionId, `${fromPath} -> ${toPath}`, true, "File moved");
+        return {
+            success: true,
+            output: t("file.moved", { from: fromPath, to: toPath }),
+            diff,
+        };
+    },
+};