micro-models-agent 0.28.9 → 0.29.0

package/dist/core/bootstrap.js

@@ -0,0 +1,321 @@
+import { loadConfig } from "../config/config";
+import { Logger } from "../logger/app-logger";
+import { OpenAICompatProvider } from "../llm/openai-compat";
+import { ModelLoader } from "../llm/model-loader";
+import { ToolRegistry, registerAllTools } from "../tools/index";
+import { ToolExecutor } from "../tools/executor";
+import { ModuleRegistry } from "../modules/registry";
+import { PluginManager } from "../modules/plugins/manager";
+import { PluginLoader } from "../modules/plugins/loader";
+import { plugin as lintOnWritePlugin } from "../modules/plugins/builtin/lint-on-write";
+import { plugin as notifyPlugin } from "../modules/plugins/builtin/notify";
+import { ContextManager } from "../modules/context/manager";
+import { TokenCounter } from "../llm/token-counter";
+import { HallucinationDetector } from "../modules/hallucination/detector";
+import { ExecutionModule } from "../modules/execution/module";
+import { SessionStore, SessionManager, SessionModule, } from "../modules/session/index";
+import { UserProfile } from "../modules/user-profile/profile";
+import { SkillsLoader, SkillsMatcher, SkillsModule, } from "../modules/skills/index";
+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";
+import { join, resolve } from "path";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+function buildSystemInfo(config, baseDir, profileCompressed) {
+    const now = new Date().toISOString().replace("T", " ").slice(0, 19);
+    const isWin = profileCompressed.toLowerCase().includes("win32");
+    const lines = [
+        `You are MMA v2, an AI coding agent for small models (${config.model}).`,
+        `Date: ${now}`,
+        `Workspace: ${baseDir}`,
+        `${profileCompressed}`,
+        `Reply in the user's language. Use tools for filesystem, bash, web access.`,
+        `When you need to act, call a tool immediately. Do not describe your plans in text — use tools to perform operations.`,
+        `After every tool call, check whether the user's request is fully satisfied. If any files, commands, or checks are still missing, call the next needed tool right away. Do not stop with an empty or "done" response until the task is complete.`,
+        `If you create a directory, continue creating the files that belong inside it. A created folder alone is not a completed task.`,
+        `If a tool call fails (e.g., a skill is too large), try an alternative approach or continue without it. Do not reply with empty text when the task is unfinished.`,
+        ``,
+        `Design principles — apply them automatically without naming them:`,
+        `- Do not add code, files, or abstractions that are not needed right now (YAGNI — You Ain't Gonna Need It). If something is not required by the current task, omit it.`,
+        `- Prefer simple, straightforward solutions over clever or complex ones (KISS — Keep It Simple, Stupid). Flat code beats nested, minimal config beats flexible, explicit beats generic.`,
+        `- Do not duplicate code, logic, or configuration (DRY — Don't Repeat Yourself). Extract shared logic into a single place, reuse existing utilities and patterns before writing new ones.`,
+    ];
+    if (isWin) {
+        lines.push(``, `Windows environment — use Windows-compatible commands:`, `- Use "dir" instead of "ls". Use "dir /b" for bare listing.`, `- Use "type" or "Get-Content" instead of "cat".`, `- Use "cd" instead of "pwd". Use "echo %cd%" to print working directory.`, `- Use "copy" instead of "cp", "move" instead of "mv", "del" instead of "rm".`, `- Do not use "mkdir -p" — Windows mkdir creates intermediate dirs by default. Use the create_dir tool instead.`, `- Use forward slashes (/) or escaped backslashes (\\\\) in file paths.`, `- Your working directory is: ${baseDir}`);
+    }
+    lines.push(``, `Bash tool rules:`, `- Use the "workdir" parameter to run commands in a specific directory. Do NOT chain "cd dir && cmd" — the security module blocks the "&&" operator.`, `- Run one command per tool call. Split multi-step shell operations into separate bash calls.`);
+    if (config.autoPlan) {
+        lines.push(``, `Plan rule: For any task with 2+ steps, create a plan first using the "plan" tool. After each step, call "plan update" to mark progress. Stay focused on the current step.`);
+    }
+    const hasMCP = config.mcpServers &&
+        Object.values(config.mcpServers).some((s) => s.enabled !== false);
+    if (hasMCP) {
+        lines.push(``, `MCP servers are available. Use the named MCP tools (prefixed with mcp__) to query external services.`);
+    }
+    return lines.join("\n");
+}
+export async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
+    const dir = configDir || join(homedir(), ".mma");
+    const projectConfigPath = projectDir
+        ? join(projectDir, ".mmrc")
+        : join(process.cwd(), ".mmrc");
+    const config = loadConfig({ configDir: dir, projectConfigPath });
+    setLocale(config.locale);
+    // Update global audit notifier with config
+    try {
+        const { globalAuditNotifier } = await import("../modules/security/audit-notifier");
+        if (config.security?.auditNotifier) {
+            globalAuditNotifier.updateConfig(config.security.auditNotifier);
+        }
+    }
+    catch {
+        // Ignore if audit notifier is not available
+    }
+    const logger = new Logger(config.logLevel);
+    logger.setLogDir(join(dir, "logs"));
+    logger.debug("MMA bootstrap", {
+        version: config.version,
+        model: config.model,
+    });
+    if (config.modelLoad.autoLoad) {
+        const modelLoader = new ModelLoader(config.provider.baseUrl, logger);
+        const loadResult = await modelLoader.ensureModelLoaded({
+            model: config.model,
+            contextLength: config.contextWindow,
+            flashAttention: config.modelLoad.flashAttention,
+            offloadKvCacheToGpu: config.modelLoad.offloadKvCacheToGpu,
+            autoLoad: config.modelLoad.autoLoad,
+        });
+        if (!loadResult.success) {
+            logger.warn(`Model auto-load failed: ${loadResult.error}. Continuing with manual load.`);
+        }
+        else if (loadResult.alreadyLoaded) {
+            logger.debug(`Model ${config.model} already loaded`);
+        }
+        else {
+            logger.info(`Model ${config.model} loaded in ${loadResult.loadTime}s`);
+        }
+    }
+    const profile = new UserProfile(join(dir));
+    profile.load() || profile.collect();
+    profile.save();
+    const llmProvider = new OpenAICompatProvider({
+        model: config.model,
+        baseUrl: config.provider.baseUrl,
+        apiKey: config.provider.apiKey,
+        contextWindow: config.contextWindow,
+        retry: config.retry,
+        rateLimits: config.security?.rateLimits,
+    });
+    const baseDir = projectDir ? resolve(projectDir) : process.cwd();
+    const projectMapCacheDir = join(baseDir, ".mma");
+    const indexerModule = new IndexerModule({
+        baseDir,
+        cacheDir: projectMapCacheDir,
+    });
+    try {
+        await indexerModule.buildIndex();
+    }
+    catch (err) {
+        logger.warn(`Project indexing failed: ${err.message}`);
+    }
+    const skillsLoader = new SkillsLoader();
+    const builtinDir = join(import.meta.dirname, "skills", "builtin");
+    const globalDir = join(homedir(), ".agents", "skills");
+    const projectSkillsDir = join(baseDir, ".mma", "skills");
+    const availableSkills = skillsLoader.loadFromAllSources(builtinDir, globalDir, projectSkillsDir);
+    const skillsMatcher = new SkillsMatcher();
+    const skillsBudget = Math.floor(config.contextWindow * 0.1);
+    const skillsModule = new SkillsModule(availableSkills, skillsMatcher, skillsBudget);
+    const toolRegistry = new ToolRegistry();
+    registerAllTools(toolRegistry, skillsModule);
+    const pluginManager = new PluginManager();
+    const systemInfoPrompt = {
+        content: buildSystemInfo(config, baseDir, profile.compress()),
+        priority: "critical",
+        essential: true,
+        estimatedTokens: 250,
+    };
+    const agentsMdGlobal = join(dir, "AGENTS.md");
+    if (!existsSync(agentsMdGlobal)) {
+        writeFileSync(agentsMdGlobal, "", "utf-8");
+    }
+    const sessionDir = join(dir, "sessions");
+    const sessionStore = new SessionStore(sessionDir);
+    sessionStore.init();
+    const sessionManager = new SessionManager(sessionStore, {
+        model: config.model,
+        contextWindow: config.contextWindow,
+        projectDir: baseDir,
+        maxSessions: config.session.maxSessions,
+        isolation: config.sessionIsolation,
+    });
+    if (config.session.autoSave && !sessionManager.getActive()) {
+        sessionManager.create();
+    }
+    const tokenCounter = new TokenCounter(config.model);
+    const contextManager = new ContextManager(config.contextWindow, config.contextBudget, tokenCounter);
+    const toolCtx = {
+        config,
+        baseDir,
+        logger,
+        exitOnComplete,
+        contextManager,
+        sessionId: sessionManager.getActiveMeta()?.id,
+        sessionContext: sessionManager.getSessionContext() ?? undefined,
+        recursionDepth: 0,
+        fileOperationsCount: 0,
+        sessionHistory: {
+            append: async (type, content) => {
+                const meta = sessionManager.getActiveMeta();
+                if (!meta)
+                    return;
+                sessionManager.appendMessage({
+                    role: "tool",
+                    content: typeof content === "string" ? content : JSON.stringify(content),
+                    name: type,
+                    timestamp: new Date().toISOString(),
+                });
+            },
+        },
+    };
+    const toolExecutor = new ToolExecutor(toolRegistry, toolCtx, pluginManager);
+    toolCtx.llmProvider = llmProvider;
+    toolCtx.toolExecutor = toolExecutor;
+    const hallucinationDetector = new HallucinationDetector();
+    const factualCheck = hallucinationDetector.getFactualCheck();
+    factualCheck.setBaseDir(baseDir);
+    toolCtx.trackReadPath = (p) => factualCheck.trackReadPath(p);
+    toolCtx.trackCreatedPath = (p) => factualCheck.trackCreatedPath(p);
+    toolCtx.trackDeletedPath = (p) => factualCheck.trackDeletedPath(p);
+    toolCtx.trackDocumentContent = (c) => factualCheck.trackDocumentContent(c);
+    const moduleRegistry = new ModuleRegistry();
+    const execModule = new ExecutionModule(baseDir, config.stuckThreshold);
+    moduleRegistry.register(execModule);
+    const sessionModule = new SessionModule(sessionManager);
+    moduleRegistry.register(sessionModule);
+    moduleRegistry.register(skillsModule);
+    moduleRegistry.register(indexerModule);
+    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);
+        const browserPlugin = browserModule.getPlugin();
+        if (browserPlugin) {
+            browserPlugin.isBuiltin = true;
+            pluginManager.register(browserPlugin);
+        }
+    }
+    const moduleTools = moduleRegistry.collectToolDefinitions();
+    for (const tool of moduleTools) {
+        toolRegistry.register(tool);
+    }
+    const plugin = execModule.getPlugin();
+    if (plugin) {
+        plugin.isBuiltin = true;
+        pluginManager.register(plugin);
+    }
+    const sessionPlugin = sessionModule.getPlugin();
+    if (sessionPlugin) {
+        sessionPlugin.isBuiltin = true;
+        pluginManager.register(sessionPlugin);
+    }
+    const skillsPlugin = skillsModule.getPlugin();
+    if (skillsPlugin) {
+        skillsPlugin.isBuiltin = true;
+        pluginManager.register(skillsPlugin);
+    }
+    const indexerPlugin = indexerModule.getPlugin();
+    if (indexerPlugin) {
+        indexerPlugin.isBuiltin = true;
+        pluginManager.register(indexerPlugin);
+    }
+    const mcpPlugin = mcpModule.getPlugin();
+    if (mcpPlugin) {
+        mcpPlugin.isBuiltin = true;
+        pluginManager.register(mcpPlugin);
+    }
+    pluginManager.register(lintOnWritePlugin);
+    pluginManager.register(notifyPlugin);
+    const pluginLoader = new PluginLoader();
+    const globalPluginsDir = join(homedir(), ".mma", "plugins");
+    const projectPluginsDir = join(dir, ".mma", "plugins");
+    pluginLoader.loadFromDir(globalPluginsDir, pluginManager, logger);
+    pluginLoader.loadFromDir(projectPluginsDir, pluginManager, logger);
+    contextManager.onCompact = (summary) => {
+        const meta = sessionManager.getActiveMeta();
+        if (!meta || !config.session.autoSave)
+            return;
+        sessionManager.appendMessage({
+            role: summary.role,
+            content: summary.content,
+            name: summary.name,
+            timestamp: new Date().toISOString(),
+        });
+    };
+    const agentsMdBlocks = [];
+    const skipAgentsMd = noAgentsMd === true;
+    if (!skipAgentsMd) {
+        const agentsMdCandidates = [
+            join(baseDir, "AGENTS.md"),
+            join(baseDir, ".mma", "AGENTS.md"),
+            join(dir, "AGENTS.md"),
+        ];
+        for (const p of agentsMdCandidates) {
+            if (existsSync(p)) {
+                const content = readFileSync(p, "utf-8").trim();
+                if (content) {
+                    agentsMdBlocks.push({
+                        content,
+                        priority: "high",
+                        essential: false,
+                        estimatedTokens: Math.ceil(content.length / 4),
+                    });
+                }
+            }
+        }
+    }
+    const promptBlocks = [
+        systemInfoPrompt,
+        ...moduleRegistry.collectPromptBlocks(),
+        ...agentsMdBlocks,
+    ];
+    const agentDeps = {
+        config,
+        llmProvider,
+        toolExecutor,
+        pluginManager,
+        contextManager,
+        hallucinationDetector,
+        logger,
+        baseDir,
+        promptBlocks,
+        getDynamicPromptBlocks: () => {
+            const planBlock = execModule.getSystemPromptBlock();
+            return planBlock ? [planBlock] : [];
+        },
+        finalAudit: () => execModule.runFinalAudit(),
+        sessionManager,
+        exitOnComplete,
+    };
+    const agent = new Agent(agentDeps);
+    return {
+        agent,
+        config,
+        logger,
+        sessionManager,
+        skillsModule,
+        pluginManager,
+        configDir: dir,
+        baseDir,
+        noAgentsMd: skipAgentsMd,
+    };
+}

