micro-models-agent 0.17.0 → 0.18.0

package/dist/core/bootstrap.js

@@ -19,6 +19,7 @@ import { SkillsLoader, SkillsMatcher, SkillsModule, } from "../modules/skills/in
 import { BrowserModule } from "../modules/browser/index";
 import { IndexerModule } from "../modules/indexer/index";
 import { MCPModule } from "../modules/mcp/index";
+import { MemoryModule } from "../modules/memory/module";
 import { setLocale } from "../i18n/index";
 import { Agent } from "./agent";
 import { homedir } from "os";
@@ -202,6 +203,8 @@ export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplet
     const mcpModule = new MCPModule(config);
     await mcpModule.initialize();
     moduleRegistry.register(mcpModule);
+    const memoryModule = new MemoryModule(join(dir, 'memory'));
+    moduleRegistry.register(memoryModule);
     if (config.browser.enabled) {
         const browserModule = new BrowserModule();
         moduleRegistry.register(browserModule);

package/dist/i18n/en.json

@@ -120,6 +120,7 @@
     "tool.no_history": "No history entries matching \"{query}\"",
     "tool.no_sessions_dir": "No sessions directory found at {dir}",
     "tool.history_error": "Error searching history: {error}",
+    "tool.memory_error": "Memory error: {error}",
     "tool.screenshot_unavailable": "[Screenshot captured \u2014 image not available for text-only model]",
     "tool.timeout": "Tool {name} timed out after {seconds} seconds",
     "tool.interactive_disabled": "Interactive tool is disabled in exit-on-complete mode. Proceed without asking the user.",
@@ -447,5 +448,14 @@
     "image.error": "Failed to load image: {message}",
     "tool.friendly.attach_image": "Attach image",
     "repl.image": "Attach image",
-    "repl.image_usage": "/image <path|url|clipboard> — attach an image to the next message"
+    "repl.image_usage": "/image <path|url|clipboard> — attach an image to the next message",
+    "tool.friendly.remember": "Remember",
+    "tool.friendly.recall": "Recall",
+    "tool.remember.preference": "Remembered: {key} = {value}",
+    "tool.remember.entry": "Remembered: {category} — \"{entry}\"",
+    "tool.remember.key_required": "Key is required for preferences",
+    "tool.remember.entry_required": "Entry text is required",
+    "tool.recall.empty": "Nothing found for \"{query}\"",
+    "tool.recall.no_memory": "Memory is empty",
+    "tool.recall.search_results": "{category} results:\n{results}"
 }

package/dist/i18n/ru.json

@@ -120,6 +120,7 @@
     "tool.no_history": "Нет записей истории по \"{query}\"",
     "tool.no_sessions_dir": "Каталог сессий не найден по {dir}",
     "tool.history_error": "Ошибка поиска истории: {error}",
+    "tool.memory_error": "Ошибка памяти: {error}",
     "tool.screenshot_unavailable": "[Скриншот сделан — изображение недоступно для текстовой модели]",
     "tool.timeout": "Инструмент {name} превысил таймаут ({seconds} сек)",
     "tool.interactive_disabled": "Интерактивный инструмент отключён в режиме exit-on-complete. Продолжай без вопроса пользователю.",
@@ -447,5 +448,14 @@
     "image.error": "Не удалось загрузить изображение: {message}",
     "tool.friendly.attach_image": "Прикрепить изображение",
     "repl.image": "Прикрепить изображение",
-    "repl.image_usage": "/image <путь|URL|clipboard> — прикрепить изображение к следующему сообщению"
+    "repl.image_usage": "/image <путь|URL|clipboard> — прикрепить изображение к следующему сообщению",
+    "tool.friendly.remember": "Запомнить",
+    "tool.friendly.recall": "Вспомнить",
+    "tool.remember.preference": "Запомнено: {key} = {value}",
+    "tool.remember.entry": "Запомнено: {category} — \"{entry}\"",
+    "tool.remember.key_required": "Для preferences требуется ключ (key)",
+    "tool.remember.entry_required": "Требуется текст записи",
+    "tool.recall.empty": "Ничего не найдено по \"{query}\"",
+    "tool.recall.no_memory": "Память пуста",
+    "tool.recall.search_results": "Результаты {category}:\n{results}"
 }

package/dist/modules/memory/module.js

