micro-models-agent 0.47.0 → 0.48.1

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(ctx.baseDir, ctx.llmProvider),
+                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/preview.js

@@ -0,0 +1,2 @@
+/** Maximum number of lines shown in tool output previews. */
+export const MAX_PREVIEW_LINES = 15;

package/dist/tools/process-kill.js

@@ -0,0 +1,29 @@
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
+export const processKillTool = {
+    name: "process_kill",
+    description: "Stop a background process started via bash (dev server, watcher). Kills the whole process tree (children included). Use the id returned by bash or process_list.",
+    tags: ["shell"],
+    parameters: {
+        type: "object",
+        properties: {
+            id: { type: "string", description: "Process id from bash output or process_list" },
+        },
+        required: ["id"],
+    },
+    handler: async (ctx, args) => {
+        const id = String(args.id);
+        const entry = processRegistry.get(id);
+        if (!entry) {
+            return { success: false, output: t("proc.not_found", { id }) };
+        }
+        const killed = processRegistry.kill(id);
+        if (!killed) {
+            return { success: false, output: t("proc.kill_failed", { id }) };
+        }
+        return {
+            success: true,
+            output: t("proc.killed", { id, pid: entry.pid }),
+        };
+    },
+};

package/dist/tools/process-list.js

@@ -0,0 +1,36 @@
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
+export const processListTool = {
+    name: "process_list",
+    description: "List background processes started via the bash tool (dev servers, watchers, long-running commands). Shows id, pid, command, status, and recent output. Use with process_log and process_kill to inspect or stop them.",
+    tags: ["shell"],
+    parameters: {
+        type: "object",
+        properties: {},
+    },
+    handler: async (ctx) => {
+        const list = processRegistry.list(ctx.sessionId);
+        if (list.length === 0) {
+            return { success: true, output: t("proc.none") };
+        }
+        const statusLabel = (status) => {
+            if (status === "running")
+                return t("proc.status_running");
+            if (status === "exited")
+                return t("proc.status_exited");
+            return t("proc.status_killed");
+        };
+        const lines = [`${t("proc.list_header")} (${list.length}):`];
+        for (const entry of list) {
+            const tail = entry.log.length > 0 ? entry.log[entry.log.length - 1] : "";
+            const detail = tail ? ` — ${tail.slice(0, 80)}${tail.length > 80 ? "…" : ""}` : "";
+            lines.push(`  ${entry.id}  PID ${entry.pid}  ${statusLabel(entry.status)}  ${entry.command}${detail}`);
+        }
+        lines.push(`\n${t("proc.hint", {
+            list: "process_list",
+            log: "process_log",
+            kill: "process_kill",
+        })}`);
+        return { success: true, output: lines.join("\n") };
+    },
+};

package/dist/tools/process-log.js

@@ -0,0 +1,45 @@
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
+import { MAX_PREVIEW_LINES } from "./preview";
+const DEFAULT_TAIL = MAX_PREVIEW_LINES;
+export const processLogTool = {
+    name: "process_log",
+    description: `Show the buffered output of a background process started via bash. Shows the last ${DEFAULT_TAIL} lines by default. Use after starting a dev server to verify it came up without errors, and while it runs to check its state.`,
+    tags: ["shell"],
+    boundedOutput: true,
+    parameters: {
+        type: "object",
+        properties: {
+            id: { type: "string", description: "Process id from bash output or process_list" },
+            tail: {
+                type: "number",
+                description: `Number of trailing lines to show (default: ${DEFAULT_TAIL}, max 300)`,
+            },
+        },
+        required: ["id"],
+    },
+    handler: async (ctx, args) => {
+        const id = String(args.id);
+        const entry = processRegistry.get(id);
+        if (!entry) {
+            return { success: false, output: t("proc.not_found", { id }) };
+        }
+        const status = entry.status === "running"
+            ? t("proc.status_running")
+            : entry.status === "exited"
+                ? t("proc.status_exited")
+                : t("proc.status_killed");
+        const tail = typeof args.tail === "number" ? args.tail : DEFAULT_TAIL;
+        const log = processRegistry.getLog(id, tail);
+        if (!log) {
+            return {
+                success: true,
+                output: `${t("proc.log_header", { id, status })} ${t("proc.log_empty")}`,
+            };
+        }
+        return {
+            success: true,
+            output: `${t("proc.log_header", { id, status })}\n${log}`,
+        };
+    },
+};

package/dist/tools/question.js

@@ -0,0 +1,140 @@
+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,91 @@
+import { readFileSync, existsSync } from "fs";
+import { extname } from "path";
+import { t } from "../i18n/index";
+import { isPathInScope } from "../modules/security/path-validator";
+import { DEFAULT_SECURITY_CONFIG } from "../config/security";
+import { logSecurityBlock } from "../modules/security/audit-log";
+import { safeResolvePath } from "./path-utils";
+/**
+ * Default lines per read_file call. Deliberately much larger than
+ * MAX_PREVIEW_LINES (15): a 15-line default forces the model to issue 10-17
+ * calls per file, which floods the context and drives compaction every 15
+ * iterations (observed: 96 read_file calls, App.tsx read 23x, then 11
+ * compactions in ~20 min that deleted the user's task mid-turn). 300 lines
+ * covers typical component files in one call while still capping output.
+ */
+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"],
+    boundedOutput: true,
+    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 resolved = safeResolvePath(ctx.baseDir, path);
+        const securityPaths = ctx.config?.security?.paths || DEFAULT_SECURITY_CONFIG.paths;
+        const scopeCheck = isPathInScope(ctx.baseDir, resolved, ctx.scope, securityPaths);
+        if (!scopeCheck.allowed) {
+            const pathStr = path;
+            logSecurityBlock(ctx.sessionId || undefined, "file_read", scopeCheck.reason || "Path not allowed", pathStr);
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        if (!existsSync(resolved)) {
+            // For relative paths, tell the model WHERE the path resolved — the
+            // "not found" alone is confusing (it cannot tell baseDir from cwd).
+            const output = resolved !== path
+                ? t("file.notfound_resolved", {
+                    path,
+                    resolved,
+                })
+                : t("file.notfound", { path });
+            return { success: false, output };
+        }
+        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),
+            })
+            : "";
+        const display = truncated ? `${header}${truncated}` : header;
+        return {
+            success: true,
+            output: `${header}\n${selected}${truncated}`,
+            display,
+        };
+    },
+};