package/dist/core/index.js

@@ -0,0 +1,2 @@
+export { PromptBuilder } from './prompt-builder';
+export { Agent } from './agent';

package/dist/core/prompt-builder.js

@@ -0,0 +1,55 @@
+const PRIORITY_ORDER = {
+    critical: 0,
+    high: 1,
+    normal: 2,
+    low: 3,
+};
+export class PromptBuilder {
+    blocks = [];
+    budget;
+    constructor(budget) {
+        this.budget = budget;
+    }
+    addBlock(block) {
+        this.blocks.push(block);
+    }
+    addBlocks(blocks) {
+        for (const b of blocks) {
+            this.blocks.push(b);
+        }
+    }
+    build() {
+        const essential = [];
+        const nonEssential = [];
+        for (const block of this.blocks) {
+            if (block.essential) {
+                essential.push(block);
+            }
+            else {
+                nonEssential.push(block);
+            }
+        }
+        nonEssential.sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
+        let usedTokens = 0;
+        const included = [];
+        const excluded = [];
+        for (const block of essential) {
+            included.push(block.content);
+            usedTokens += block.estimatedTokens;
+        }
+        for (const block of nonEssential) {
+            const tokens = block.estimatedTokens;
+            if (usedTokens + tokens <= this.budget) {
+                included.push(block.content);
+                usedTokens += tokens;
+            }
+            else {
+                excluded.push(block.content);
+            }
+        }
+        return {
+            prompt: included.join('\n\n'),
+            excluded,
+        };
+    }
+}

