micro-models-agent 0.41.2 → 0.42.0

package/dist/tools/list-dir.js

@@ -1,20 +1,19 @@
-import { readdirSync, statSync, existsSync } from "fs";
-import { resolve } from "path";
-import { t } from "../i18n/index";
-import { isPathInScope } from "../modules/security/path-validator";
-import { safeResolvePath } from "./path-utils";
-import { MAX_PREVIEW_LINES } from "./preview";
+import { readdirSync, statSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { t } from '../i18n/index';
+import { isPathInScope } from '../modules/security/path-validator';
+import { safeResolvePath } from './path-utils';
+import { MAX_PREVIEW_LINES } from './preview';
 export const listDirTool = {
-    name: "list_dir",
+    name: 'list_dir',
     description: `List files and directories in a given path. Shows up to ${MAX_PREVIEW_LINES} entries by default.`,
-    tags: ["file"],
-    boundedOutput: true,
+    tags: ['file'],
     parameters: {
-        type: "object",
+        type: 'object',
         properties: {
-            path: { type: "string", description: "Directory path" },
+            path: { type: 'string', description: 'Directory path' },
         },
-        required: ["path"],
+        required: ['path'],
     },
     handler: async (ctx, args) => {
         const path = String(args.path);
@@ -24,25 +23,25 @@ export const listDirTool = {
         if (!scopeCheck.allowed) {
             return {
                 success: false,
-                output: t("file.path_not_allowed", {
+                output: t('file.path_not_allowed', {
                     path: `${path} — ${scopeCheck.reason}`,
                 }),
             };
         }
         if (!existsSync(resolved)) {
-            return { success: false, output: t("file.dir_notfound", { path }) };
+            return { success: false, output: t('file.dir_notfound', { path }) };
         }
         const entries = readdirSync(resolved);
-        const lines = entries.map((e) => {
+        const lines = entries.map(e => {
             const full = resolve(resolved, e);
             return statSync(full).isDirectory() ? `${e}/` : e;
         });
         if (lines.length === 0) {
-            return { success: true, output: t("file.empty") };
+            return { success: true, output: t('file.empty') };
         }
         const truncated = lines.length > MAX_PREVIEW_LINES
             ? `\n... (${lines.length - MAX_PREVIEW_LINES} more entries)`
-            : "";
-        return { success: true, output: lines.slice(0, MAX_PREVIEW_LINES).join("\n") + truncated };
+            : '';
+        return { success: true, output: lines.slice(0, MAX_PREVIEW_LINES).join('\n') + truncated };
     },
 };

package/dist/tools/load-skill.js

@@ -28,7 +28,9 @@ export function createLoadSkillTool(skillsModule) {
                 return { success: false, output: result.message + hint };
             }
             const budget = skillsModule.getBudget();
-            const tokens = result.skill ? Math.ceil(result.skill.content.length / 4) : 0;
+            const tokens = result.skill
+                ? Math.ceil(result.skill.content.length / 4)
+                : 0;
             return {
                 success: true,
                 output: t("tool.skill_budget", {

package/dist/tools/path-utils.js

@@ -1,5 +1,5 @@
-import { resolve, normalize, dirname, basename, sep } from "path";
-import { existsSync } from "fs";
+import { resolve, normalize, dirname, basename, sep } from 'path';
+import { existsSync } from 'fs';
 /**
  * Resolve a user-provided path against baseDir.
  *
@@ -13,7 +13,7 @@ import { existsSync } from "fs";
  */
 export function safeResolvePath(baseDir, userPath) {
     const norm = normalize(userPath);
-    const stripped = norm.replace(/^[/\\]/, "");
+    const stripped = norm.replace(/^[/\\]/, '');
     const resolved = resolve(baseDir, stripped);
     // Fast path: if it exists (or parent does for new files), return it
     if (existsSync(resolved) || existsSync(dirname(resolved)))
@@ -31,7 +31,7 @@ export function safeResolvePath(baseDir, userPath) {
         while (idx >= 0) {
             const afterIdx = idx + name.length;
             const afterChar = stripped[afterIdx];
-            if (afterChar && afterChar !== "\\" && afterChar !== "/") {
+            if (afterChar && afterChar !== '\\' && afterChar !== '/') {
                 const fixed = stripped.slice(0, afterIdx) + sep + stripped.slice(afterIdx);
                 const fixedResolved = resolve(baseDir, normalize(fixed));
                 if (existsSync(fixedResolved) || existsSync(dirname(fixedResolved))) {

package/dist/tools/pipeline-run.js

@@ -1,13 +1,13 @@
-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";
+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;
@@ -52,29 +52,29 @@ async function runStep(ctx, step, params, outputs) {
     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"],
+    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",
+        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" },
+            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"],
+        required: ['name', 'yaml'],
     },
     handler: async (ctx, args) => {
-        const name = String(args.name || "");
-        const yaml = String(args.yaml || "");
+        const name = String(args.name || '');
+        const yaml = String(args.yaml || '');
         const params = args.params || {};
         if (!yaml) {
-            return { success: false, output: t("pipeline.invalid") };
+            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",
+                output: 'Pipeline cannot run: missing llmProvider or toolExecutor in context',
             };
         }
         const securityConfig = ctx.sessionContext
@@ -104,7 +104,7 @@ export const pipelineRunTool = {
                 if (ready.length === 0) {
                     if (failed.size > 0)
                         break;
-                    throw new Error(t("pipeline.circular", { stepId: order.join(", ") }));
+                    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)));
@@ -114,12 +114,12 @@ export const pipelineRunTool = {
                     if (result.ok) {
                         completed.add(step.id);
                         outputs[step.id] = { output: result.output };
-                        engine.setStepStatus(step.id, "done");
+                        engine.setStepStatus(step.id, 'done');
                         logs.push(`  ✓ ${step.id}: ${result.output.split("\n")[0]}`);
                     }
                     else {
                         failed.add(step.id);
-                        engine.setStepStatus(step.id, "failed");
+                        engine.setStepStatus(step.id, 'failed');
                         logs.push(`  ✗ ${step.id}: ${result.error}`);
                     }
                 }

package/dist/tools/process-kill.js

@@ -1,29 +1,29 @@
-import { processRegistry } from "../modules/processes";
-import { t } from "../i18n/index";
+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"],
+    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",
+        type: 'object',
         properties: {
-            id: { type: "string", description: "Process id from bash output or process_list" },
+            id: { type: 'string', description: 'Process id from bash output or process_list' },
         },
-        required: ["id"],
+        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 }) };
+            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: false, output: t('proc.kill_failed', { id }) };
         }
         return {
             success: true,
-            output: t("proc.killed", { id, pid: entry.pid }),
+            output: t('proc.killed', { id, pid: entry.pid }),
         };
     },
 };

package/dist/tools/process-list.js

@@ -1,36 +1,38 @@
-import { processRegistry } from "../modules/processes";
-import { t } from "../i18n/index";
+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"],
+    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",
+        type: 'object',
         properties: {},
     },
     handler: async (ctx) => {
         const list = processRegistry.list(ctx.sessionId);
         if (list.length === 0) {
-            return { success: true, output: t("proc.none") };
+            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");
+            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}):`];
+        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 ? "…" : ""}` : "";
+            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",
+        lines.push(`\n${t('proc.hint', {
+            list: 'process_list',
+            log: 'process_log',
+            kill: 'process_kill',
         })}`);
-        return { success: true, output: lines.join("\n") };
+        return { success: true, output: lines.join('\n') };
     },
 };

package/dist/tools/process-log.js

@@ -1,45 +1,41 @@
-import { processRegistry } from "../modules/processes";
-import { t } from "../i18n/index";
-import { MAX_PREVIEW_LINES } from "./preview";
+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",
+    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,
+    tags: ['shell'],
     parameters: {
-        type: "object",
+        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)`,
-            },
+            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"],
+        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 }) };
+            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 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")}`,
+                output: `${t('proc.log_header', { id, status })} ${t('proc.log_empty')}`,
             };
         }
         return {
             success: true,
-            output: `${t("proc.log_header", { id, status })}\n${log}`,
+            output: `${t('proc.log_header', { id, status })}\n${log}`,
         };
     },
 };

