micro-models-agent 0.7.10 → 0.9.0

package/dist/tools/grep-tool.js

@@ -0,0 +1,57 @@
+import { execFileSync, execSync } from 'child_process';
+import { resolve } from 'path';
+import { t } from '../i18n/index';
+import { logBashCommand } from '../modules/security/audit-log';
+export const grepTool = {
+    name: 'grep',
+    description: 'Search file contents using a regular expression. 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: 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
+            try {
+                const cmd = `grep -rn "${pattern.replace(/"/g, '\\"')}" "${searchPath}"`;
+                const output = execSync(cmd, {
+                    encoding: 'utf-8',
+                    maxBuffer: 1024 * 1024,
+                    cwd: ctx.baseDir,
+                });
+                return { success: true, output: 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/index.js

@@ -0,0 +1,44 @@
+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 { subagentTool } from './subagent';
+import { webSearchTool } from './web-search';
+import { webFetchTool } from './web-fetch';
+import { webBrowseTool } from './web-browse';
+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 { createBrowserTool } from './browser';
+export { ToolRegistry, ToolExecutor };
+export { filterToolsByTags } from './filter-tools';
+export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, webSearchTool, webFetchTool, webBrowseTool, questionTool, approveTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, createBrowserTool, };
+export function registerAllTools(registry, skillsModule) {
+    const tools = [
+        readFileTool, writeFileTool, editFileTool,
+        globTool, grepTool, listDirTool, createDirTool,
+        deleteFileTool, moveFileTool, fileInfoTool,
+        bashTool, subagentTool,
+        webSearchTool, webFetchTool, webBrowseTool,
+        questionTool, approveTool,
+        pipelineRunTool, mcpCallTool, searchHistoryTool,
+    ];
+    if (skillsModule) {
+        tools.push(createLoadSkillTool(skillsModule));
+    }
+    for (const tool of tools) {
+        registry.register(tool);
+    }
+}

package/dist/tools/list-dir.js

@@ -0,0 +1,40 @@
+import { readdirSync, statSync, existsSync } from 'fs';
+import { resolve, normalize } from 'path';
+import { t } from '../i18n/index';
+import { isPathInScope } from '../modules/security/path-validator';
+export const listDirTool = {
+    name: 'list_dir',
+    description: 'List files and directories in a given path.',
+    tags: ['file'],
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Directory path' },
+        },
+        required: ['path'],
+    },
+    handler: async (ctx, args) => {
+        const path = String(args.path);
+        const baseDir = resolve(ctx.baseDir);
+        const resolved = resolve(baseDir, normalize(path));
+        // Check path permissions
+        const scopeCheck = isPathInScope(ctx.baseDir, path, 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;
+        });
+        return { success: true, output: lines.join('\n') || t('file.empty') };
+    },
+};

package/dist/tools/load-skill.js

@@ -0,0 +1,48 @@
+import { t } from "../i18n/index";
+export function createLoadSkillTool(skillsModule) {
+    return {
+        name: "load_skill",
+        tags: ["core"],
+        description: "Load a skill by name or task description. Skills provide specialized instructions and workflows. Only use when the task clearly requires domain-specific knowledge. If loading fails because the skill is too large, continue the task without it.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Skill name to load directly" },
+                task: {
+                    type: "string",
+                    description: "Task description to find matching skill",
+                },
+            },
+        },
+        handler: async (_ctx, args) => {
+            const name = args.name ? String(args.name) : undefined;
+            const task = args.task ? String(args.task) : undefined;
+            if (!name && !task) {
+                return { success: false, output: t("tool.name_or_task") };
+            }
+            let result;
+            if (name) {
+                result = skillsModule.loadByName(name);
+            }
+            else if (task) {
+                result = skillsModule.loadByMatch(task);
+            }
+            else {
+                return { success: false, output: t("tool.invalid_params") };
+            }
+            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 skill = result.skill;
+            const budget = skillsModule.getBudget();
+            return {
+                success: true,
+                output: `${result.message}\n\n--- Skill Content ---\n${skill.content}\n\n${t("tool.skill_budget", { remaining: budget.remaining })}`,
+            };
+        },
+    };
+}

package/dist/tools/mcp-call.js

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

