micro-models-agent 0.52.0 → 0.52.1

package/dist/config/config.js

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

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

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

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

@@ -1,4 +0,0 @@
-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";