package/dist/tools/question.js

@@ -28,7 +28,9 @@ function normalizeQuestions(args) {
             const q = item;
             if (typeof q.question !== "string" || !q.question.trim())
                 continue;
-            const options = Array.isArray(q.options) ? q.options.filter(isOption) : undefined;
+            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)

package/dist/tools/read-file.js

@@ -5,20 +5,12 @@ 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;
+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"],
-    boundedOutput: true,
     parameters: {
         type: "object",
         properties: {

package/dist/tools/recall.js

@@ -1,30 +1,30 @@
-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"];
+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"],
+    name: 'recall',
+    description: 'Recall stored information from memory. Search across preferences, facts, conventions, decisions, errors.',
+    tags: ['memory'],
     parameters: {
-        type: "object",
+        type: 'object',
         properties: {
             query: {
-                type: "string",
-                description: "Search query (full-text search across all memory)",
+                type: 'string',
+                description: 'Search query (full-text search across all memory)',
             },
             category: {
-                type: "string",
-                description: "Limit to specific category: preferences, conventions, decisions, errors, facts",
+                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 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
@@ -39,26 +39,20 @@ export const recallTool = {
             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.empty', { query }) };
                 }
-                return {
-                    success: true,
-                    output: t("tool.recall.search_results", { category, results: results.join("\n") }),
-                };
+                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 }) };
+                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 }),
-            };
+            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) }) };
+            return { success: true, output: t('tool.memory_error', { error: String(err) }) };
         }
     },
 };