package/dist/core/session-logger.js

@@ -0,0 +1,122 @@
+/**
+ * Thin wrapper around SessionManager that eliminates repetitive
+ * `if (sessionManager)` + `new Date().toISOString()` boilerplate
+ * from the agent loop.
+ */
+export class SessionLogger {
+    session;
+    constructor(session) {
+        this.session = session;
+    }
+    get active() {
+        return !!this.session?.getActive();
+    }
+    logSystem(content) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "system",
+            content,
+        });
+    }
+    logUser(content) {
+        this.session?.appendMessage({
+            role: "user",
+            content,
+            timestamp: new Date().toISOString(),
+        });
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "user",
+            content,
+        });
+    }
+    logAssistant(content, reasoning, toolCalls, iteration) {
+        if (reasoning) {
+            this.session?.appendLog({
+                ts: new Date().toISOString(),
+                type: "reasoning",
+                content: reasoning,
+                iteration,
+            });
+        }
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "assistant",
+            content,
+            ...(toolCalls
+                ? { tool_calls: toolCalls.map((tc) => ({ id: tc.id, name: tc.name, arguments: tc.arguments })) }
+                : {}),
+            iteration,
+        });
+    }
+    saveAssistantMessage(content) {
+        this.session?.appendMessage({
+            role: "assistant",
+            content: content.slice(0, 500),
+            timestamp: new Date().toISOString(),
+        });
+    }
+    logToolDefs(toolCount, toolNames, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "tool_defs",
+            toolCount,
+            toolNames,
+            iteration,
+        });
+    }
+    logToolCall(call, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "tool_call",
+            tool: call.name,
+            tool_call_id: call.id,
+            args: call.arguments,
+            iteration,
+        });
+    }
+    logToolResult(call, result, duration, iteration) {
+        this.session?.appendMessage({
+            role: "tool",
+            content: result.output.slice(0, 500),
+            name: call.name,
+            timestamp: new Date().toISOString(),
+        });
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "tool_result",
+            tool: call.name,
+            tool_call_id: call.id,
+            success: result.success,
+            content: result.output.slice(0, 1000),
+            diff: result.diff,
+            duration,
+            iteration,
+        });
+    }
+    logCompaction(content, iteration, contextTokens, contextLimit) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "compaction",
+            content,
+            iteration,
+            ...(contextTokens !== undefined ? { contextTokens } : {}),
+            ...(contextLimit !== undefined ? { contextLimit } : {}),
+        });
+    }
+    logError(message) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "error",
+            content: message,
+        });
+    }
+    logAudit(summary, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "audit",
+            content: summary,
+            iteration,
+        });
+    }
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};