micro-models-agent 0.57.0 → 0.57.2

package/dist/config/config.js

@@ -0,0 +1,276 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { DEFAULTS } from "./defaults";
+import { DEFAULT_SECURITY_CONFIG } from "./security";
+import { DEFAULT_LSP_CONFIG } from "../modules/lsp/config";
+import { t } from "../i18n/index";
+import { MigrationDetector } from "../migration/detect";
+import { BackupManager } from "../migration/backup";
+import { validateExpertConfig } from "./experts";
+import { ConfigEncryptor } from "../modules/security/encryption";
+import { loadDomainFiles, saveDomainFiles } from "./domains";
+// ── Centralized path constants ──────────────────────────────────────────
+export const CONFIG_DIR = join(homedir(), ".mma");
+export const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export const CONFIG_DOMAIN_DIR = join(CONFIG_DIR, "config");
+// ── Internal helpers ────────────────────────────────────────────────────
+/**
+ * Restore RegExp instances in dangerousPatterns that were serialized as {}
+ * (pre-0.8.0 configs) or as {__regex, source, flags} (new format).
+ * Falls back to default patterns for any entry that is not a real RegExp.
+ */
+function restoreDangerousPatterns(patterns, defaults) {
+    const fallback = (Array.isArray(defaults) ? defaults : []);
+    if (!Array.isArray(patterns) || patterns.length === 0) {
+        return fallback;
+    }
+    return patterns.map((p, i) => {
+        if (p instanceof RegExp)
+            return p;
+        if (p && typeof p === "object") {
+            const { source, flags } = p;
+            if (source && typeof source === "string") {
+                try {
+                    return new RegExp(source, flags || "");
+                }
+                catch {
+                    // fall through
+                }
+            }
+        }
+        return fallback[i] || fallback[0] || p;
+    });
+}
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const srcVal = source[key];
+        const tgtVal = target[key];
+        if (srcVal !== null &&
+            srcVal !== undefined &&
+            typeof srcVal === "object" &&
+            !Array.isArray(srcVal) &&
+            typeof tgtVal === "object" &&
+            !Array.isArray(tgtVal)) {
+            result[key] = deepMerge(tgtVal, srcVal);
+        }
+        else if (srcVal !== undefined) {
+            result[key] = srcVal;
+        }
+    }
+    return result;
+}
+/**
+ * JSON replacer that serializes RegExp objects as {__regex, source, flags}
+ * so they survive JSON.stringify/parse round-trips.
+ */
+function regexReplacer(_key, value) {
+    if (value instanceof RegExp) {
+        return { __regex: true, source: value.source, flags: value.flags };
+    }
+    return value;
+}
+/**
+ * JSON reviver that restores RegExp objects serialized by regexReplacer.
+ */
+function regexReviver(_key, value) {
+    if (value && typeof value === "object" && value.__regex === true) {
+        const { source, flags } = value;
+        try {
+            return new RegExp(source, flags);
+        }
+        catch {
+            return value;
+        }
+    }
+    return value;
+}
+/**
+ * Legacy npx `args` for LSP servers that predate the fixed invocation.
+ */
+const LEGACY_LSP_SERVER_ARGS = {
+    typescript: { args: ["typescript-language-server", "--stdio"], timeout: 30000 },
+    javascript: { args: ["typescript-language-server", "--stdio"], timeout: 30000 },
+    json: { args: ["vscode-json-languageserver", "--stdio"], timeout: 30000 },
+    html: { args: ["vscode-html-languageserver", "--stdio"], timeout: 60000 },
+    css: { args: ["vscode-css-languageserver", "--stdio"], timeout: 60000 },
+};
+/**
+ * Replace stale pre-0.41.1 LSP server invocations with current defaults.
+ */
+function normalizeLspServerArgs(config) {
+    const servers = config.lsp?.servers;
+    if (!servers)
+        return;
+    for (const [lang, legacy] of Object.entries(LEGACY_LSP_SERVER_ARGS)) {
+        const server = servers[lang];
+        const def = DEFAULT_LSP_CONFIG.servers[lang];
+        if (!server || server.command !== "npx" || !def)
+            continue;
+        const storedArgs = Array.isArray(server.args) ? server.args : null;
+        const isLegacy = storedArgs === null || JSON.stringify(storedArgs) === JSON.stringify(legacy.args);
+        if (isLegacy) {
+            server.args = def.args;
+            server.timeout = def.timeout;
+        }
+    }
+}
+function loadJSON(path) {
+    try {
+        if (existsSync(path)) {
+            return JSON.parse(readFileSync(path, "utf-8"), regexReviver);
+        }
+    }
+    catch {
+        /* ignore malformed files */
+    }
+    return null;
+}
+function applyEnvVars(config) {
+    const env = process.env;
+    const result = { ...config };
+    if (env.MMA_MODEL)
+        result.model = env.MMA_MODEL;
+    if (env.MMA_PROVIDER_TYPE)
+        result.provider = { ...result.provider, type: env.MMA_PROVIDER_TYPE };
+    if (env.MMA_PROVIDER_BASEURL)
+        result.provider = { ...result.provider, baseUrl: env.MMA_PROVIDER_BASEURL };
+    if (env.MMA_PROVIDER_APIKEY)
+        result.provider = { ...result.provider, apiKey: env.MMA_PROVIDER_APIKEY };
+    if (env.MMA_LOG_LEVEL)
+        result.logLevel = env.MMA_LOG_LEVEL;
+    if (env.MMA_LOCALE)
+        result.locale = env.MMA_LOCALE;
+    if (env.MMA_CONTEXT_WINDOW) {
+        const v = parseInt(env.MMA_CONTEXT_WINDOW, 10);
+        if (!isNaN(v))
+            result.contextWindow = v;
+    }
+    if (env.MMA_MAX_TOOL_ITERATIONS) {
+        const v = parseInt(env.MMA_MAX_TOOL_ITERATIONS, 10);
+        if (!isNaN(v))
+            result.maxToolIterations = v;
+    }
+    if (env.MMA_STUCK_THRESHOLD) {
+        const v = parseInt(env.MMA_STUCK_THRESHOLD, 10);
+        if (!isNaN(v))
+            result.stuckThreshold = v;
+    }
+    if (env.MMA_AUTO_PLAN)
+        result.autoPlan = env.MMA_AUTO_PLAN === "true";
+    if (env.MMA_MOE_ENABLED)
+        result.moe = { ...result.moe, enabled: env.MMA_MOE_ENABLED === "true" };
+    return result;
+}
+/**
+ * Load config from domain files (preferred) or legacy config.json (fallback).
+ *
+ * Pipeline:
+ *   1. DEFAULTS
+ *   2. deepMerge(legacy config.json)  — if exists
+ *   3. deepMerge(domain files)        — if exist, override legacy
+ *   4. deepMerge(project .mmrc)       — overrides everything
+ *   5. Post-load fixups (RegExp, LSP args)
+ *   6. Env vars
+ *   7. Decrypt
+ *
+ * On first run (no config.json, no domain files), auto-creates domain files.
+ */
+export function loadConfig(options) {
+    const globalPath = join(options.configDir, "config.json");
+    mkdirSync(options.configDir, { recursive: true });
+    // v1 → v2 migration check (reads config.json directly, before domain logic)
+    const detector = new MigrationDetector(options.configDir);
+    if (detector.needsMigration()) {
+        const backup = new BackupManager(options.configDir);
+        backup.backupConfig();
+        const summary = backup.getBackupSummary();
+        console.log(t("migration.detected", { summary }));
+        try {
+            unlinkSync(globalPath);
+        }
+        catch { }
+    }
+    let config = { ...DEFAULTS };
+    let legacyDetected = false;
+    // Step 1: legacy config.json (fallback)
+    const globalData = loadJSON(globalPath);
+    if (globalData) {
+        config = deepMerge(config, globalData);
+        legacyDetected = true;
+    }
+    // Step 2: domain files (override legacy)
+    const domainConfig = loadDomainFiles(options.configDir);
+    if (domainConfig) {
+        config = deepMerge(config, domainConfig);
+        legacyDetected = false;
+    }
+    // Step 3: first run — auto-create domain files instead of config.json
+    if (!globalData && !domainConfig) {
+        saveDomainFiles(config, options.configDir);
+    }
+    // Step 4: project .mmrc (overrides everything)
+    const projectData = loadJSON(options.projectConfigPath);
+    if (projectData) {
+        config = deepMerge(config, projectData);
+    }
+    // Step 5: post-load fixups — AFTER all merges
+    if (config.security?.contentScan?.dangerousPatterns) {
+        config.security.contentScan.dangerousPatterns = restoreDangerousPatterns(config.security.contentScan.dangerousPatterns, DEFAULT_SECURITY_CONFIG.contentScan.dangerousPatterns);
+    }
+    normalizeLspServerArgs(config);
+    // Step 6: env vars
+    config = applyEnvVars(config);
+    // Step 7: decrypt
+    try {
+        const encryptor = new ConfigEncryptor();
+        const decrypted = encryptor.decrypt(config);
+        for (const key of Object.keys(decrypted)) {
+            config[key] = decrypted[key];
+        }
+    }
+    catch (e) {
+        console.warn(t("config.decryption_warning", { error: e.message }));
+    }
+    return { config, legacyDetected };
+}
+export function validateConfig(config, allToolTags) {
+    const errors = validateExpertConfig(config, allToolTags);
+    const knownTags = new Set(allToolTags);
+    for (const tag of config.tools?.defaultTags ?? []) {
+        if (!knownTags.has(tag)) {
+            errors.push(`tools.defaultTags references unknown tag "${tag}". Known tags: ${Array.from(knownTags).join(", ")}`);
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`Config validation failed:\n${errors.join("\n")}`);
+    }
+}
+/**
+ * Save config to domain files (preferred) or legacy single file (fallback).
+ *
+ * @param config   Full AppConfig to save
+ * @param configPath  Legacy path (e.g. ~/.mma/config.json) — used when configDir is absent
+ * @param configDir  Optional config directory (e.g. ~/.mma). When provided, writes domain files.
+ */
+export function saveConfig(config, configPath, configDir) {
+    if (configDir) {
+        saveDomainFiles(config, configDir);
+        return;
+    }
+    // Legacy single-file write (backward compat for tests / edge cases)
+    const dir = dirname(configPath);
+    mkdirSync(dir, { recursive: true });
+    try {
+        const encryptor = new ConfigEncryptor();
+        const encryptedConfig = encryptor.encrypt({
+            ...config,
+        });
+        writeFileSync(configPath, JSON.stringify(encryptedConfig, regexReplacer, 2), "utf-8");
+    }
+    catch (e) {
+        console.warn(t("config.encryption_warning", { error: e.message }));
+        writeFileSync(configPath, JSON.stringify(config, regexReplacer, 2), "utf-8");
+    }
+}

