micro-models-agent 0.19.1 → 0.19.2

package/dist/core/bootstrap.js

@@ -1,314 +0,0 @@
-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.`,
-        `Use tools when needed. Explain briefly what you're doing if it's not obvious.`,
-        `Answer the user's question directly. Only take action when the user explicitly asks you to change, create, or fix something.`,
-        `If a tool call fails, report the error and ask the user how to proceed.`,
-        ``,
-        `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 complex tasks with 3+ steps, you may create a plan using the "plan" tool. For simple questions, just answer directly.`);
-    }
-    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 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

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

package/dist/core/prompt-builder.js

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

@@ -1,122 +0,0 @@
-/**
- * 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

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