micro-models-agent 0.46.1 → 0.46.3

package/dist/tools/filter-tools.js

@@ -1,17 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-import { globSync } from "fs";
-import { t } from "../i18n/index";
-import { MAX_PREVIEW_LINES } from "./preview";
-export const globTool = {
-    name: "glob",
-    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

@@ -1,84 +0,0 @@
-import { execFileSync } 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)`);
-}
-export const grepTool = {
-    name: "grep",
-    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 = execFileSync("rg", rgArgs, {
-                encoding: "utf-8",
-                maxBuffer: 1024 * 1024,
-                cwd: ctx.baseDir,
-            });
-            return {
-                success: true,
-                output: truncateLines(output || t("file.no_matches")),
-            };
-        }
-        catch (e) {
-            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 execFileSync with array args avoids shell injection.
-            try {
-                const grepArgs = ["-rn", pattern, searchPath];
-                if (args.include) {
-                    grepArgs.push("--include", String(args.include));
-                }
-                const output = execFileSync("grep", grepArgs, {
-                    encoding: "utf-8",
-                    maxBuffer: 1024 * 1024,
-                    cwd: 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

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

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

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

@@ -1,42 +0,0 @@
-import { t } from "../i18n/index";
-export function createLoadSkillTool(skillsModule) {
-    return {
-        name: "load_skill",
-        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

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

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

package/dist/tools/path-utils.js

@@ -1,51 +0,0 @@
-import { resolve, normalize, dirname, basename, sep } from "path";
-import { existsSync } from "fs";
-/**
- * Resolve a user-provided path against baseDir.
- *
- * Handles common model mistakes:
- * 1. Leading slash: "/testing/cat3" → resolve relative to baseDir
- * 2. Missing separator: "E:\agent_test" when baseDir is "E:\agent\_test"
- *    → inserts the missing backslash
- *
- * For new files the parent directory must exist; we check that instead of
- * the full path so write_file still works.
- */
-export function safeResolvePath(baseDir, userPath) {
-    const norm = normalize(userPath);
-    const stripped = norm.replace(/^[/\\]/, "");
-    const resolved = resolve(baseDir, stripped);
-    // Fast path: if it exists (or parent does for new files), return it
-    if (existsSync(resolved) || existsSync(dirname(resolved)))
-        return resolved;
-    const baseNorm = normalize(baseDir);
-    // Walk ancestors and look for missing separators
-    let cur = baseNorm;
-    while (cur && cur !== dirname(cur)) {
-        const name = basename(cur);
-        if (!name) {
-            cur = dirname(cur);
-            continue;
-        }
-        let idx = stripped.toLowerCase().indexOf(name.toLowerCase());
-        while (idx >= 0) {
-            const afterIdx = idx + name.length;
-            const afterChar = stripped[afterIdx];
-            if (afterChar && afterChar !== "\\" && afterChar !== "/") {
-                const fixed = stripped.slice(0, afterIdx) + sep + stripped.slice(afterIdx);
-                const fixedResolved = resolve(baseDir, normalize(fixed));
-                if (existsSync(fixedResolved) || existsSync(dirname(fixedResolved))) {
-                    return fixedResolved;
-                }
-                // Try from ancestor's parent
-                const fromParent = resolve(dirname(cur), normalize(fixed));
-                if (existsSync(fromParent) || existsSync(dirname(fromParent))) {
-                    return fromParent;
-                }
-            }
-            idx = stripped.toLowerCase().indexOf(name.toLowerCase(), idx + 1);
-        }
-        cur = dirname(cur);
-    }
-    return resolved;
-}