@@ -66,14 +60,14 @@ function formatAll(store) {
     const parts = [];
     const prefs = store.getPreferences();
     if (Object.keys(prefs).length > 0) {
-        parts.push("Preferences:");
+        parts.push('Preferences:');
         for (const [k, v] of Object.entries(prefs)) {
             parts.push(`  ${k} = ${v}`);
         }
     }
-    for (const cat of ["facts", "conventions", "decisions", "errors"]) {
+    for (const cat of ['facts', 'conventions', 'decisions', 'errors']) {
         const content = store.read(cat);
-        const entries = content.split("\n").filter((l) => l.startsWith("- "));
+        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)) {
@@ -81,27 +75,27 @@ function formatAll(store) {
             }
         }
     }
-    return parts.length > 0 ? parts.join("\n") : t("tool.recall.no_memory");
+    return parts.length > 0 ? parts.join('\n') : t('tool.recall.no_memory');
 }
 function formatCategory(store, category) {
-    if (category === "preferences") {
+    if (category === 'preferences') {
         const prefs = store.getPreferences();
         if (Object.keys(prefs).length === 0)
-            return t("tool.recall.no_memory");
-        const lines = ["Preferences:"];
+            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");
+        return lines.join('\n');
     }
     const content = store.read(category);
-    const entries = content.split("\n").filter((l) => l.startsWith("- "));
+    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")}`;
+        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") {
+    if (category === 'preferences') {
         const prefs = store.getPreferences();
         const lower = query.toLowerCase();
         return Object.entries(prefs)
@@ -110,8 +104,7 @@ function searchCategory(store, category, query) {
     }
     const content = store.read(category);
     const lower = query.toLowerCase();
-    return content
-        .split("\n")
-        .filter((l) => l.startsWith("- ") && l.toLowerCase().includes(lower))
-        .map((l) => `  ${l}`);
+    return content.split('\n')
+        .filter(l => l.startsWith('- ') && l.toLowerCase().includes(lower))
+        .map(l => `  ${l}`);
 }

package/dist/tools/registry.js

@@ -19,29 +19,18 @@ export class ToolRegistry {
         return Array.from(this.tools.values());
     }
     getByTags(tags) {
-        return this.getAll().filter((t) => {
+        return this.getAll().filter(t => {
             if (!t.tags || t.tags.length === 0)
                 return false;
-            return tags.some((tag) => t.tags.includes(tag));
+            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) => ({
+        const tools = tags ? this.getByTags(tags) : this.getAll();
+        return tools.map(t => ({
             name: t.name,
             description: t.description,
             parameters: t.parameters,
-            boundedOutput: t.boundedOutput,
         }));
     }
 }