package/dist/config/defaults.js

@@ -0,0 +1,141 @@
+import { DEFAULT_SECURITY_CONFIG } from "./security";
+import { DEFAULT_LSP_CONFIG } from "../modules/lsp/config";
+export const DEFAULTS = {
+    version: "2.0.0",
+    model: "qwen/qwen3.5-9b",
+    provider: {
+        type: "openai-compat",
+        baseUrl: "http://localhost:1234/v1",
+        apiKey: "not-needed",
+    },
+    orchestrator: {
+        model: undefined,
+        provider: undefined,
+    },
+    moe: {
+        enabled: false,
+    },
+    tools: {
+        defaultTags: ["file", "code"],
+        enableOnDemand: true,
+    },
+    experts: {
+        code: {
+            model: "qwen/qwen3.5-9b",
+            tool_tags: ["file", "code", "shell"],
+            max_attempts: 3,
+        },
+        research: {
+            model: "qwen/qwen3.5-9b",
+            tool_tags: ["research"],
+            max_attempts: 3,
+        },
+        browser: {
+            model: "qwen/qwen3.5-9b",
+            tool_tags: ["browser", "vision"],
+            max_attempts: 3,
+        },
+        vision: {
+            model: "qwen/qwen3.5-9b",
+            tool_tags: ["browser", "vision", "file"],
+            max_attempts: 2,
+        },
+    },
+    contextWindow: 32768,
+    contextBudget: {
+        systemPrompt: 0.1,
+        responseReserve: 0.15,
+        compactionThreshold: 0.75,
+    },
+    modelLoad: {
+        autoLoad: false,
+        flashAttention: true,
+        offloadKvCacheToGpu: true,
+    },
+    retry: {
+        maxRetries: 3,
+        baseDelay: 1000,
+        maxDelay: 30000,
+        maxStreamRetries: 2,
+        noDataTimeoutMs: 180000,
+    },
+    maxToolIterations: 1000,
+    stuckThreshold: 6,
+    autoPlan: true,
+    showReasoning: false,
+    logLevel: "info",
+    locale: "en",
+    session: {
+        autoSave: true,
+        maxSessions: 50,
+        isolateMemory: false,
+    },
+    browser: {
+        enabled: true,
+        headless: true,
+        maxElements: 30,
+        maxContentChars: 2500,
+        maxConsoleEntries: 40,
+        maxConsoleLineChars: 400,
+        viewportWidth: 1280,
+        viewportHeight: 720,
+        navigationTimeout: 15000,
+    },
+    webSearch: {
+        enabled: true,
+    },
+    errorWebSearch: {
+        enabled: true,
+        threshold: 5,
+        maxResults: 5,
+        maxQueryChars: 200,
+        maxSearchesPerSession: 3,
+        requestTimeoutMs: 10000,
+    },
+    pricing: {
+        enabled: true,
+        overrides: {},
+    },
+    ui: {
+        spinner: true,
+        toolStyle: "inline",
+        toolComments: true,
+        showContextStats: false,
+        showCompaction: true,
+    },
+    mcpServers: {
+        context7: {
+            name: "context7",
+            transport: "http",
+            url: "https://mcp.context7.com/mcp",
+            headers: {
+                CONTEXT7_API_KEY: process.env.CONTEXT7_API_KEY || "",
+            },
+            enabled: true,
+            timeout: 30000,
+        },
+    },
+    security: DEFAULT_SECURITY_CONFIG,
+    sessionIsolation: {
+        enabled: false,
+        isolatePlugins: true,
+        isolateTempFiles: true,
+    },
+    skills: {
+        budget: 0.15,
+    },
+    subagent: {
+        resultMode: "text",
+        maxSummaryChars: 2000,
+        artifactsDir: ".mma/artifacts",
+        stableSystemPrompt: true,
+        maxParallelChunkQueries: 4,
+    },
+    lsp: DEFAULT_LSP_CONFIG,
+    updater: {
+        enabled: true,
+        checkOnStart: true,
+        autoInstall: true,
+        intervalMs: 0,
+    },
+};