package/dist/tools/recall.js

@@ -0,0 +1,117 @@
+import { homedir } from "os";
+import { join } from "path";
+import { t } from "../i18n/index";
+import { MemoryStore } from "../modules/memory/store";
+const CATEGORIES = ["preferences", "conventions", "decisions", "errors", "facts"];
+export const recallTool = {
+    name: "recall",
+    description: "Recall stored information from memory. Search across preferences, facts, conventions, decisions, errors.",
+    tags: ["memory"],
+    parameters: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Search query (full-text search across all memory)",
+            },
+            category: {
+                type: "string",
+                description: "Limit to specific category: preferences, conventions, decisions, errors, facts",
+                enum: CATEGORIES,
+            },
+        },
+    },
+    handler: async (_ctx, args) => {
+        const query = args.query ? String(args.query) : "";
+        const category = args.category ? String(args.category) : "";
+        const memoryDir = join(homedir(), ".mma", "memory");
+        const store = new MemoryStore(memoryDir);
+        try {
+            // No query, no category → show everything
+            if (!query && !category) {
+                return { success: true, output: formatAll(store) };
+            }
+            // Category only → show that category
+            if (!query && category) {
+                return { success: true, output: formatCategory(store, category) };
+            }
+            // Query with optional category → search
+            if (category) {
+                const results = searchCategory(store, category, query);
+                if (results.length === 0) {
+                    return { success: true, output: t("tool.recall.empty", { query }) };
+                }
+                return {
+                    success: true,
+                    output: t("tool.recall.search_results", { category, results: results.join("\n") }),
+                };
+            }
+            // Query across all
+            const results = store.search(query);
+            if (results.length === 0) {
+                return { success: true, output: t("tool.recall.empty", { query }) };
+            }
+            const formatted = results.map((r) => `[${r.file}] ${r.match}`).join("\n");
+            return {
+                success: true,
+                output: t("tool.recall.search_results", { category: "all", results: formatted }),
+            };
+        }
+        catch (err) {
+            return { success: true, output: t("tool.memory_error", { error: String(err) }) };
+        }
+    },
+};
+function formatAll(store) {
+    const parts = [];
+    const prefs = store.getPreferences();
+    if (Object.keys(prefs).length > 0) {
+        parts.push("Preferences:");
+        for (const [k, v] of Object.entries(prefs)) {
+            parts.push(`  ${k} = ${v}`);
+        }
+    }
+    for (const cat of ["facts", "conventions", "decisions", "errors"]) {
+        const content = store.read(cat);
+        const entries = content.split("\n").filter((l) => l.startsWith("- "));
+        if (entries.length > 0) {
+            parts.push(`\n${cat.charAt(0).toUpperCase() + cat.slice(1)} (last 5):`);
+            for (const e of entries.slice(-5)) {
+                parts.push(`  ${e}`);
+            }
+        }
+    }
+    return parts.length > 0 ? parts.join("\n") : t("tool.recall.no_memory");
+}
+function formatCategory(store, category) {
+    if (category === "preferences") {
+        const prefs = store.getPreferences();
+        if (Object.keys(prefs).length === 0)
+            return t("tool.recall.no_memory");
+        const lines = ["Preferences:"];
+        for (const [k, v] of Object.entries(prefs)) {
+            lines.push(`  ${k} = ${v}`);
+        }
+        return lines.join("\n");
+    }
+    const content = store.read(category);
+    const entries = content.split("\n").filter((l) => l.startsWith("- "));
+    if (entries.length === 0)
+        return t("tool.recall.no_memory");
+    return `${category.charAt(0).toUpperCase() + category.slice(1)} (${entries.length} entries):\n${entries.join("\n")}`;
+}
+function searchCategory(store, category, query) {
+    if (category === "preferences") {
+        const prefs = store.getPreferences();
+        const lower = query.toLowerCase();
+        return Object.entries(prefs)
+            .filter(([k, v]) => k.toLowerCase().includes(lower) || v.toLowerCase().includes(lower))
+            .map(([k, v]) => `  ${k} = ${v}`);
+    }
+    const content = store.read(category);
+    const lower = query.toLowerCase();
+    return content
+        .split("\n")
+        .filter((l) => l.startsWith("- ") && l.toLowerCase().includes(lower))
+        .map((l) => `  ${l}`);
+}

package/dist/tools/registry.js

@@ -0,0 +1,47 @@
+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));
+        });
+    }
+    /**
+     * Tools to expose to the LLM. Always includes `alwaysOn` tools, then tools
+     * matching the given tags. When no tags are given, returns every registered
+     * tool (backward-compatible). Duplicates are impossible because the
+     * alwaysOn + tagged sets are unioned by name.
+     */
+    getAllForLLM(tags) {
+        const all = this.getAll();
+        const tagSet = new Set(tags ?? []);
+        const selected = tagSet.size === 0
+            ? all
+            : all.filter((t) => t.alwaysOn || (t.tags && t.tags.some((tag) => tagSet.has(tag))));
+        return selected.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+            boundedOutput: t.boundedOutput,
+        }));
+    }
+}