micro-models-agent 0.40.1 → 0.41.2

package/dist/modules/mcp/module.js

@@ -7,9 +7,7 @@ function sanitizeToolName(server, tool) {
 }
 function convertInputSchema(schema) {
     if (schema && typeof schema === "object" && "properties" in schema) {
-        const required = Array.isArray(schema.required)
-            ? schema.required
-            : [];
+        const required = Array.isArray(schema.required) ? schema.required : [];
         return {
             type: "object",
             properties: schema.properties,
@@ -118,9 +116,7 @@ export class MCPModule {
                     const result = await client.callTool(d.toolName, args);
                     return {
                         success: true,
-                        output: typeof result === "string"
-                            ? result
-                            : JSON.stringify(result, null, 2),
+                        output: typeof result === "string" ? result : JSON.stringify(result, null, 2),
                     };
                 }
                 catch (e) {

package/dist/modules/memory/index.js

@@ -1 +1 @@
-export { MemoryStore } from './store';
+export { MemoryStore } from "./store";

package/dist/modules/memory/module.js

@@ -1,44 +1,92 @@
-import { homedir } from 'os';
-import { join } from 'path';
-import { MemoryStore } from './store';
-import { rememberTool } from '../../tools/remember';
-import { recallTool } from '../../tools/recall';
+import { homedir } from "os";
+import { join } from "path";
+import { MemoryStore } from "./store";
+import { rememberTool } from "../../tools/remember";
+import { recallTool } from "../../tools/recall";
+const MEMORY_MD_FILES = ["errors", "conventions", "decisions", "facts"];
 export class MemoryModule {
-    name = 'memory';
+    name = "memory";
     store;
-    constructor(memoryDir) {
-        const dir = memoryDir || join(homedir(), '.mma', 'memory');
-        this.store = new MemoryStore(dir);
+    constructor(storeOrDir) {
+        if (storeOrDir instanceof MemoryStore) {
+            this.store = storeOrDir;
+        }
+        else {
+            const dir = storeOrDir || join(homedir(), ".mma", "memory");
+            this.store = new MemoryStore(dir);
+        }
     }
     getSystemPromptBlock() {
+        const parts = [];
         const prefs = this.store.getPreferences();
-        if (Object.keys(prefs).length === 0)
+        if (Object.keys(prefs).length > 0) {
+            const prefStr = Object.entries(prefs)
+                .map(([k, v]) => `${k}=${v}`)
+                .join(", ");
+            parts.push(`User preferences: ${prefStr}`);
+        }
+        const memoryTail = this.getMemoryTail();
+        if (memoryTail)
+            parts.push(memoryTail);
+        if (parts.length === 0)
             return null;
-        const prefStr = Object.entries(prefs)
-            .map(([k, v]) => `${k}=${v}`)
-            .join(', ');
+        const content = parts.join("\n\n");
         return {
-            content: `User preferences: ${prefStr}`,
-            priority: 'normal',
+            content,
+            priority: "normal",
             essential: false,
-            estimatedTokens: Math.ceil(prefStr.length / 4) + 10,
+            estimatedTokens: Math.ceil(content.length / 4) + 10,
         };
     }
+    /**
+     * Bounded tail of the append-only .md memory files (errors, conventions,
+     * decisions, facts). This is what makes past-session lessons visible in the
+     * system prompt — without it the loop's error rules are write-only.
+     */
+    getMemoryTail() {
+        const sections = [];
+        const tailPerFile = 3;
+        for (const name of MEMORY_MD_FILES) {
+            const content = this.store.read(name).trim();
+            if (!content)
+                continue;
+            const entries = content
+                .split(/\r?\n/)
+                .map((l) => l.trim())
+                .filter((l) => l.startsWith("- "))
+                .slice(-tailPerFile);
+            if (entries.length === 0)
+                continue;
+            sections.push(`[Memory ${name}]:\n${entries.join("\n")}`);
+        }
+        if (sections.length === 0)
+            return null;
+        let joined = sections.join("\n\n");
+        // Hard cap so a huge errors.md can never blow the system prompt budget.
+        if (joined.length > 1200)
+            joined = joined.slice(0, 1200) + "\n…";
+        return joined;
+    }
     getToolDefinitions() {
         return [rememberTool, recallTool];
     }
     getPlugin() {
         return {
-            name: 'memory',
+            name: "memory",
             isBuiltin: true,
             onBuildPrompt: () => {
+                const parts = [];
                 const prefs = this.store.getPreferences();
-                if (Object.keys(prefs).length === 0)
-                    return null;
-                const prefStr = Object.entries(prefs)
-                    .map(([k, v]) => `${k}=${v}`)
-                    .join(', ');
-                return `User preferences: ${prefStr}`;
+                if (Object.keys(prefs).length > 0) {
+                    const prefStr = Object.entries(prefs)
+                        .map(([k, v]) => `${k}=${v}`)
+                        .join(", ");
+                    parts.push(`User preferences: ${prefStr}`);
+                }
+                const memoryTail = this.getMemoryTail();
+                if (memoryTail)
+                    parts.push(memoryTail);
+                return parts.length > 0 ? parts.join("\n\n") : null;
             },
         };
     }

package/dist/modules/memory/search.js

@@ -1,6 +1,6 @@
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-const MEMORY_FILES = ['conventions', 'decisions', 'errors', 'facts'];
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+const MEMORY_FILES = ["conventions", "decisions", "errors", "facts"];
 export class MemorySearch {
     memoryDir;
     constructor(memoryDir) {
@@ -13,8 +13,8 @@ export class MemorySearch {
             const path = join(this.memoryDir, `${name}.md`);
             if (!existsSync(path))
                 continue;
-            const content = readFileSync(path, 'utf-8');
-            const lines = content.split('\n');
+            const content = readFileSync(path, "utf-8");
+            const lines = content.split("\n");
             for (const line of lines) {
                 if (line.toLowerCase().includes(lowerQuery)) {
                     results.push({ file: name, match: line.trim() });
@@ -22,18 +22,20 @@ export class MemorySearch {
             }
         }
         // Search preferences.json
-        const prefsPath = join(this.memoryDir, 'preferences.json');
+        const prefsPath = join(this.memoryDir, "preferences.json");
         if (existsSync(prefsPath)) {
             try {
-                const prefs = JSON.parse(readFileSync(prefsPath, 'utf-8'));
+                const prefs = JSON.parse(readFileSync(prefsPath, "utf-8"));
                 for (const [key, value] of Object.entries(prefs)) {
                     const searchStr = `${key}=${value}`;
                     if (searchStr.toLowerCase().includes(lowerQuery)) {
-                        results.push({ file: 'preferences', match: `${key} = ${value}` });
+                        results.push({ file: "preferences", match: `${key} = ${value}` });
                     }
                 }
             }
-            catch { /* skip */ }
+            catch {
+                /* skip */
+            }
         }
         return results;
     }

package/dist/modules/memory/store.js

@@ -1,7 +1,7 @@
-import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { MemorySearch } from './search';
-const MEMORY_FILES = ['conventions', 'decisions', 'errors', 'facts'];
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { MemorySearch } from "./search";
+const MEMORY_FILES = ["conventions", "decisions", "errors", "facts"];
 export class MemoryStore {
     memoryDir;
     constructor(memoryDir) {
@@ -10,7 +10,7 @@ export class MemoryStore {
         for (const name of MEMORY_FILES) {
             const path = join(this.memoryDir, `${name}.md`);
             if (!existsSync(path)) {
-                writeFileSync(path, `# ${name.charAt(0).toUpperCase() + name.slice(1)}\n\n`, 'utf-8');
+                writeFileSync(path, `# ${name.charAt(0).toUpperCase() + name.slice(1)}\n\n`, "utf-8");
             }
         }
     }
@@ -22,28 +22,28 @@ export class MemoryStore {
     read(name) {
         const path = join(this.memoryDir, `${name}.md`);
         if (!existsSync(path))
-            return '';
-        return readFileSync(path, 'utf-8');
+            return "";
+        return readFileSync(path, "utf-8");
     }
     append(name, entry) {
         const path = join(this.memoryDir, `${name}.md`);
-        const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+        const timestamp = new Date().toISOString().replace("T", " ").slice(0, 19);
         const formatted = `- **${timestamp}** — ${entry}\n`;
-        appendFileSync(path, formatted, 'utf-8');
+        appendFileSync(path, formatted, "utf-8");
     }
     search(query) {
         const searchModule = new MemorySearch(this.memoryDir);
         return searchModule.query(query);
     }
     prefsPath() {
-        return join(this.memoryDir, 'preferences.json');
+        return join(this.memoryDir, "preferences.json");
     }
     getPreferences() {
         const path = this.prefsPath();
         if (!existsSync(path))
             return {};
         try {
-            return JSON.parse(readFileSync(path, 'utf-8'));
+            return JSON.parse(readFileSync(path, "utf-8"));
         }
         catch {
             return {};
@@ -52,14 +52,14 @@ export class MemoryStore {
     setPreference(key, value) {
         const prefs = this.getPreferences();
         prefs[key] = value;
-        writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), 'utf-8');
+        writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
     }
     deletePreference(key) {
         const prefs = this.getPreferences();
         if (!(key in prefs))
             return false;
         delete prefs[key];
-        writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), 'utf-8');
+        writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
         return true;
     }
     appendRule(category, pattern, cause, solution) {

package/dist/modules/pipelines/engine.js

@@ -1,4 +1,4 @@
-import { t } from '../../i18n/index';
+import { t } from "../../i18n/index";
 export class PipelineEngine {
     stepStatus = new Map();
     resolveDependencies(steps) {
@@ -7,7 +7,7 @@ export class PipelineEngine {
         const order = [];
         function visit(stepId, stepMap) {
             if (inStack.has(stepId))
-                throw new Error(t('pipeline.circular', { stepId }));
+                throw new Error(t("pipeline.circular", { stepId }));
             if (visited.has(stepId))
                 return;
             inStack.add(stepId);
@@ -21,7 +21,7 @@ export class PipelineEngine {
             visited.add(stepId);
             order.push(stepId);
         }
-        const stepMap = new Map(steps.map(s => [s.id, s]));
+        const stepMap = new Map(steps.map((s) => [s.id, s]));
         for (const step of steps) {
             if (!visited.has(step.id)) {
                 visit(step.id, stepMap);
@@ -30,28 +30,28 @@ export class PipelineEngine {
         return order;
     }
     getReadySteps(steps, completed) {
-        return steps.filter(s => {
+        return steps.filter((s) => {
             if (completed.has(s.id))
                 return false;
-            if (this.stepStatus.get(s.id) === 'running')
+            if (this.stepStatus.get(s.id) === "running")
                 return false;
-            if (this.stepStatus.get(s.id) === 'failed')
+            if (this.stepStatus.get(s.id) === "failed")
                 return false;
             if (!s.depends_on || s.depends_on.length === 0)
                 return true;
-            return s.depends_on.every(d => completed.has(d));
+            return s.depends_on.every((d) => completed.has(d));
         });
     }
     setStepStatus(stepId, status) {
         this.stepStatus.set(stepId, status);
     }
     getStepStatus(stepId) {
-        return this.stepStatus.get(stepId) || 'pending';
+        return this.stepStatus.get(stepId) || "pending";
     }
     isComplete(stepIds) {
-        return stepIds.every(id => {
+        return stepIds.every((id) => {
             const s = this.stepStatus.get(id);
-            return s === 'done' || s === 'skipped';
+            return s === "done" || s === "skipped";
         });
     }
     reset() {

package/dist/modules/pipelines/index.js

@@ -1,3 +1,3 @@
-export { PipelineParser } from './parser';
-export { PipelineEngine } from './engine';
-export { TemplateEngine } from './template';
+export { PipelineParser } from "./parser";
+export { PipelineEngine } from "./engine";
+export { TemplateEngine } from "./template";

package/dist/modules/pipelines/parser.js

@@ -1,23 +1,23 @@
-import { t } from '../../i18n/index';
+import { t } from "../../i18n/index";
 export class PipelineParser {
     static parse(yaml) {
-        const lines = yaml.split('\n').filter(l => l.trim());
+        const lines = yaml.split("\n").filter((l) => l.trim());
         const result = {};
         let currentSection = null;
         let currentSteps = [];
         for (const line of lines) {
-            if (line.match(/^\w+:/) && !line.startsWith(' ') && !line.startsWith('  -')) {
-                const [key, ...valParts] = line.split(':');
-                const val = valParts.join(':').trim();
-                if (key === 'steps') {
-                    currentSection = 'steps';
+            if (line.match(/^\w+:/) && !line.startsWith(" ") && !line.startsWith("  -")) {
+                const [key, ...valParts] = line.split(":");
+                const val = valParts.join(":").trim();
+                if (key === "steps") {
+                    currentSection = "steps";
                 }
                 else {
                     result[key] = val;
                     currentSection = null;
                 }
             }
-            else if (currentSection === 'steps') {
+            else if (currentSection === "steps") {
                 const stepMatch = line.match(/^\s+- id:\s*(\S+)/);
                 if (stepMatch) {
                     currentSteps.push({ id: stepMatch[1] });
@@ -28,12 +28,15 @@ export class PipelineParser {
                     if (kvMatch) {
                         const key = kvMatch[1];
                         let val = kvMatch[2].trim();
-                        if (val === 'true')
+                        if (val === "true")
                             val = true;
-                        else if (val === 'false')
+                        else if (val === "false")
                             val = false;
-                        else if (val.startsWith('[') && val.endsWith(']')) {
-                            val = val.slice(1, -1).split(',').map((s) => s.trim().replace(/^['"]|['"]$/g, ''));
+                        else if (val.startsWith("[") && val.endsWith("]")) {
+                            val = val
+                                .slice(1, -1)
+                                .split(",")
+                                .map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
                         }
                         lastStep[key] = val;
                     }
@@ -41,11 +44,11 @@ export class PipelineParser {
             }
         }
         if (!result.name || currentSteps.length === 0) {
-            throw new Error(t('pipeline.invalid'));
+            throw new Error(t("pipeline.invalid"));
         }
         for (const step of currentSteps) {
             if (!step.id || !step.agent || !step.prompt) {
-                throw new Error(t('pipeline.step_missing_fields', { step: JSON.stringify(step) }));
+                throw new Error(t("pipeline.step_missing_fields", { step: JSON.stringify(step) }));
             }
         }
         return { name: result.name, steps: currentSteps };

package/dist/modules/pipelines/template.js

@@ -2,7 +2,7 @@ export class TemplateEngine {
     static render(template, params, stepOutputs) {
         let result = template;
         for (const [key, val] of Object.entries(params)) {
-            result = result.replace(new RegExp(`\\{${key}\\}`, 'g'), val);
+            result = result.replace(new RegExp(`\\{${key}\\}`, "g"), val);
         }
         if (stepOutputs) {
             result = result.replace(/\{\{steps\.(\w+)\.output\}\}/g, (_, stepId) => {

package/dist/modules/plugins/builtin/lint-on-write.js

@@ -2,6 +2,7 @@ import { spawn, execSync } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import { resolve, extname, join } from "path";
 import { platform } from "os";
+import { findProjectRoot } from "../../lsp/project-root";
 const TYPE_CHECK_DEBOUNCE_MS = 2000;
 // Per-file syntax checks are cached by (path, content hash): re-writing a file
 // with identical content skips the (expensive) check. Content changes → cache
@@ -40,6 +41,7 @@ function getWinDecoder() {
 export class LintOnWritePlugin {
     name = "lint-on-write";
     priority = 10;
+    isBuiltin = true;
     _checkPromise = null;
     _checkTimestamp = 0;
     async onAfterTool(ctx, call, result) {
@@ -62,10 +64,10 @@ export class LintOnWritePlugin {
             return;
         }
         await this.runProjectLint(ctx, result);
-        await this.runProjectTypeCheck(ctx, result);
+        await this.runProjectTypeCheck(fullPath, ctx.baseDir, result);
     }
     async checkSyntax(filePath, ext, baseDir) {
-        if (ext === ".ts" || ext === ".tsx") {
+        if (ext === ".ts" || ext === ".tsx" || ext === ".cts" || ext === ".mts") {
             // Syntax-only check via bun's parser (~200ms) instead of `npx tsc`
             // (~3-5s per write). Full type errors are still surfaced by the
             // debounced project typecheck below when a tsconfig exists.
@@ -93,21 +95,19 @@ export class LintOnWritePlugin {
                     return null;
                 }
                 const stderr = err.stderr?.toString() || err.stdout?.toString() || "";
-                const firstError = stderr.split("\n").find((line) => line.trim()) ||
-                    "TypeScript syntax error";
+                const firstError = stderr.split("\n").find((line) => line.trim()) || "TypeScript syntax error";
                 syntaxCache.set(filePath, { hash, error: firstError.trim() });
                 return firstError.trim();
             }
         }
-        if (ext === ".js" || ext === ".jsx") {
+        if (ext === ".js" || ext === ".jsx" || ext === ".cjs" || ext === ".mjs") {
             try {
                 await runAsync(`node --check "${filePath}"`, baseDir, 5000);
                 return null;
             }
             catch (err) {
                 const stderr = err.stderr?.toString() || "";
-                const firstError = stderr.split("\n").find((line) => line.trim()) ||
-                    "JavaScript syntax error";
+                const firstError = stderr.split("\n").find((line) => line.trim()) || "JavaScript syntax error";
                 return firstError.trim();
             }
         }
@@ -129,18 +129,25 @@ export class LintOnWritePlugin {
             ctx.logger.debug("Lint passed");
         }
         catch (err) {
+            const stderr = (err.stderr?.toString?.() || "").trim();
+            const stdout = (err.stdout?.toString?.() || "").trim();
+            const detail = (stderr || stdout || err.message).split("\n").filter(Boolean).slice(-5).join("\n");
             ctx.logger.warn(`Lint failed: ${err.message}`);
-            result.output += `\n\n[Project lint failed]: ${err.message}`;
+            result.output += `\n\n[Project lint failed]: ${detail}`;
         }
     }
-    async runProjectTypeCheck(ctx, result) {
-        const tsconfigPath = join(ctx.baseDir, "tsconfig.json");
+    async runProjectTypeCheck(filePath, baseDir, result) {
+        // Resolve the project root from the EDITED FILE, not the agent baseDir.
+        // In a nested layout (`baseDir/proj/tsconfig.json`) the old baseDir-based
+        // lookup silently skipped the typecheck on every write — the whole
+        // session then ran with zero type feedback (observed in ses_mst2r0r5).
+        const projectRoot = findProjectRoot(filePath, baseDir, ["tsconfig.json", "package.json"]);
+        const tsconfigPath = join(projectRoot, "tsconfig.json");
         if (!existsSync(tsconfigPath)) {
             return;
         }
         const now = Date.now();
-        if (this._checkPromise &&
-            now - this._checkTimestamp < TYPE_CHECK_DEBOUNCE_MS) {
+        if (this._checkPromise && now - this._checkTimestamp < TYPE_CHECK_DEBOUNCE_MS) {
             const error = await this._checkPromise;
             if (error) {
                 result.output += `\n\n[Project typecheck failed]: ${error}`;
@@ -148,7 +155,7 @@ export class LintOnWritePlugin {
             return;
         }
         this._checkTimestamp = now;
-        this._checkPromise = this.runTscCheck(ctx.baseDir);
+        this._checkPromise = this.runTscCheck(projectRoot);
         const error = await this._checkPromise;
         if (error) {
             result.output += `\n\n[Project typecheck failed]: ${error}`;
@@ -167,9 +174,7 @@ export class LintOnWritePlugin {
             }
             const stderr = err.stderr?.toString() || err.stdout?.toString() || "";
             if (stderr.includes("error TS")) {
-                const firstError = stderr
-                    .split("\n")
-                    .find((line) => line.includes("error TS")) ||
+                const firstError = stderr.split("\n").find((line) => line.includes("error TS")) ||
                     "TypeScript type error";
                 return firstError.trim();
             }

package/dist/modules/plugins/builtin/notify.js

@@ -1,8 +1,9 @@
 export class NotifyPlugin {
-    name = 'notify';
+    name = "notify";
     priority = 5;
+    isBuiltin = true;
     onSessionEnd(ctx) {
-        ctx.logger.info('Session ended');
+        ctx.logger.info("Session ended");
     }
 }
 export const plugin = new NotifyPlugin();

package/dist/modules/plugins/index.js

@@ -1 +1 @@
-export { PluginManager } from './manager';
+export { PluginManager } from "./manager";

package/dist/modules/plugins/loader.js

@@ -1,28 +1,70 @@
-import { readdirSync, existsSync, statSync } from 'fs';
-import { join } from 'path';
-import { t } from '../../i18n/index';
+import { readdirSync, existsSync, statSync } from "fs";
+import { join, basename } from "path";
+import { t } from "../../i18n/index";
+import { semverGt } from "../updater/checker";
+/**
+ * Entry file candidates for folder plugins. Looked up in order:
+ * `plugin.ts` > `plugin.js` > `index.ts` > `index.js`.
+ */
+const FOLDER_ENTRY_NAMES = ["plugin.ts", "plugin.js", "index.ts", "index.js"];
 export class PluginLoader {
-    loadFromDir(dirPath, pluginManager, logger) {
+    loadFromDir(dirPath, pluginManager, logger, options) {
         if (!existsSync(dirPath))
             return;
-        const entries = readdirSync(dirPath);
+        const entries = readdirSync(dirPath).sort();
         for (const entry of entries) {
             const fullPath = join(dirPath, entry);
-            if (!statSync(fullPath).isFile())
-                continue;
-            if (!entry.endsWith('.ts') && !entry.endsWith('.js'))
-                continue;
-            try {
-                const mod = require(fullPath);
-                const plugin = mod.default || mod.plugin;
-                if (plugin && plugin.name) {
-                    pluginManager.register(plugin);
-                    logger?.warn(t('plugin.loaded', { name: plugin.name }));
+            const stat = statSync(fullPath);
+            if (stat.isFile()) {
+                if (!entry.endsWith(".ts") && !entry.endsWith(".js"))
+                    continue;
+                this.tryLoad(fullPath, entry, pluginManager, logger, options);
+            }
+            else if (stat.isDirectory()) {
+                const entryFile = this.findEntryFile(fullPath);
+                if (entryFile) {
+                    this.tryLoad(entryFile, `${entry}/${basename(entryFile)}`, pluginManager, logger, options);
                 }
             }
-            catch (e) {
-                logger?.warn(t('plugin.skipped', { entry, message: e.message }));
+        }
+    }
+    findEntryFile(dir) {
+        for (const name of FOLDER_ENTRY_NAMES) {
+            const candidate = join(dir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+        return null;
+    }
+    tryLoad(fullPath, label, pluginManager, logger, options) {
+        try {
+            const mod = require(fullPath);
+            const plugin = mod.default || mod.plugin;
+            if (plugin && plugin.name) {
+                if (plugin.minMmaVersion &&
+                    options?.mmaVersion &&
+                    semverGt(plugin.minMmaVersion, options.mmaVersion)) {
+                    logger?.warn(t("plugin.incompatible", {
+                        name: plugin.name,
+                        min: plugin.minMmaVersion,
+                        current: options.mmaVersion,
+                    }));
+                    return;
+                }
+                const result = pluginManager.register(plugin, options?.source);
+                if (result.status === "registered") {
+                    logger?.warn(t("plugin.loaded", { name: plugin.name }));
+                }
+                else if (result.status === "skipped_older") {
+                    logger?.warn(t("plugin.dedup_older", {
+                        name: plugin.name,
+                        version: plugin.version || "0.0.0",
+                    }));
+                }
             }
         }
+        catch (e) {
+            logger?.warn(t("plugin.skipped", { entry: label, message: e.message }));
+        }
     }
 }