micro-models-agent 0.63.0 → 1.1.0

package/dist/tools/subagent.js

@@ -6,6 +6,7 @@ import { PluginManager } from "../modules/plugins/manager";
 import { logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 import { ArtifactStore } from "../modules/artifacts/store";
+import { ScopeDenialCollector, formatScopeRequest } from "./scope-request";
 /** Fixed system prompt (KV-cache friendly when stableSystemPrompt is on). */
 export const SUBAGENT_SYSTEM_PROMPT_TEMPLATE = `You are a sub-agent working on a specific task. You have your own context window and tool set.
 
@@ -24,6 +25,7 @@ export const subagentTool = {
     icon: "🤖",
     description: "Spawn an isolated sub-agent to work on a task independently. The sub-agent has its own context and executes autonomously. Use for parallel work or complex sub-tasks.",
     tags: ["code"],
+    timeoutMs: 180000,
     parameters: {
         type: "object",
         properties: {
@@ -84,9 +86,14 @@ export const subagentTool = {
         const securityConfig = ctx.sessionContext
             ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
             : ctx.config.security;
-        // Security check: limit recursion depth
+        // Security check: limit recursion depth. Read the depth from the SHARED
+        // executor ctx (which nested sub-agents actually see) — `ctx.recursionDepth`
+        // was captured once at bootstrap and never incremented, so the guard never
+        // fired and a sub-agent could spawn sub-agents unbounded.
+        const executor = ctx.toolExecutor;
+        const parentDepth = executor?.getRecursionDepth?.() ?? (ctx.recursionDepth ?? 0);
         const maxDepth = securityConfig?.maxRecursionDepth ?? 3;
-        const currentDepth = ctx.recursionDepth ?? 0;
+        const currentDepth = parentDepth;
         if (currentDepth >= maxDepth) {
             logSecurityBlock(ctx.sessionId, "bash_command", `Maximum recursion depth (${maxDepth}) exceeded`, task);
             return {
@@ -124,19 +131,38 @@ export const subagentTool = {
         try {
             const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
             const subPluginManager = new PluginManager();
+            // Deterministic scope-denial tracking: when the child's file tools are
+            // blocked by the scope guard, the denial is surfaced as a machine-readable
+            // <scope-request> block in the result (see MoE executor / Router).
+            const scopeCollector = new ScopeDenialCollector();
+            subPluginManager.register(scopeCollector.plugin, "builtin");
             const hallucinationDetector = new HallucinationDetector(ctx.baseDir, ctx.llmProvider);
             // Save/restore the shared executor scope so the sub-agent doesn't
             // permanently mutate the parent's scope.
             const parentScope = ctx.scope;
             ctx.toolExecutor.setScope(scope || { allowed_files: [], read_only_files: [] });
+            // Register cleanup so the executor restores scope on timeout/abort
+            // even when the agent's `finally` block never runs (abandoned promise).
+            ctx.cleanup = () => ctx.toolExecutor?.setScope(parentScope);
+            // Increment recursion depth on the shared executor ctx so NESTED
+            // sub-agents see the deeper level (and the guard above can fire).
+            ctx.recursionDepth = currentDepth + 1;
+            executor?.setRecursionDepth?.(currentDepth + 1);
             const systemPrompt = {
                 content: buildSubagentSystemPrompt(context, ctx.config.subagent?.stableSystemPrompt !== false),
                 priority: "critical",
                 essential: true,
                 estimatedTokens: 150,
             };
+            // MoE is a TOP-LEVEL orchestration mode: a sub-agent spawned by the
+            // subagent tool must always run the plain single-agent loop. Sharing the
+            // parent's config here made every MoE sub-agent re-enter runWithMoE —
+            // planning its own subtasks and spawning nested sub-agents recursively
+            // (bounded only by maxRecursionDepth), which hung execution for many
+            // minutes with zero progress events.
+            const subConfig = { ...ctx.config, moe: { ...ctx.config.moe, enabled: false } };
             const subDeps = {
-                config: ctx.config,
+                config: subConfig,
                 llmProvider: ctx.llmProvider,
                 toolExecutor: ctx.toolExecutor,
                 pluginManager: subPluginManager,
@@ -147,17 +173,24 @@ export const subagentTool = {
                 scope,
                 toolTags,
                 promptBlocks: [systemPrompt],
-                recursionDepth: currentDepth + 1, // Increment recursion depth for sub-agent
             };
-            const subAgent = new Agent(subDeps);
+            const subAgent = (ctx.agentFactory ?? ((d) => new Agent(d)))(subDeps);
             const fullTask = context ? `${task}\n\nContext: ${context}` : task;
             try {
                 const result = await subAgent.run(fullTask);
+                const pickUsage = () => result.promptTokens !== undefined || result.totalTokens !== undefined
+                    ? {
+                        promptTokens: result.promptTokens ?? 0,
+                        completionTokens: result.completionTokens ?? 0,
+                        totalTokens: result.totalTokens ?? 0,
+                    }
+                    : undefined;
                 if (!result.success) {
-                    return {
-                        success: false,
-                        output: `Sub-agent failed: ${result.error}\nPartial output: ${result.text}`,
-                    };
+                    let output = `Sub-agent failed: ${result.error}\nPartial output: ${result.text}`;
+                    const scopeReq = scopeCollector.toScopeRequest();
+                    if (scopeReq)
+                        output += `\n${formatScopeRequest(scopeReq)}`;
+                    return { success: false, output };
                 }
                 const resultMode = args.result_mode || ctx.config.subagent?.resultMode || "text";
                 if (resultMode === "file") {
@@ -176,17 +209,25 @@ export const subagentTool = {
                             iterations: String(result.iterationCount),
                             summary,
                         }),
+                        // Structured path so callers (MoE executor) don't parse the
+                        // localized `output` string.
+                        artifactPath: abs,
+                        usage: pickUsage(),
                     };
                 }
                 return {
                     success: true,
                     output: `Sub-agent completed:\n${result.text}\n\nIterations: ${result.iterationCount}`,
+                    usage: pickUsage(),
                 };
             }
             finally {
                 // Restore the parent's exact scope: undefined means "no restrictions"
                 // and must not become an empty scope (which denies everything).
                 ctx.toolExecutor.setScope(parentScope);
+                ctx.cleanup = undefined;
+                ctx.recursionDepth = currentDepth;
+                executor?.setRecursionDepth?.(currentDepth);
             }
         }
         catch (e) {

package/dist/tools/syntax-validator.js

@@ -0,0 +1,177 @@
+import { writeFileSync, existsSync, unlinkSync } from "fs";
+import { extname, dirname } from "path";
+import { spawn } from "child_process";
+const SYNTAX_CACHE = new Map();
+function contentHash(content) {
+    let h = 5381;
+    for (let i = 0; i < content.length; i++) {
+        h = ((h << 5) + h + content.charCodeAt(i)) | 0;
+    }
+    return String(h);
+}
+/**
+ * Run a command with timeout. Returns stdout/stderr on success, throws on failure.
+ */
+function runCommand(command, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout?.on("data", (d) => stdoutChunks.push(d));
+        child.stderr?.on("data", (d) => stderrChunks.push(d));
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error(`Syntax check timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+            const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+            if (code === 0) {
+                resolve({ stdout, stderr });
+            }
+            else {
+                const err = new Error(`Syntax check failed with exit code ${code}`);
+                err.stdout = stdout;
+                err.stderr = stderr;
+                err.status = code;
+                reject(err);
+            }
+        });
+    });
+}
+/**
+ * Supported file extensions for syntax validation.
+ */
+const TS_EXTENSIONS = new Set([".ts", ".tsx", ".cts", ".mts"]);
+const JS_EXTENSIONS = new Set([".js", ".jsx", ".cjs", ".mjs"]);
+const JSON_EXTENSIONS = new Set([".json"]);
+/**
+ * Pre-validate file syntax BEFORE writing to disk.
+ * Returns { valid: true } if syntax is OK or language is not supported.
+ * Returns { valid: false, error: "..." } if syntax is invalid.
+ *
+ * For TypeScript/JavaScript: writes to a temp file and runs the compiler.
+ * For JSON: parses the content directly.
+ */
+export async function preValidateSyntax(filePath, content, baseDir) {
+    const ext = extname(filePath).toLowerCase();
+    // JSON — parse directly
+    if (JSON_EXTENSIONS.has(ext)) {
+        try {
+            JSON.parse(content);
+            return { valid: true };
+        }
+        catch (e) {
+            return { valid: false, error: e.message };
+        }
+    }
+    // TypeScript — syntax check via bun build
+    if (TS_EXTENSIONS.has(ext)) {
+        const hash = contentHash(content);
+        const cached = SYNTAX_CACHE.get(filePath);
+        if (cached && cached.hash === hash) {
+            return cached.error ? { valid: false, error: cached.error } : { valid: true };
+        }
+        const tmpFile = `${filePath}.tmp${ext}`;
+        try {
+            writeFileSync(tmpFile, content, "utf-8");
+            await runCommand(`bun build --no-bundle --target=bun "${tmpFile}"`, dirname(filePath), 5000);
+            SYNTAX_CACHE.set(filePath, { hash, error: null });
+            return { valid: true };
+        }
+        catch (err) {
+            const stderr = err.stderr || err.stdout || "";
+            const firstError = stderr.split("\n").find((line) => line.trim()) || "TypeScript syntax error";
+            const error = firstError.trim();
+            SYNTAX_CACHE.set(filePath, { hash, error });
+            return { valid: false, error };
+        }
+        finally {
+            try {
+                if (existsSync(tmpFile))
+                    unlinkSync(tmpFile);
+            }
+            catch {
+                /* ignore cleanup errors */
+            }
+        }
+    }
+    // JavaScript — syntax check via node --check
+    if (JS_EXTENSIONS.has(ext)) {
+        const hash = contentHash(content);
+        const cached = SYNTAX_CACHE.get(filePath);
+        if (cached && cached.hash === hash) {
+            return cached.error ? { valid: false, error: cached.error } : { valid: true };
+        }
+        const tmpFile = `${filePath}.tmp${ext}`;
+        try {
+            writeFileSync(tmpFile, content, "utf-8");
+            await runCommand(`node --check "${tmpFile}"`, dirname(filePath), 5000);
+            SYNTAX_CACHE.set(filePath, { hash, error: null });
+            return { valid: true };
+        }
+        catch (err) {
+            const stderr = err.stderr || "";
+            const firstError = stderr.split("\n").find((line) => line.trim()) || "JavaScript syntax error";
+            const error = firstError.trim();
+            SYNTAX_CACHE.set(filePath, { hash, error });
+            return { valid: false, error };
+        }
+        finally {
+            try {
+                if (existsSync(tmpFile))
+                    unlinkSync(tmpFile);
+            }
+            catch {
+                /* ignore cleanup errors */
+            }
+        }
+    }
+    // Unsupported extension — skip validation
+    return { valid: true };
+}
+/**
+ * Detect import/export conflicts in TypeScript/JavaScript code.
+ * Returns array of conflicting names.
+ */
+export function detectImportConflicts(content) {
+    const conflicts = [];
+    // Extract all named imports: import { foo, bar as baz } from '...'
+    const importRegex = /import\s+(?:type\s+)?\{([^}]+)\}\s+from/g;
+    const exportRegex = /export\s+(?:function|class|const|let|var|type|interface|async\s+function)\s+(\w+)/g;
+    const imports = new Set();
+    const exports = new Set();
+    let match;
+    while ((match = importRegex.exec(content))) {
+        const names = match[1]
+            .split(",")
+            .map((s) => s.trim())
+            .map((s) => {
+            // Handle "foo as bar" — take the local name (foo)
+            const asMatch = s.match(/^(\w+)\s+as\s+\w+$/);
+            return asMatch ? asMatch[1] : s;
+        })
+            .filter((s) => /^\w+$/.test(s));
+        names.forEach((n) => imports.add(n));
+    }
+    while ((match = exportRegex.exec(content))) {
+        exports.add(match[1]);
+    }
+    // Check for conflicts
+    for (const name of imports) {
+        if (exports.has(name)) {
+            conflicts.push(name);
+        }
+    }
+    return conflicts;
+}

