micro-models-agent 0.7.10 → 0.8.0

package/dist/tools/grep-tool.js

@@ -0,0 +1,51 @@
+import { execSync } from 'child_process';
+import { resolve } from 'path';
+import { t } from '../i18n/index';
+import { isCommandAllowed, sanitizeCommandForLog } from '../modules/security/command-validator';
+import { logSecurityBlock } 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 grep command
+        let cmd = `rg -n "${pattern.replace(/"/g, '\\"')}" "${searchPath}"`;
+        if (args.include) {
+            cmd += ` -g "${String(args.include)}"`;
+        }
+        // Security check: validate command (grep/rg should be allowed)
+        const securityConfig = ctx.config.security?.bash;
+        const validation = isCommandAllowed(cmd, securityConfig);
+        if (!validation.allowed) {
+            logSecurityBlock(ctx.sessionId, "bash_command", validation.reason || "Command blocked by security policy", sanitizeCommandForLog(cmd));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Command is not allowed: ${validation.reason}`,
+            };
+        }
+        try {
+            const output = execSync(cmd, {
+                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') };
+            return { success: false, output: t('error.grep_failed', { message: e.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,39 @@
+import { t } from '../i18n/index';
+import { PipelineEngine } from '../modules/pipelines/engine';
+import { PipelineParser } from '../modules/pipelines/parser';
+const engine = new PipelineEngine();
+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' },
+        },
+        required: ['name', 'yaml'],
+    },
+    handler: async (_ctx, args) => {
+        const name = String(args.name || '');
+        const yaml = String(args.yaml || '');
+        if (!yaml) {
+            return { success: false, output: t('pipeline.invalid') };
+        }
+        try {
+            const pipeline = PipelineParser.parse(yaml);
+            const order = engine.resolveDependencies(pipeline.steps);
+            const readySteps = engine.getReadySteps(pipeline.steps, new Set());
+            const summary = [
+                `Pipeline "${pipeline.name}" parsed successfully.`,
+                `Steps: ${pipeline.steps.length}`,
+                `Execution order: ${order.join(' → ')}`,
+                `Ready to run: ${readySteps.map(s => s.id).join(', ') || '(none)'}`,
+            ].join('\n');
+            return { success: true, output: summary };
+        }
+        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 }),
+        };
+    },
+};

package/dist/tools/read-file.js

@@ -0,0 +1,65 @@
+import { readFileSync, existsSync } from "fs";
+import { resolve, normalize, extname } from "path";
+import { t } from "../i18n/index";
+import { isPathInScope } from "../modules/security/path-validator";
+/** Default number of lines returned when the caller omits `limit`. */
+const DEFAULT_LIMIT = 300;
+export const readFileTool = {
+    name: "read_file",
+    description: `Read a file from the filesystem. Reads up to ${DEFAULT_LIMIT} lines at a time by default; use offset to page through large files.`,
+    tags: ["file", "code"],
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path to read" },
+            offset: {
+                type: "number",
+                description: `Starting line (1-indexed). Use offset=<next> from a truncated result to continue reading.`,
+            },
+            limit: {
+                type: "number",
+                description: `Number of lines to read (default ${DEFAULT_LIMIT})`,
+            },
+        },
+        required: ["path"],
+    },
+    handler: async (ctx, args) => {
+        const path = String(args.path);
+        const 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}`,
+                }),
+            };
+        }
+        const resolved = resolve(ctx.baseDir, normalize(path));
+        if (!existsSync(resolved)) {
+            return { success: false, output: t("file.notfound", { path }) };
+        }
+        ctx.trackReadPath?.(path);
+        const content = readFileSync(resolved, "utf-8");
+        const lines = content.split("\n");
+        const total = lines.length;
+        const offset = args.offset || 1;
+        const limit = args.limit || DEFAULT_LIMIT;
+        const end = Math.min(offset - 1 + limit, total);
+        const selected = lines.slice(offset - 1, end).join("\n");
+        const ext = extname(resolved) || "(no extension)";
+        const header = t("file.read_header", {
+            path,
+            ext,
+            total: String(total),
+            from: String(offset),
+            to: String(end),
+        });
+        const truncated = end < total
+            ? t("file.read_truncated", {
+                remaining: String(total - end),
+                next: String(end + 1),
+            })
+            : "";
+        return { success: true, output: `${header}\n${selected}${truncated}` };
+    },
+};

package/dist/tools/registry.js

@@ -0,0 +1,36 @@
+export class ToolRegistry {
+    tools = new Map();
+    register(tool) {
+        if (this.tools.has(tool.name)) {
+            throw new Error(`Tool already registered: ${tool.name}`);
+        }
+        this.tools.set(tool.name, tool);
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    has(name) {
+        return this.tools.has(name);
+    }
+    list() {
+        return Array.from(this.tools.keys()).sort();
+    }
+    getAll() {
+        return Array.from(this.tools.values());
+    }
+    getByTags(tags) {
+        return this.getAll().filter(t => {
+            if (!t.tags || t.tags.length === 0)
+                return false;
+            return tags.some(tag => t.tags.includes(tag));
+        });
+    }
+    getAllForLLM(tags) {
+        const tools = tags ? this.getByTags(tags) : this.getAll();
+        return tools.map(t => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        }));
+    }
+}

package/dist/tools/scope-check.js

@@ -0,0 +1,30 @@
+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' };
+}