@@ -0,0 +1,48 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { MemoryStore } from './store';
+import { rememberTool } from '../../tools/remember';
+import { recallTool } from '../../tools/recall';
+export class MemoryModule {
+    name = 'memory';
+    store;
+    constructor(memoryDir) {
+        const dir = memoryDir || join(homedir(), '.mma', 'memory');
+        this.store = new MemoryStore(dir);
+    }
+    getSystemPromptBlock() {
+        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 {
+            content: `User preferences: ${prefStr}`,
+            priority: 'normal',
+            essential: false,
+            estimatedTokens: Math.ceil(prefStr.length / 4) + 10,
+        };
+    }
+    getToolDefinitions() {
+        return [rememberTool, recallTool];
+    }
+    getPlugin() {
+        return {
+            name: 'memory',
+            isBuiltin: true,
+            onBuildPrompt: () => {
+                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}`;
+            },
+        };
+    }
+    getStore() {
+        return this.store;
+    }
+}

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'];
+const MEMORY_FILES = ['conventions', 'decisions', 'errors', 'facts'];
 export class MemorySearch {
     memoryDir;
     constructor(memoryDir) {
@@ -21,6 +21,20 @@ export class MemorySearch {
                 }
             }
         }
+        // Search preferences.json
+        const prefsPath = join(this.memoryDir, 'preferences.json');
+        if (existsSync(prefsPath)) {
+            try {
+                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}` });
+                    }
+                }
+            }
+            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'];
+const MEMORY_FILES = ['conventions', 'decisions', 'errors', 'facts'];
 export class MemoryStore {
     memoryDir;
     constructor(memoryDir) {
@@ -35,4 +35,31 @@ export class MemoryStore {
         const searchModule = new MemorySearch(this.memoryDir);
         return searchModule.query(query);
     }
+    prefsPath() {
+        return join(this.memoryDir, 'preferences.json');
+    }
+    getPreferences() {
+        const path = this.prefsPath();
+        if (!existsSync(path))
+            return {};
+        try {
+            return JSON.parse(readFileSync(path, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    setPreference(key, value) {
+        const prefs = this.getPreferences();
+        prefs[key] = value;
+        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');
+        return true;
+    }
 }

package/dist/tools/index.js

@@ -24,11 +24,13 @@ import { createLoadSkillTool } from './load-skill';
 import { pipelineRunTool } from './pipeline-run';
 import { mcpCallTool } from './mcp-call';
 import { searchHistoryTool } from './search-history';
+import { rememberTool } from './remember';
+import { recallTool } from './recall';
 import { createBrowserTool } from './browser';
 import { attachImageTool } from './attach-image';
 export { ToolRegistry, ToolExecutor };
 export { filterToolsByTags } from './filter-tools';
-export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, questionTool, approveTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, createBrowserTool, attachImageTool, };
+export { readFileTool, writeFileTool, editFileTool, globTool, grepTool, listDirTool, createDirTool, deleteFileTool, moveFileTool, fileInfoTool, bashTool, subagentTool, processListTool, processLogTool, processKillTool, webSearchTool, webFetchTool, webBrowseTool, questionTool, approveTool, createLoadSkillTool, pipelineRunTool, mcpCallTool, searchHistoryTool, rememberTool, recallTool, createBrowserTool, attachImageTool, };
 export function registerAllTools(registry, skillsModule) {
     const tools = [
         readFileTool, writeFileTool, editFileTool,

package/dist/tools/recall.js

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

@@ -0,0 +1,67 @@
+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 rememberTool = {
+    name: 'remember',
+    description: 'Remember information across sessions. Use for user preferences, facts, conventions, decisions, or errors.',
+    tags: ['memory'],
+    parameters: {
+        type: 'object',
+        properties: {
+            category: {
+                type: 'string',
+                description: 'Memory category: preferences, conventions, decisions, errors, facts',
+                enum: CATEGORIES,
+            },
+            key: {
+                type: 'string',
+                description: 'Key name (required for preferences, e.g. "color", "language")',
+            },
+            value: {
+                type: 'string',
+                description: 'Value to store (required for preferences)',
+            },
+            entry: {
+                type: 'string',
+                description: 'Text entry to append (for conventions, decisions, errors, facts)',
+            },
+        },
+        required: ['category'],
+    },
+    handler: async (_ctx, args) => {
+        const category = String(args.category || '');
+        if (!CATEGORIES.includes(category)) {
+            return { success: false, output: t('tool.invalid_params') };
+        }
+        const memoryDir = join(homedir(), '.mma', 'memory');
+        const store = new MemoryStore(memoryDir);
+        try {
+            if (category === 'preferences') {
+                const key = String(args.key || '');
+                const value = String(args.value || '');
+                if (!key) {
+                    return { success: false, output: t('tool.remember.key_required') };
+                }
+                store.setPreference(key, value);
+                return {
+                    success: true,
+                    output: t('tool.remember.preference', { key, value }),
+                };
+            }
+            const entry = String(args.entry || '');
+            if (!entry) {
+                return { success: false, output: t('tool.remember.entry_required') };
+            }
+            store.append(category, entry);
+            return {
+                success: true,
+                output: t('tool.remember.entry', { category, entry }),
+            };
+        }
+        catch (err) {
+            return { success: true, output: t('tool.memory_error', { error: String(err) }) };
+        }
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micro-models-agent",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
   "type": "module",
   "bin": {