package/dist/tools/user-input.js

@@ -1,5 +1,6 @@
 import * as readline from "readline";
 import { t } from "../i18n/index";
+import { getDefaultChannel } from "../output/index";
 /** Index returned by askChoice when the user picks the "custom answer" entry. */
 export const CUSTOM_INDEX = -1;
 /**
@@ -77,14 +78,15 @@ export async function askChoice(question, options, opts = {}) {
     const customEntry = options.length; // index of the custom entry, if enabled
     const rl = createRl();
     try {
-        console.log(formatMenu(question, options, opts));
+        const channel = getDefaultChannel();
+        channel.writeLine(formatMenu(question, options, opts));
         for (;;) {
             const answer = await promptLine(rl, choicePrompt(entryCount, multiple));
             const parsed = parseSelection(answer, entryCount, multiple);
             if (parsed) {
                 return parsed.map((i) => (opts.allowCustom && i === customEntry ? CUSTOM_INDEX : i));
             }
-            console.log(t("tool.user_input.invalid"));
+            channel.writeLine(t("tool.user_input.invalid"));
         }
     }
     finally {
@@ -95,23 +97,28 @@ export async function askChoice(question, options, opts = {}) {
  * High-level helper used by the question tool.
  * - No options: free-text input, returns [text] or [] when empty.
  * - With options: returns selected labels; custom entry resolves to typed text.
+ *
+ * When `io` is provided (REPL), all prompting goes through it so the tool can
+ * borrow the terminal from the input editor. Without it (headless/non-REPL)
+ * the module-level readline helpers above remain the fallback.
  */
