micro-models-agent 0.51.1 → 0.51.2

package/dist/modules/plugins/manager.js

@@ -1,217 +0,0 @@
-import { semverGt } from "../updater/checker";
-export class PluginManager {
-    plugins = [];
-    /**
-     * Register a plugin. Plugins with the same `name` are deduplicated — the
-     * higher `version` wins (unversioned plugins count as "0.0.0"). The loser is
-     * discarded; `skipped_older` lets the caller warn about the dropped copy.
-     */
-    register(plugin, source) {
-        if (source)
-            plugin.source = source;
-        const existing = this.plugins.find((p) => p.name === plugin.name);
-        if (existing) {
-            if (semverGt(plugin.version || "0.0.0", existing.version || "0.0.0")) {
-                this.plugins = this.plugins.filter((p) => p.name !== plugin.name);
-                this.plugins.push(plugin);
-                this.sort();
-                return { status: "registered" };
-            }
-            return { status: "skipped_older", existing };
-        }
-        this.plugins.push(plugin);
-        this.sort();
-        return { status: "registered" };
-    }
-    sort() {
-        this.plugins.sort((a, b) => (b.priority || 0) - (a.priority || 0));
-    }
-    getAllPlugins() {
-        return [...this.plugins];
-    }
-    /** Detailed plugin list (name, version, source) for REPL / CLI display. */
-    getPluginInfos() {
-        return [...this.plugins].map((plugin) => ({ plugin, source: plugin.source }));
-    }
-    /** Find a registered plugin by name, or null. */
-    getPlugin(name) {
-        return this.plugins.find((p) => p.name === name) ?? null;
-    }
-    runOnBuildPrompt() {
-        return this.plugins.map((p) => {
-            try {
-                return p.onBuildPrompt?.() ?? null;
-            }
-            catch {
-                return null;
-            }
-        });
-    }
-    async runOnBeforeTool(ctx, call) {
-        for (const plugin of this.plugins) {
-            if (plugin.onBeforeTool) {
-                try {
-                    const result = await plugin.onBeforeTool(ctx, call);
-                    if (result === false)
-                        return false;
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-        return true;
-    }
-    async runOnAfterTool(ctx, call, result) {
-        for (const plugin of this.plugins) {
-            if (plugin.onAfterTool) {
-                try {
-                    await plugin.onAfterTool(ctx, call, result);
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-    }
-    async runOnError(ctx, error) {
-        for (const plugin of this.plugins) {
-            if (plugin.onError) {
-                try {
-                    await plugin.onError(ctx, error);
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-    }
-    runOnSessionStart(ctx) {
-        for (const plugin of this.plugins) {
-            if (plugin.onSessionStart) {
-                try {
-                    plugin.onSessionStart(ctx);
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-    }
-    runOnBeforeThink(ctx) {
-        for (const plugin of this.plugins) {
-            if (plugin.onBeforeThink) {
-                try {
-                    plugin.onBeforeThink(ctx);
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-    }
-    runOnAfterThink(ctx, response) {
-        for (const plugin of this.plugins) {
-            if (plugin.onAfterThink) {
-                try {
-                    plugin.onAfterThink(ctx, response);
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-    }
-    runOnSessionEnd(ctx) {
-        for (const plugin of this.plugins) {
-            if (plugin.onSessionEnd) {
-                try {
-                    plugin.onSessionEnd(ctx);
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-    }
-    runOnToolCall(ctx) {
-        for (const plugin of this.plugins) {
-            if (plugin.onToolCall) {
-                try {
-                    plugin.onToolCall(ctx);
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-    }
-    runOnPhase(ctx, phase) {
-        for (const plugin of this.plugins) {
-            if (plugin.onPhase) {
-                try {
-                    plugin.onPhase(ctx, phase);
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-    }
-    runOnToolStart(ctx, call) {
-        for (const plugin of this.plugins) {
-            if (plugin.onToolStart) {
-                try {
-                    plugin.onToolStart(ctx, call);
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-    }
-    runOnToolEnd(ctx, call, result, durationMs) {
-        for (const plugin of this.plugins) {
-            if (plugin.onToolEnd) {
-                try {
-                    plugin.onToolEnd(ctx, call, result, durationMs);
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-    }
-    /** Pipe a text chunk through plugin transforms; returns the (possibly replaced) chunk. */
-    runOnText(ctx, chunk) {
-        for (const plugin of this.plugins) {
-            if (plugin.onText) {
-                try {
-                    const out = plugin.onText(ctx, chunk);
-                    if (typeof out === "string")
-                        chunk = out;
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-        return chunk;
-    }
-    /** Pipe a meta chunk through plugin transforms; returns the (possibly replaced) chunk. */
-    runOnMeta(ctx, chunk) {
-        for (const plugin of this.plugins) {
-            if (plugin.onMeta) {
-                try {
-                    const out = plugin.onMeta(ctx, chunk);
-                    if (typeof out === "string")
-                        chunk = out;
-                }
-                catch {
-                    /* error isolation */
-                }
-            }
-        }
-        return chunk;
-    }
-}

package/dist/modules/plugins/types.js

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

package/dist/modules/processes/detect.js

@@ -1,34 +0,0 @@
-/**
- * Heuristic detection of long-running (server/watch) commands.
- *
- * The explicit `background: true` bash parameter always wins; this list is a
- * convenience so dev servers don't block the agent. It only inspects the raw
- * shell command (a technical process-type decision, not task classification).
- */
-const LONG_RUNNING_PATTERNS = [
-    /\b(npm|pnpm|yarn|bun|npx)\s+(run\s+)?(dev|start|serve|preview|watch|server)\b/i,
-    /\b(deno|node)\s+.*\b(run\s+)?(dev|serve|watch|server)\b/i,
-    /(^|\s)--watch\b/i,
-    /(^|\s)-w\b/i,
-    /\bnodemon\b/i,
-    /\btsx watch\b/i,
-    /\b(ts-node|tsc)\s+.*--watch\b/i,
-    /\bvite(?!\s+(build|create))\b/i,
-    /\bwebpack(-dev-server|\s+serve)\b/i,
-    /\bastro dev\b/i,
-    /\bnext (dev|start)\b/i,
-    /\bnuxt (dev|start)\b/i,
-    /\bsvelte-kit (dev|preview)\b/i,
-    /\bgatsby develop\b/i,
-    /\bdocker(-compose)?\s+.*\bup\b/i,
-    /\buvicorn\b|\bgunicorn\b/i,
-    /\bpython\s+-m\s+http\.server\b/i,
-    /\bflask run\b/i,
-    /\bphp artisan serve\b/i,
-    /\brails (server|s)\b/i,
-    /\bvitest watch\b/i,
-    /\bjest --watch\b/i,
-];
-export function isLongRunningCommand(command) {
-    return LONG_RUNNING_PATTERNS.some((pattern) => pattern.test(command));
-}

package/dist/modules/processes/index.js

@@ -1,2 +0,0 @@
-export { registerKillable, unregisterKillable, killByCallId } from "./runner";
-export { processRegistry } from "./registry";

package/dist/modules/processes/registry.js

@@ -1,327 +0,0 @@
-import { spawn, spawnSync } from "child_process";
-import { platform } from "os";
-const MAX_LOG_LINES = 2000;
-const MAX_KEPT_PROCESSES = 20;
-let seq = 0;
-/** OEM decoder (Russian CP866 / active code page) — cached after first use. */
-let oemDecoder;
-function getOemDecoder() {
-    if (oemDecoder !== undefined)
-        return oemDecoder;
-    oemDecoder = null;
-    try {
-        const cpOut = spawnSync("chcp.com", {
-            encoding: "buffer",
-            timeout: 2000,
-            windowsHide: true,
-        }).stdout;
-        const m = cpOut ? cpOut.toString("latin1").match(/(\d+)/) : null;
-        if (m) {
-            try {
-                oemDecoder = new TextDecoder("ibm" + m[1]);
-            }
-            catch {
-                oemDecoder = null;
-            }
-        }
-    }
-    catch {
-        /* ignore */
-    }
-    if (!oemDecoder) {
-        try {
-            oemDecoder = new TextDecoder("ibm866");
-        }
-        catch {
-            oemDecoder = null;
-        }
-    }
-    return oemDecoder;
-}
-/**
- * Decode one complete line of output to UTF-8.
- *
- * Modern tools (Bun, Node, npm, git) write UTF-8 into the pipe regardless of
- * the console code page, while built-in cmd.exe commands (echo, type, dir)
- * emit the OEM code page (CP866 on Russian Windows). Try strict UTF-8 first;
- * fall back to the OEM decoder when the bytes are not valid UTF-8.
- */
-function decodeLineToUtf8(buf) {
-    try {
-        return new TextDecoder("utf-8", { fatal: true }).decode(buf);
-    }
-    catch {
-        /* not valid UTF-8 → OEM code page output */
-    }
-    const oem = getOemDecoder();
-    if (oem) {
-        try {
-            return oem.decode(buf);
-        }
-        catch {
-            /* unknown encoding — latin1 fallback */
-        }
-    }
-    return buf.toString("latin1");
-}
-/** Synchronous pause without blocking the event loop (via Atomics.wait). */
-function sleepSync(ms) {
-    try {
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-    }
-    catch {
-        /* ignore */
-    }
-}
-function taskkillPid(pid) {
-    try {
-        spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
-            windowsHide: true,
-            stdio: "ignore",
-            timeout: 5000,
-        });
-    }
-    catch {
-        /* already dead */
-    }
-}
-/**
- * Kill a spawned tree on Windows.
- *
- * `taskkill /T` has a race: when cmd.exe is killed, a child (node) that is
- * still starting up can survive as an orphan because it was never attached to
- * the tree at kill time. A single pass misses it. Running taskkill twice with
- * a settle gap catches those late starters on the second pass — the second
- * tree walk sees the child that was still being created during the first one.
- * This is much cheaper than enumerating processes (wmic/PowerShell), which
- * slows every kill down to seconds under parallel load.
- */
-export function killTree(child) {
-    const pid = child.pid;
-    if (!pid)
-        return;
-    if (platform() === "win32") {
-        taskkillPid(pid);
-        sleepSync(150);
-        taskkillPid(pid);
-        return;
-    }
-    try {
-        process.kill(-pid, "SIGTERM");
-    }
-    catch {
-        try {
-            child.kill("SIGKILL");
-        }
-        catch {
-            /* already dead */
-        }
-    }
-}
-class ProcessRegistry {
-    procs = new Map();
-    children = new Map();
-    exitWaiters = new Map();
-    /**
-     * Start a command. The returned entry buffers output and reports status; a
-     * call may check `waitForExit(id)` to learn when (if ever) it finishes.
-     */
-    start(command, cwd, sessionId) {
-        const id = `proc_${Date.now()}_${++seq}`;
-        const entry = {
-            id,
-            pid: 0,
-            command,
-            cwd,
-            sessionId,
-            status: "running",
-            exitCode: null,
-            startedAt: new Date().toISOString(),
-            log: [],
-        };
-        this.trimOldEntries();
-        this.procs.set(id, entry);
-        let child;
-        try {
-            child = spawn(command, {
-                cwd,
-                shell: true,
-                windowsHide: true,
-                detached: platform() !== "win32",
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        }
-        catch (e) {
-            entry.status = "killed";
-            entry.spawnError = e?.message || String(e);
-            entry.log.push(`[process error] ${entry.spawnError}`);
-            return entry;
-        }
-        this.children.set(id, child);
-        entry.pid = child.pid ?? 0;
-        let buf = "";
-        let byteBuf = Buffer.alloc(0);
-        const isWin = platform() === "win32";
-        const unixDecoder = new TextDecoder("utf-8");
-        const pushLine = (line) => {
-            if (entry.log.length >= MAX_LOG_LINES) {
-                entry.log.shift();
-            }
-            entry.log.push(line);
-        };
-        const append = (chunk) => {
-            if (!isWin) {
-                const decoded = unixDecoder.decode(chunk, { stream: true });
-                buf += decoded;
-                const lines = buf.split(/\r?\n/);
-                buf = lines.pop() ?? "";
-                for (const line of lines) {
-                    pushLine(line);
-                }
-                return;
-            }
-            // Windows: buffer raw bytes and decode per line. Modern tools (Bun, Node,
-            // npm, git) write UTF-8 into the pipe regardless of the console code
-            // page; cmd.exe builtins (echo, type, dir) emit the OEM code page. Pick
-            // the right decoding per line so Russian text survives either way.
-            byteBuf = byteBuf.length ? Buffer.concat([byteBuf, chunk]) : Buffer.from(chunk);
-            let nl;
-            while ((nl = byteBuf.indexOf(0x0a)) !== -1) {
-                const raw = byteBuf.subarray(0, nl);
-                byteBuf = byteBuf.subarray(nl + 1);
-                pushLine(decodeLineToUtf8(raw).replace(/\r$/, ""));
-            }
-        };
-        const flush = () => {
-            if (!isWin) {
-                buf += unixDecoder.decode();
-                if (buf) {
-                    pushLine(buf);
-                    buf = "";
-                }
-                return;
-            }
-            if (byteBuf.length) {
-                pushLine(decodeLineToUtf8(byteBuf));
-                byteBuf = Buffer.alloc(0);
-            }
-        };
-        const resolveExit = () => {
-            this.exitWaiters.get(id)?.resolve();
-        };
-        child.stdout?.on("data", append);
-        child.stderr?.on("data", append);
-        child.on("error", (err) => {
-            if (entry.status === "running") {
-                entry.status = "killed";
-            }
-            entry.spawnError = err.message;
-            // Write directly to the log, not through `append`: a failed spawn often
-            // never emits `close`, so the buffered line would never be flushed and
-            // the log would be empty (observed: "records a spawn error" test).
-            pushLine(`[process error] ${err.message}`);
-            resolveExit();
-        });
-        child.on("close", (code) => {
-            flush();
-            if (entry.status === "running") {
-                entry.status = "exited";
-            }
-            entry.exitCode = code;
-            this.children.delete(id);
-            resolveExit();
-        });
-        let resolve;
-        const promise = new Promise((r) => {
-            resolve = r;
-        });
-        this.exitWaiters.set(id, { promise, resolve });
-        return entry;
-    }
-    list(sessionId) {
-        const all = Array.from(this.procs.values());
-        if (!sessionId)
-            return all;
-        return all.filter((p) => p.sessionId === sessionId);
-    }
-    get(id) {
-        return this.procs.get(id);
-    }
-    getLog(id, tail) {
-        const entry = this.procs.get(id);
-        if (!entry)
-            return "";
-        const lines = tail && tail > 0 ? entry.log.slice(-tail) : entry.log;
-        return lines.join("\n");
-    }
-    /** Kill a background process tree. Returns false when not found. */
-    kill(id) {
-        const entry = this.procs.get(id);
-        if (!entry)
-            return false;
-        if (entry.status === "running") {
-            entry.status = "killed";
-            const child = this.children.get(id);
-            if (child) {
-                killTree(child);
-            }
-        }
-        return true;
-    }
-    /** Kill every managed background process (used on agent shutdown). */
-    killAll(sessionId) {
-        const targets = this.list(sessionId);
-        for (const entry of targets) {
-            this.kill(entry.id);
-        }
-        return targets.length;
-    }
-    /**
-     * Resolve `true` when the process exits (or fails to spawn) within
-     * `timeoutMs`, otherwise `false` (still running → a background process).
-     */
-    waitForExit(id, timeoutMs) {
-        const entry = this.procs.get(id);
-        const waiter = this.exitWaiters.get(id);
-        if (!entry || entry.status !== "running" || !waiter) {
-            return Promise.resolve(true);
-        }
-        return new Promise((resolve) => {
-            const timer = setTimeout(() => resolve(false), timeoutMs);
-            waiter.promise.then(() => {
-                clearTimeout(timer);
-                resolve(true);
-            });
-        });
-    }
-    /**
-     * Remove a finished entry (foreground results do not linger). A still-running
-     * entry is killed first so nothing is orphaned.
-     */
-    remove(id) {
-        const entry = this.procs.get(id);
-        if (!entry)
-            return false;
-        if (entry.status === "running") {
-            const child = this.children.get(id);
-            if (child) {
-                killTree(child);
-            }
-            entry.status = "killed";
-        }
-        this.procs.delete(id);
-        this.children.delete(id);
-        this.exitWaiters.delete(id);
-        return true;
-    }
-    trimOldEntries() {
-        if (this.procs.size < MAX_KEPT_PROCESSES)
-            return;
-        const sorted = Array.from(this.procs.values()).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
-        const toRemove = sorted.slice(0, sorted.length - MAX_KEPT_PROCESSES + 1);
-        for (const entry of toRemove) {
-            this.remove(entry.id);
-        }
-    }
-}
-export const processRegistry = new ProcessRegistry();

package/dist/modules/processes/runner.js

@@ -1,23 +0,0 @@
-const activeChildren = new Map();
-/** Register a kill callback for a tool call id (executor timeout/abort). */
-export function registerKillable(callId, kill) {
-    activeChildren.set(callId, { kill });
-}
-/** Unregister a tool call's kill callback once its handler finished. */
-export function unregisterKillable(callId) {
-    activeChildren.delete(callId);
-}
-/** Invoke (and drop) the kill callback registered for `callId`. */
-export function killByCallId(callId) {
-    const entry = activeChildren.get(callId);
-    if (!entry)
-        return false;
-    activeChildren.delete(callId);
-    try {
-        entry.kill();
-    }
-    catch {
-        /* already dead */
-    }
-    return true;
-}

package/dist/modules/registry.js

@@ -1,47 +0,0 @@
-export class ModuleRegistry {
-    modules = new Map();
-    register(mod) {
-        this.modules.set(mod.name, mod);
-    }
-    get(name) {
-        return this.modules.get(name);
-    }
-    listModules() {
-        return Array.from(this.modules.keys()).sort();
-    }
-    collectPromptBlocks(exclude = []) {
-        const blocks = [];
-        for (const [name, mod] of this.modules) {
-            if (exclude.includes(name))
-                continue;
-            if (mod.getSystemPromptBlock) {
-                const block = mod.getSystemPromptBlock();
-                if (block)
-                    blocks.push(block);
-            }
-        }
-        return blocks;
-    }
-    collectToolDefinitions() {
-        const tools = [];
-        for (const mod of this.modules.values()) {
-            if (mod.getToolDefinitions) {
-                const defs = mod.getToolDefinitions();
-                if (defs)
-                    tools.push(...defs);
-            }
-        }
-        return tools;
-    }
-    collectPlugins() {
-        const plugins = [];
-        for (const mod of this.modules.values()) {
-            if (mod.getPlugin) {
-                const plugin = mod.getPlugin();
-                if (plugin)
-                    plugins.push(plugin);
-            }
-        }
-        return plugins;
-    }
-}