micro-models-agent 0.28.0 → 0.28.1

package/dist/tools/pipeline-run.js

@@ -1,144 +0,0 @@
-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/preview.js

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

package/dist/tools/process-kill.js

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

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

@@ -1,41 +0,0 @@
-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'],
-    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

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

@@ -1,73 +0,0 @@
-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";
-import { MAX_PREVIEW_LINES } from "./preview";
-const DEFAULT_LIMIT = MAX_PREVIEW_LINES;
-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 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)) {
-            return { success: false, output: t("file.notfound", { path }) };
-        }
-        ctx.trackReadPath?.(path);
-        const content = readFileSync(resolved, "utf-8");
-        // Track file paths mentioned in the document (e.g. structure.md, README)
-        ctx.trackDocumentContent?.(content);
-        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/recall.js

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

@@ -1,36 +0,0 @@
-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,
-        }));
-    }
-}