-export async function askUser(question, opts = {}) {
+export async function askUser(question, opts = {}, io) {
     const header = [opts.progress, opts.header].filter(Boolean).join(" — ");
     const text = header ? `${header}\n${question}` : question;
     if (!opts.options || opts.options.length === 0) {
-        const answer = await askText(text);
+        const answer = io ? await io.askText(text) : await askText(text);
         return answer ? [answer] : [];
     }
     const allowCustom = opts.custom ?? true;
-    const indexes = await askChoice(text, opts.options, {
-        multiple: opts.multiple,
-        allowCustom,
-    });
+    const indexes = io
+        ? await io.askChoice(text, opts.options, { multiple: opts.multiple, allowCustom })
+        : await askChoice(text, opts.options, { multiple: opts.multiple, allowCustom });
     const labels = [];
     for (const idx of indexes) {
         if (idx === CUSTOM_INDEX) {
-            const custom = await askText(t("tool.user_input.custom_prompt"));
+            const custom = io
+                ? await io.askText(t("tool.user_input.custom_prompt"))
+                : await askText(t("tool.user_input.custom_prompt"));
             if (custom)
                 labels.push(custom);
         }

package/dist/tools/write-file.js

@@ -7,6 +7,7 @@ import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 import { generateDiff, generateNewFileDiff } from "../ui/diff";
 import { safeResolvePath } from "./path-utils";
+import { preValidateSyntax, detectImportConflicts } from "./syntax-validator";
 export const writeFileTool = {
     name: "write_file",
     icon: "📝",
@@ -66,6 +67,16 @@ export const writeFileTool = {
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
         }
+        // Pre-validate syntax BEFORE writing — prevents "file written" + syntax error loop
+        const validation = await preValidateSyntax(resolved, content, ctx.baseDir);
+        if (!validation.valid) {
+            return {
+                success: false,
+                output: t("file.syntax_error", { path, error: validation.error || "Unknown syntax error" }),
+            };
+        }
+        // Detect import/export conflicts — warning only (code may be valid)
+        const conflicts = detectImportConflicts(content);
         const fileExists = existsSync(resolved);
         let oldContent = "";
         if (fileExists) {
@@ -77,6 +88,11 @@ export const writeFileTool = {
         ctx.fileOperationsCount = currentCount + 1;
         // Log successful file write
         logFileWrite(ctx.sessionId, path, true, `File ${fileExists ? "updated" : "created"}`);
-        return { success: true, output: t("file.written", { path }), diff };
+        // Add conflict warning to output if any
+        let output = t("file.written", { path });
+        if (conflicts.length > 0) {
+            output += `\n[WARNING] Import/export conflicts: ${conflicts.join(", ")}`;
+        }
+        return { success: true, output, diff };
     },
 };

package/dist/ui/diff.js

@@ -1,6 +1,10 @@
 import { pc } from "./colors";
 const CONTEXT_LINES = 3;
 const MAX_DIFF_LINES = 100;
+// LCS is O(m*n) in time and memory — cap the DP input so a huge edit_file
+// can't allocate hundreds of MB. Beyond the cap, diff degrades to a
+// "changed N lines" summary instead of a full LCS.
+const MAX_LCS_INPUT_LINES = 2000;
 function computeLCS(oldLines, newLines) {
     const m = oldLines.length;
     const n = newLines.length;
@@ -127,6 +131,12 @@ export function generateDiff(oldContent, newContent) {
         return "";
     const oldLines = oldContent.split("\n");
     const newLines = newContent.split("\n");
+    if (oldLines.length > MAX_LCS_INPUT_LINES ||
+        newLines.length > MAX_LCS_INPUT_LINES) {
+        // Too large for the O(m*n) DP — show a bounded summary instead of
+        // allocating an m*n matrix.
+        return pc.dim(`  ... (file too large for line diff: ${oldLines.length} -> ${newLines.length} lines)`);
+    }
     const diff = buildDiff(oldLines, newLines);
     if (diff.length === 0)
         return "";