package/dist/config/domains.js

@@ -0,0 +1,179 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+/**
+ * Mapping: domain name → AppConfig keys that belong to it.
+ * Each domain becomes one JSON file in ~/.mma/config/<domain>.json.
+ */
+export const CONFIG_DOMAINS = {
+    core: [
+        "version",
+        "model",
+        "contextWindow",
+        "contextBudget",
+        "modelLoad",
+        "maxToolIterations",
+        "stuckThreshold",
+        "autoPlan",
+        "showReasoning",
+        "logLevel",
+        "locale",
+    ],
+    provider: ["provider", "orchestrator", "retry", "pricing"],
+    moe: ["moe", "experts"],
+    security: ["security"],
+    browser: ["browser"],
+    search: ["webSearch", "errorWebSearch"],
+    tools: ["tools", "subagent"],
+    session: ["session", "sessionIsolation"],
+    ui: ["ui"],
+    mcp: ["mcpServers"],
+    lsp: ["lsp"],
+    skills: ["skills"],
+    updater: ["updater"],
+};
+/**
+ * JSON replacer that serializes RegExp objects as {__regex, source, flags}
+ * so they survive JSON.stringify/parse round-trips.
+ */
+function regexReplacer(_key, value) {
+    if (value instanceof RegExp) {
+        return { __regex: true, source: value.source, flags: value.flags };
+    }
+    return value;
+}
+/**
+ * JSON reviver that restores RegExp objects serialized by regexReplacer.
+ */
+function regexReviver(_key, value) {
+    if (value &&
+        typeof value === "object" &&
+        value.__regex === true) {
+        const { source, flags } = value;
+        try {
+            return new RegExp(source, flags);
+        }
+        catch {
+            return value;
+        }
+    }
+    return value;
+}
+/**
+ * Deep merge two objects. Arrays and scalars in source replace target.
+ */
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const srcVal = source[key];
+        const tgtVal = target[key];
+        if (srcVal !== null &&
+            srcVal !== undefined &&
+            typeof srcVal === "object" &&
+            !Array.isArray(srcVal) &&
+            typeof tgtVal === "object" &&
+            !Array.isArray(tgtVal)) {
+            result[key] = deepMerge(tgtVal, srcVal);
+        }
+        else if (srcVal !== undefined) {
+            result[key] = srcVal;
+        }
+    }
+    return result;
+}
+/**
+ * Extract a domain subset from a full AppConfig.
+ */
+export function extractDomain(config, domain) {
+    const keys = CONFIG_DOMAINS[domain];
+    if (!keys)
+        return {};
+    const subset = {};
+    for (const key of keys) {
+        if (config[key] !== undefined) {
+            subset[key] = config[key];
+        }
+    }
+    return subset;
+}
+/**
+ * Get the file path for a domain config file.
+ */
+export function getDomainFilePath(configDir, domain) {
+    return join(configDir, "config", `${domain}.json`);
+}
+/**
+ * Check if domain files exist in config/ directory.
+ */
+export function hasDomainFiles(configDir) {
+    const configDirPath = join(configDir, "config");
+    if (!existsSync(configDirPath))
+        return false;
+    try {
+        const files = readdirSync(configDirPath);
+        return files.some((f) => f.endsWith(".json"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load all domain files from ~/.mma/config/ and merge into a partial AppConfig.
+ * Each file is parsed with regexReviver to restore RegExp objects.
+ * Returns null if no domain files exist.
+ */
+export function loadDomainFiles(configDir) {
+    const configDirPath = join(configDir, "config");
+    if (!existsSync(configDirPath))
+        return null;
+    let result = {};
+    let anyLoaded = false;
+    for (const domain of Object.keys(CONFIG_DOMAINS)) {
+        const filePath = getDomainFilePath(configDir, domain);
+        if (!existsSync(filePath))
+            continue;
+        try {
+            const raw = readFileSync(filePath, "utf-8");
+            const data = JSON.parse(raw, regexReviver);
+            result = deepMerge(result, data);
+            anyLoaded = true;
+        }
+        catch {
+            // Skip malformed domain files
+        }
+    }
+    return anyLoaded ? result : null;
+}
+/**
+ * Save a full AppConfig to domain files in ~/.mma/config/.
+ * Each domain's keys are extracted and written to config/<domain>.json.
+ * RegExp objects are serialized via regexReplacer.
+ */
+export function saveDomainFiles(config, configDir) {
+    const configDirPath = join(configDir, "config");
+    mkdirSync(configDirPath, { recursive: true });
+    for (const [domain, keys] of Object.entries(CONFIG_DOMAINS)) {
+        const subset = {};
+        let hasContent = false;
+        for (const key of keys) {
+            if (config[key] !== undefined) {
+                subset[key] = config[key];
+                hasContent = true;
+            }
+        }
+        if (!hasContent)
+            continue;
+        const filePath = getDomainFilePath(configDir, domain);
+        writeFileSync(filePath, JSON.stringify(subset, regexReplacer, 2), "utf-8");
+    }
+}
+/**
+ * Determine which domain a config key belongs to.
+ * Returns the domain name or null if not found.
+ */
+export function domainForKey(key) {
+    for (const [domain, keys] of Object.entries(CONFIG_DOMAINS)) {
+        if (keys.includes(key))
+            return domain;
+    }
+    return null;
+}

package/dist/config/experts.js

@@ -0,0 +1,15 @@
+export function getExpertConfig(config, tag) {
+    return config.experts?.[tag];
+}
+export function validateExpertConfig(config, allToolTags) {
+    const errors = [];
+    const knownTags = new Set(allToolTags);
+    for (const [name, expert] of Object.entries(config.experts || {})) {
+        for (const tag of expert.tool_tags) {
+            if (!knownTags.has(tag)) {
+                errors.push(`Expert "${name}" references unknown tool_tag "${tag}". Known tags: ${Array.from(knownTags).join(", ")}`);
+            }
+        }
+    }
+    return errors;
+}

package/dist/config/index.js

@@ -0,0 +1,4 @@
+export { DEFAULTS } from "./defaults";
+export { loadConfig, saveConfig, validateConfig, CONFIG_DIR, CONFIG_FILE, CONFIG_DOMAIN_DIR } from "./config";
+export { getExpertConfig, validateExpertConfig } from "./experts";
+export { CONFIG_DOMAINS, extractDomain, hasDomainFiles, loadDomainFiles, saveDomainFiles, getDomainFilePath, domainForKey, } from "./domains";