micro-models-agent 0.13.1 → 0.13.3

package/dist/cli/commands.js

@@ -6,11 +6,12 @@ import { t } from "../i18n/index";
 import { join } from "path";
 import { homedir } from "os";
 import { createSecurityCommand } from "./security-commands";
+import { version } from "../../package.json";
 export function createProgram() {
     const program = new Command()
         .name("mma")
         .description(t("cli.description"))
-        .version("0.4.0")
+        .version(version)
         .option("--no-agents-md", t("cli.no_agents_md"))
         .option("-d, --dir <path>", t("cli.dir"))
         .option("-e, --exit-on-complete", t("cli.exit_on_complete"))

package/dist/cli/repl.js

@@ -43,6 +43,7 @@ export class Repl {
     commands = new Map();
     completer = new Completer();
     running = false;
+    agentRunning = false;
     agent;
     config;
     sessionManager;
@@ -609,6 +610,15 @@ export class Repl {
         let inMultiLine = false;
         this.rl.on("line", async (line) => {
             const trimmed = line.trim();
+            if (this.agentRunning) {
+                if (trimmed) {
+                    this.history.push(trimmed);
+                    if (this.history.length > this.maxHistory) {
+                        this.history = this.history.slice(-this.maxHistory);
+                    }
+                }
+                return;
+            }
             if (trimmed) {
                 this.history.push(trimmed);
                 if (this.history.length > this.maxHistory) {
@@ -692,29 +702,41 @@ export class Repl {
         return false;
     }
     async runAgent(input) {
-        process.stdout.write("\n" + pc.green(t("repl.agent")));
-        const renderer = new Renderer({ spinner: this.config.ui?.spinner ?? true });
-        const result = await this.agent.run(input, (c) => renderer.text(c), (m) => renderer.meta(m), (ev) => {
-            if (ev.type === "start") {
-                renderer.toolStart(ev.tool, ev.args);
-            }
-            else {
-                renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error);
-            }
-        }, (phase) => {
-            if (phase === "thinking") {
-                renderer.thinkingStart();
+        if (this.agentRunning)
+            return;
+        this.agentRunning = true;
+        this.rl.pause();
+        try {
+            process.stdout.write("\n" + pc.green(t("repl.agent")));
+            const renderer = new Renderer({ spinner: this.config.ui?.spinner ?? true });
+            const result = await this.agent.run(input, (c) => renderer.text(c), (m) => renderer.meta(m), (ev) => {
+                if (ev.type === "start") {
+                    renderer.toolStart(ev.tool, ev.args);
+                }
+                else {
+                    renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error);
+                }
+            }, (phase) => {
+                if (phase === "thinking") {
+                    renderer.thinkingStart();
+                }
+                else {
+                    renderer.thinkingEnd();
+                }
+            });
+            renderer.flush();
+            process.stdout.write("\n");
+            if (!result.success) {
+                console.error(pc.red(`${t("error.prefix")}${result.error}`));
             }
-            else {
-                renderer.thinkingEnd();
+            this.showContextBar(result);
+        }
+        finally {
+            this.agentRunning = false;
+            if (this.running) {
+                this.rl.resume();
             }
-        });
-        renderer.flush();
-        process.stdout.write("\n");
-        if (!result.success) {
-            console.error(pc.red(`${t("error.prefix")}${result.error}`));
         }
-        this.showContextBar(result);
     }
     registerCommand(cmd) {
         this.commands.set(cmd.name, cmd);

package/dist/config/config.js

@@ -7,6 +7,13 @@ import { MigrationDetector } from '../migration/detect';
 import { BackupManager } from '../migration/backup';
 import { validateExpertConfig } from './experts';
 import { ConfigEncryptor } from '../modules/security/encryption';
+/**
+ * When the user's config version is older than this, force-overwrite
+ * the security bash settings with the current defaults.
+ * This ensures critical security changes (like operator allowlists)
+ * are applied even if the user has a saved config.
+ */
+const FORCE_SECURITY_UPDATE_VERSION = '2.1.0';
 /**
  * Restore RegExp instances in dangerousPatterns that were serialized as {}
  * (pre-0.8.0 configs) or as {__regex, source, flags} (new format).
@@ -115,6 +122,39 @@ function applyEnvVars(config) {
         result.moe = { ...result.moe, enabled: env.MMA_MOE_ENABLED === 'true' };
     return result;
 }
+/**
+ * Force-update security settings when upgrading from an older version.
+ * This overrides user config for critical security fields that must
+ * match the current code defaults (e.g. dangerousOperators).
+ */
+function forceSecurityUpdate(config) {
+    const userVersion = config.version || '0.0.0';
+    if (userVersion >= FORCE_SECURITY_UPDATE_VERSION)
+        return config;
+    // Force-overwrite bash security with current defaults
+    const security = config.security || {};
+    const userBash = security.bash || {};
+    security.bash = {
+        ...DEFAULT_SECURITY_CONFIG.bash,
+        // Keep user's custom blacklist additions, but ensure defaults are present
+        blacklist: [...new Set([
+                ...DEFAULT_SECURITY_CONFIG.bash.blacklist,
+                ...(userBash.blacklist || []),
+            ])],
+        whitelist: userBash.whitelist || DEFAULT_SECURITY_CONFIG.bash.whitelist,
+        dangerousFlags: [...new Set([
+                ...DEFAULT_SECURITY_CONFIG.bash.dangerousFlags,
+                ...(userBash.dangerousFlags || []),
+            ])],
+        // dangerousOperators: ALWAYS use defaults — user overrides are dangerous
+        dangerousOperators: [...DEFAULT_SECURITY_CONFIG.bash.dangerousOperators],
+        blockDangerousFlags: DEFAULT_SECURITY_CONFIG.bash.blockDangerousFlags,
+        logCommands: DEFAULT_SECURITY_CONFIG.bash.logCommands,
+    };
+    config.security = security;
+    console.log(t('migration.security_updated', { from: userVersion, to: FORCE_SECURITY_UPDATE_VERSION }));
+    return config;
+}
 export function loadConfig(options) {
     const globalPath = join(options.configDir, 'config.json');
     mkdirSync(options.configDir, { recursive: true });
@@ -146,6 +186,8 @@ export function loadConfig(options) {
     if (config.security?.contentScan?.dangerousPatterns) {
         config.security.contentScan.dangerousPatterns = restoreDangerousPatterns(config.security.contentScan.dangerousPatterns, DEFAULT_SECURITY_CONFIG.contentScan.dangerousPatterns);
     }
+    // Force-update security settings when upgrading from older version
+    config = forceSecurityUpdate(config);
     config = applyEnvVars(config);
     // Decrypt sensitive fields in the loaded config
     try {

package/dist/config/defaults.js

@@ -76,7 +76,7 @@ export const DEFAULTS = {
             transport: "http",
             url: "https://mcp.context7.com/mcp",
             headers: {
-                CONTEXT7_API_KEY: "ctx7sk-f3dd1f44-bc3a-4f6b-94c0-87cacb6c084b",
+                CONTEXT7_API_KEY: process.env.CONTEXT7_API_KEY || "",
             },
             enabled: true,
             timeout: 30000,

package/dist/config/security.js

@@ -65,7 +65,7 @@ export const DEFAULT_SECURITY_CONFIG = {
             "--no-confirm",
         ],
         // Dangerous operators that are always blocked
-        dangerousOperators: [">", ">>", "2>", "2>>", "|", "&&", "||", ";", "&", "`"],
+        dangerousOperators: [">", ">>", "2>", "2>>", "&", "`"],
     },
     paths: {
         // Glob patterns for paths that are always denied

package/dist/core/agent-moe.js

@@ -0,0 +1,98 @@
+import { OrchestratorClient } from "../llm/orchestrator";
+import { validatePlan, applyAutoFixes, } from "../modules/execution/plan-validator";
+import { MoEExecutor } from "../modules/execution/moe-executor";
+import { StepVerifier } from "../modules/execution/verifier";
+/**
+ * Execute the MoE (Mixture of Experts) path: plan → validate → execute → verify.
+ * Returns a fallback signal when MoE cannot proceed so the caller can fall
+ * back to the single-agent loop.
+ */
+export async function runWithMoE(deps, input, fallback, opts = {}) {
+    const { config, llmProvider, logger, toolExecutor, baseDir } = deps;
+    const { onMeta, onPhase } = opts;
+    const orchestrator = new OrchestratorClient({
+        model: config.orchestrator.model,
+        provider: config.orchestrator.provider,
+    }, llmProvider);
+    if (!orchestrator.isEnabled()) {
+        logger.debug("MoE enabled but no orchestrator model configured — falling back to single-agent");
+        return fallback();
+    }
+    onMeta?.("🤖 Planning with MoE mode...\n");
+    onPhase?.("thinking");
+    const planResult = await orchestrator.plan(input);
+    onPhase?.("done");
+    if ("error" in planResult) {
+        logger.warn(`MoE plan failed: ${planResult.error} — falling back to single-agent`);
+        return fallback();
+    }
+    const { plan } = planResult;
+    onMeta?.(`📋 Plan created: "${plan.title}" (${plan.subtasks.length} subtasks)\n`);
+    const validation = validatePlan(plan, config);
+    if (!validation.valid) {
+        const applied = applyAutoFixes(plan, validation.autoFixes);
+        const retry = validatePlan(applied, config);
+        if (!retry.valid) {
+            logger.warn(`MoE plan validation failed: ${retry.errors.join("; ")} — falling back to single-agent`);
+            onMeta?.(`⚠️ Plan validation failed. Falling back to single-agent mode.\n`);
+            return fallback();
+        }
+        Object.assign(plan, applied);
+        onMeta?.(`🔧 Auto-fixed ${validation.autoFixes.length} plan issues.\n`);
+    }
+    const moeDeps = {
+        config,
+        toolRegistry: toolExecutor.getRegistry(),
+        toolExecutor,
+        llmProvider,
+        logger,
+        baseDir,
+    };
+    const executor = new MoEExecutor(moeDeps);
+    onMeta?.(`⚙️ Executing ${plan.subtasks.length} subtasks...\n`);
+    const planResults = await executor.executePlan(plan);
+    onMeta?.(`✅ Execution complete: ${planResults.results.filter((r) => r.success).length}/${planResults.results.length} succeeded\n`);
+    const verifier = new StepVerifier(baseDir);
+    const knownTags = [
+        "file",
+        "code",
+        "shell",
+        "research",
+        "browser",
+        "vision",
+        "core",
+    ];
+    const verification = await verifier.verifyMoEManifest(plan, config, knownTags);
+    onPhase?.("thinking");
+    const verifyResult = await orchestrator.verifyAndMerge({
+        plan,
+        results: planResults.results.map((r) => ({
+            subtaskId: r.subtaskId,
+            success: r.success,
+            summary: r.summary,
+            result: r.result,
+            error: r.error,
+        })),
+        verifierErrors: verification.errors,
+        verifierWarnings: verification.warnings,
+    });
+    onPhase?.("done");
+    const outputLines = [`## MoE Execution Results\n`];
+    for (const r of planResults.results) {
+        const icon = r.success ? "✅" : "❌";
+        outputLines.push(`${icon} **${r.subtaskId}**: ${r.summary} (${r.durationMs}ms)`);
+    }
+    outputLines.push("");
+    if (verifyResult.type === "final") {
+        outputLines.push(`**Result:** ${verifyResult.finalAnswer || "Complete"}`);
+    }
+    else {
+        outputLines.push(`**Re-plan requested:** ${verifyResult.explanation || ""}`);
+    }
+    const failedCount = planResults.results.filter((r) => !r.success).length;
+    return {
+        success: failedCount === 0 && verification.success,
+        text: outputLines.join("\n"),
+        iterationCount: planResults.results.length,
+    };
+}