@@ -0,0 +1,84 @@
+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";
+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 = resolve(baseDir, normalize(fromPath));
+        const toResolved = resolve(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/pipeline-run.js

@@ -0,0 +1,144 @@
+import { t } from '../i18n/index';
+import { PipelineEngine } from '../modules/pipelines/engine';
+import { PipelineParser } from '../modules/pipelines/parser';
+import { TemplateEngine } from '../modules/pipelines/template';
+import { Agent } from '../core/agent';
+import { ContextManager } from '../modules/context/manager';
+import { PluginManager } from '../modules/plugins/manager';
+import { HallucinationDetector } from '../modules/hallucination/detector';
+import { logSecurityBlock } from '../modules/security/audit-log';
+import { getSessionSecurityConfig } from '../modules/security/session-isolation';
+const engine = new PipelineEngine();
+const MAX_CONCURRENT = 3;
+const MAX_ATTEMPTS = 3;
+async function runStep(ctx, step, params, outputs) {
+    const prompt = TemplateEngine.render(step.prompt, params, outputs);
+    let lastError = "";
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+            const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
+            const subPluginManager = new PluginManager();
+            const systemPrompt = {
+                content: `You are a pipeline step agent ("${step.agent}"). Complete the given task using the available tools.`,
+                priority: "critical",
+                essential: true,
+                estimatedTokens: 80,
+            };
+            const subDeps = {
+                config: ctx.config,
+                llmProvider: ctx.llmProvider,
+                toolExecutor: ctx.toolExecutor,
+                pluginManager: subPluginManager,
+                contextManager: subContextManager,
+                hallucinationDetector: new HallucinationDetector(),
+                logger: ctx.logger,
+                baseDir: ctx.baseDir,
+                scope: ctx.scope,
+                recursionDepth: (ctx.recursionDepth ?? 0) + 1,
+                promptBlocks: [systemPrompt],
+            };
+            const subAgent = new Agent(subDeps);
+            const result = await subAgent.run(prompt);
+            if (result.success) {
+                return { ok: true, output: result.text };
+            }
+            lastError = result.error || "no output";
+        }
+        catch (e) {
+            lastError = e.message;
+        }
+        await new Promise((r) => setTimeout(r, 500 * attempt));
+    }
+    return { ok: false, output: "", error: lastError };
+}
+export const pipelineRunTool = {
+    name: 'pipeline_run',
+    description: 'Run a named pipeline with YAML definition. Creates a DAG of sub-agents that execute in dependency order.',
+    tags: ['shell', 'code'],
+    parameters: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Pipeline name' },
+            yaml: { type: 'string', description: 'Pipeline YAML definition with steps' },
+            params: { type: 'object', description: 'Template params for {key} placeholders' },
+        },
+        required: ['name', 'yaml'],
+    },
+    handler: async (ctx, args) => {
+        const name = String(args.name || '');
+        const yaml = String(args.yaml || '');
+        const params = args.params || {};
+        if (!yaml) {
+            return { success: false, output: t('pipeline.invalid') };
+        }
+        if (!ctx.llmProvider || !ctx.toolExecutor) {
+            return {
+                success: false,
+                output: 'Pipeline cannot run: missing llmProvider or toolExecutor in context',
+            };
+        }
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        const maxDepth = securityConfig?.maxRecursionDepth ?? 3;
+        const currentDepth = ctx.recursionDepth ?? 0;
+        if (currentDepth >= maxDepth) {
+            logSecurityBlock(ctx.sessionId, "bash_command", `Maximum recursion depth (${maxDepth}) exceeded`, name);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum pipeline recursion depth (${maxDepth}) exceeded`,
+            };
+        }
+        try {
+            const pipeline = PipelineParser.parse(yaml);
+            engine.reset();
+            const order = engine.resolveDependencies(pipeline.steps);
+            const completed = new Set();
+            const outputs = {};
+            const logs = [];
+            const failed = new Set();
+            while (completed.size < pipeline.steps.length) {
+                const ready = engine
+                    .getReadySteps(pipeline.steps, completed)
+                    .filter((s) => !failed.has(s.id));
+                if (ready.length === 0) {
+                    if (failed.size > 0)
+                        break;
+                    throw new Error(t('pipeline.circular', { stepId: order.join(', ') }));
+                }
+                const batch = ready.slice(0, MAX_CONCURRENT);
+                const results = await Promise.all(batch.map((step) => runStep(ctx, step, params, outputs)));
+                for (let i = 0; i < batch.length; i++) {
+                    const step = batch[i];
+                    const result = results[i];
+                    if (result.ok) {
+                        completed.add(step.id);
+                        outputs[step.id] = { output: result.output };
+                        engine.setStepStatus(step.id, 'done');
+                        logs.push(`  ✓ ${step.id}: ${result.output.split("\n")[0]}`);
+                    }
+                    else {
+                        failed.add(step.id);
+                        engine.setStepStatus(step.id, 'failed');
+                        logs.push(`  ✗ ${step.id}: ${result.error}`);
+                    }
+                }
+                if (failed.size > 0)
+                    break;
+            }
+            if (failed.size > 0) {
+                return {
+                    success: false,
+                    output: `Pipeline "${pipeline.name}" failed. Executed ${completed.size}/${pipeline.steps.length} steps.\n${logs.join("\n")}`,
+                };
+            }
+            return {
+                success: true,
+                output: `Pipeline "${pipeline.name}" completed successfully (${completed.size} steps).\n${logs.join("\n")}`,
+            };
+        }
+        catch (e) {
+            return { success: false, output: `Pipeline error: ${e.message}` };
+        }
+    },
+};

package/dist/tools/question.js

@@ -0,0 +1,142 @@
+import { t } from "../i18n/index";
+import { askUser } from "./user-input";
+const DESCRIPTION = `Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+- When "custom" is enabled (default), a "Type your own answer" option is added automatically; don't include "Other" or catch-all options
+- Answers are returned as arrays of labels; set "multiple": true to allow selecting more than one
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label
+- Execution blocks until the user answers every question
+- Omit "options" for a free-text question`;
+function isOption(val) {
+    if (!val || typeof val !== "object")
+        return false;
+    const opt = val;
+    return typeof opt.label === "string" && typeof opt.description === "string";
+}
+function normalizeQuestions(args) {
+    const raw = args.questions;
+    if (Array.isArray(raw)) {
+        const specs = [];
+        for (const item of raw) {
+            if (!item || typeof item !== "object")
+                continue;
+            const q = item;
+            if (typeof q.question !== "string" || !q.question.trim())
+                continue;
+            const options = Array.isArray(q.options)
+                ? q.options.filter(isOption)
+                : undefined;
+            // An explicitly provided options array with no valid entries is a
+            // malformed call — skip the question instead of blocking on stdin.
+            if (Array.isArray(q.options) && options.length === 0)
+                continue;
+            specs.push({
+                question: q.question,
+                header: typeof q.header === "string" ? q.header : undefined,
+                options,
+                multiple: q.multiple === true,
+                custom: q.custom === false ? false : undefined,
+            });
+        }
+        return specs;
+    }
+    // Legacy format: { question: "..." } — plain free-text question.
+    if (typeof args.question === "string" && args.question.trim()) {
+        return [{ question: args.question }];
+    }
+    return [];
+}
+export const questionTool = {
+    name: "question",
+    description: DESCRIPTION,
+    tags: ["core"],
+    interactive: true,
+    parameters: {
+        type: "object",
+        properties: {
+            questions: {
+                type: "array",
+                description: "Questions to ask",
+                items: {
+                    type: "object",
+                    properties: {
+                        question: { type: "string", description: "Complete question" },
+                        header: {
+                            type: "string",
+                            description: "Very short label (max 30 chars)",
+                        },
+                        options: {
+                            type: "array",
+                            description: "Available choices; omit for a free-text question",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    label: {
+                                        type: "string",
+                                        description: "Display text (1-5 words, concise)",
+                                    },
+                                    description: {
+                                        type: "string",
+                                        description: "Explanation of choice",
+                                    },
+                                },
+                                required: ["label", "description"],
+                            },
+                        },
+                        multiple: {
+                            type: "boolean",
+                            description: "Allow selecting multiple choices",
+                        },
+                        custom: {
+                            type: "boolean",
+                            description: "Allow typing a custom answer (default: true)",
+                        },
+                    },
+                    required: ["question"],
+                },
+            },
+            question: {
+                type: "string",
+                description: "Legacy single free-text question",
+            },
+        },
+    },
+    handler: async (ctx, args) => {
+        if (ctx.exitOnComplete) {
+            return { success: false, output: t("tool.interactive_disabled") };
+        }
+        const questions = normalizeQuestions(args);
+        if (questions.length === 0) {
+            return { success: false, output: t("tool.question.no_questions") };
+        }
+        const answers = [];
+        for (let i = 0; i < questions.length; i++) {
+            const q = questions[i];
+            const progress = questions.length > 1
+                ? t("tool.question.progress", {
+                    current: i + 1,
+                    total: questions.length,
+                })
+                : undefined;
+            answers.push(await askUser(q.question, {
+                header: q.header,
+                options: q.options,
+                multiple: q.multiple,
+                custom: q.custom,
+                progress,
+            }));
+        }
+        const formatted = questions
+            .map((q, i) => `"${q.question}"="${answers[i].length ? answers[i].join(", ") : t("tool.question.unanswered")}"`)
+            .join(", ");
+        return {
+            success: true,
+            output: t("tool.question.answered", { formatted }),
+        };
+    },
+};