micro-models-agent 0.47.1 → 0.48.2

package/dist/modules/memory/store.js

@@ -0,0 +1,69 @@
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { MemorySearch } from "./search";
+const MEMORY_FILES = ["conventions", "decisions", "errors", "facts"];
+export class MemoryStore {
+    memoryDir;
+    constructor(memoryDir) {
+        this.memoryDir = memoryDir;
+        this.ensureDir();
+        for (const name of MEMORY_FILES) {
+            const path = join(this.memoryDir, `${name}.md`);
+            if (!existsSync(path)) {
+                writeFileSync(path, `# ${name.charAt(0).toUpperCase() + name.slice(1)}\n\n`, "utf-8");
+            }
+        }
+    }
+    ensureDir() {
+        if (!existsSync(this.memoryDir)) {
+            mkdirSync(this.memoryDir, { recursive: true });
+        }
+    }
+    read(name) {
+        const path = join(this.memoryDir, `${name}.md`);
+        if (!existsSync(path))
+            return "";
+        return readFileSync(path, "utf-8");
+    }
+    append(name, entry) {
+        const path = join(this.memoryDir, `${name}.md`);
+        const timestamp = new Date().toISOString().replace("T", " ").slice(0, 19);
+        const formatted = `- **${timestamp}** — ${entry}\n`;
+        appendFileSync(path, formatted, "utf-8");
+    }
+    search(query) {
+        const searchModule = new MemorySearch(this.memoryDir);
+        return searchModule.query(query);
+    }
+    prefsPath() {
+        return join(this.memoryDir, "preferences.json");
+    }
+    getPreferences() {
+        const path = this.prefsPath();
+        if (!existsSync(path))
+            return {};
+        try {
+            return JSON.parse(readFileSync(path, "utf-8"));
+        }
+        catch {
+            return {};
+        }
+    }
+    setPreference(key, value) {
+        const prefs = this.getPreferences();
+        prefs[key] = value;
+        writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
+    }
+    deletePreference(key) {
+        const prefs = this.getPreferences();
+        if (!(key in prefs))
+            return false;
+        delete prefs[key];
+        writeFileSync(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
+        return true;
+    }
+    appendRule(category, pattern, cause, solution) {
+        const entry = `**pattern:** ${pattern}\n  **cause:** ${cause}\n  **solution:** ${solution}`;
+        this.append(category, entry);
+    }
+}

package/dist/modules/pipelines/engine.js

@@ -0,0 +1,60 @@
+import { t } from "../../i18n/index";
+export class PipelineEngine {
+    stepStatus = new Map();
+    resolveDependencies(steps) {
+        const visited = new Set();
+        const inStack = new Set();
+        const order = [];
+        function visit(stepId, stepMap) {
+            if (inStack.has(stepId))
+                throw new Error(t("pipeline.circular", { stepId }));
+            if (visited.has(stepId))
+                return;
+            inStack.add(stepId);
+            const step = stepMap.get(stepId);
+            if (step?.depends_on) {
+                for (const dep of step.depends_on) {
+                    visit(dep, stepMap);
+                }
+            }
+            inStack.delete(stepId);
+            visited.add(stepId);
+            order.push(stepId);
+        }
+        const stepMap = new Map(steps.map((s) => [s.id, s]));
+        for (const step of steps) {
+            if (!visited.has(step.id)) {
+                visit(step.id, stepMap);
+            }
+        }
+        return order;
+    }
+    getReadySteps(steps, completed) {
+        return steps.filter((s) => {
+            if (completed.has(s.id))
+                return false;
+            if (this.stepStatus.get(s.id) === "running")
+                return false;
+            if (this.stepStatus.get(s.id) === "failed")
+                return false;
+            if (!s.depends_on || s.depends_on.length === 0)
+                return true;
+            return s.depends_on.every((d) => completed.has(d));
+        });
+    }
+    setStepStatus(stepId, status) {
+        this.stepStatus.set(stepId, status);
+    }
+    getStepStatus(stepId) {
+        return this.stepStatus.get(stepId) || "pending";
+    }
+    isComplete(stepIds) {
+        return stepIds.every((id) => {
+            const s = this.stepStatus.get(id);
+            return s === "done" || s === "skipped";
+        });
+    }
+    reset() {
+        this.stepStatus.clear();
+    }
+}

package/dist/modules/pipelines/index.js

@@ -0,0 +1,3 @@
+export { PipelineParser } from "./parser";
+export { PipelineEngine } from "./engine";
+export { TemplateEngine } from "./template";

package/dist/modules/pipelines/parser.js

@@ -0,0 +1,56 @@
+import { t } from "../../i18n/index";
+export class PipelineParser {
+    static parse(yaml) {
+        const lines = yaml.split("\n").filter((l) => l.trim());
+        const result = {};
+        let currentSection = null;
+        let currentSteps = [];
+        for (const line of lines) {
+            if (line.match(/^\w+:/) && !line.startsWith(" ") && !line.startsWith("  -")) {
+                const [key, ...valParts] = line.split(":");
+                const val = valParts.join(":").trim();
+                if (key === "steps") {
+                    currentSection = "steps";
+                }
+                else {
+                    result[key] = val;
+                    currentSection = null;
+                }
+            }
+            else if (currentSection === "steps") {
+                const stepMatch = line.match(/^\s+- id:\s*(\S+)/);
+                if (stepMatch) {
+                    currentSteps.push({ id: stepMatch[1] });
+                }
+                else if (currentSteps.length > 0) {
+                    const lastStep = currentSteps[currentSteps.length - 1];
+                    const kvMatch = line.match(/^\s+(\w+):\s*(.+)$/);
+                    if (kvMatch) {
+                        const key = kvMatch[1];
+                        let val = kvMatch[2].trim();
+                        if (val === "true")
+                            val = true;
+                        else if (val === "false")
+                            val = false;
+                        else if (val.startsWith("[") && val.endsWith("]")) {
+                            val = val
+                                .slice(1, -1)
+                                .split(",")
+                                .map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
+                        }
+                        lastStep[key] = val;
+                    }
+                }
+            }
+        }
+        if (!result.name || currentSteps.length === 0) {
+            throw new Error(t("pipeline.invalid"));
+        }
+        for (const step of currentSteps) {
+            if (!step.id || !step.agent || !step.prompt) {
+                throw new Error(t("pipeline.step_missing_fields", { step: JSON.stringify(step) }));
+            }
+        }
+        return { name: result.name, steps: currentSteps };
+    }
+}

package/dist/modules/pipelines/template.js

@@ -0,0 +1,14 @@
+export class TemplateEngine {
+    static render(template, params, stepOutputs) {
+        let result = template;
+        for (const [key, val] of Object.entries(params)) {
+            result = result.replace(new RegExp(`\\{${key}\\}`, "g"), val);
+        }
+        if (stepOutputs) {
+            result = result.replace(/\{\{steps\.(\w+)\.output\}\}/g, (_, stepId) => {
+                return stepOutputs[stepId]?.output || `{{steps.${stepId}.output}}`;
+            });
+        }
+        return result;
+    }
+}

package/dist/modules/plugins/builtin/lint-on-write.js

@@ -0,0 +1,231 @@
+import { spawn, execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { resolve, extname, join } from "path";
+import { platform } from "os";
+import { findProjectRoot } from "../../lsp/project-root";
+const TYPE_CHECK_DEBOUNCE_MS = 2000;
+// Per-file syntax checks are cached by (path, content hash): re-writing a file
+// with identical content skips the (expensive) check. Content changes → cache
+// miss → fresh check.
+const syntaxCache = 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);
+}
+let _winDecoder;
+function getWinDecoder() {
+    if (_winDecoder === undefined) {
+        if (platform() !== "win32") {
+            _winDecoder = null;
+        }
+        else {
+            try {
+                const cpOut = execSync("chcp.com", {
+                    encoding: "buffer",
+                    timeout: 2000,
+                    windowsHide: true,
+                }).toString("latin1");
+                const m = cpOut.match(/(\d+)/);
+                _winDecoder = m ? new TextDecoder("ibm" + m[1]) : null;
+            }
+            catch {
+                _winDecoder = null;
+            }
+        }
+    }
+    return _winDecoder ?? new TextDecoder("utf-8");
+}
+export class LintOnWritePlugin {
+    name = "lint-on-write";
+    priority = 10;
+    isBuiltin = true;
+    _checkPromise = null;
+    _checkTimestamp = 0;
+    async onAfterTool(ctx, call, result) {
+        if (call.name !== "write_file" && call.name !== "edit_file") {
+            return;
+        }
+        if (!result.success) {
+            return;
+        }
+        const path = String(call.arguments.path || "");
+        if (!path)
+            return;
+        const fullPath = resolve(ctx.baseDir, path);
+        if (!existsSync(fullPath))
+            return;
+        const ext = extname(fullPath);
+        const syntaxError = await this.checkSyntax(fullPath, ext, ctx.baseDir);
+        if (syntaxError) {
+            result.output += `\n\n[Syntax check failed]: ${syntaxError}`;
+            return;
+        }
+        await this.runProjectLint(ctx, result);
+        await this.runProjectTypeCheck(fullPath, ctx.baseDir, result);
+    }
+    async checkSyntax(filePath, ext, baseDir) {
+        if (ext === ".ts" || ext === ".tsx" || ext === ".cts" || ext === ".mts") {
+            // Syntax-only check via bun's parser (~200ms) instead of `npx tsc`
+            // (~3-5s per write). Full type errors are still surfaced by the
+            // debounced project typecheck below when a tsconfig exists.
+            let content = "";
+            try {
+                content = readFileSync(filePath, "utf-8");
+            }
+            catch {
+                return null;
+            }
+            const hash = contentHash(content);
+            const cached = syntaxCache.get(filePath);
+            if (cached && cached.hash === hash) {
+                return cached.error;
+            }
+            try {
+                await runAsync(`bun build --no-bundle --target=bun "${filePath}"`, baseDir, 10000);
+                syntaxCache.set(filePath, { hash, error: null });
+                return null;
+            }
+            catch (err) {
+                if (err.status === 127 ||
+                    err.message.includes("not found") ||
+                    err.message.includes("ENOENT")) {
+                    return null;
+                }
+                const stderr = err.stderr?.toString() || err.stdout?.toString() || "";
+                const firstError = stderr.split("\n").find((line) => line.trim()) || "TypeScript syntax error";
+                syntaxCache.set(filePath, { hash, error: firstError.trim() });
+                return firstError.trim();
+            }
+        }
+        if (ext === ".js" || ext === ".jsx" || ext === ".cjs" || ext === ".mjs") {
+            try {
+                await runAsync(`node --check "${filePath}"`, baseDir, 5000);
+                return null;
+            }
+            catch (err) {
+                const stderr = err.stderr?.toString() || "";
+                const firstError = stderr.split("\n").find((line) => line.trim()) || "JavaScript syntax error";
+                return firstError.trim();
+            }
+        }
+        return null;
+    }
+    async runProjectLint(ctx, result) {
+        try {
+            const packageJsonPath = join(ctx.baseDir, "package.json");
+            if (!existsSync(packageJsonPath)) {
+                return;
+            }
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            const lintScript = packageJson.scripts?.lint;
+            if (!lintScript) {
+                return;
+            }
+            ctx.logger.debug(`Running lint: ${lintScript}`);
+            await runAsync(lintScript, ctx.baseDir, 30_000);
+            ctx.logger.debug("Lint passed");
+        }
+        catch (err) {
+            const stderr = (err.stderr?.toString?.() || "").trim();
+            const stdout = (err.stdout?.toString?.() || "").trim();
+            const detail = (stderr || stdout || err.message).split("\n").filter(Boolean).slice(-5).join("\n");
+            ctx.logger.warn(`Lint failed: ${err.message}`);
+            result.output += `\n\n[Project lint failed]: ${detail}`;
+        }
+    }
+    async runProjectTypeCheck(filePath, baseDir, result) {
+        // Resolve the project root from the EDITED FILE, not the agent baseDir.
+        // In a nested layout (`baseDir/proj/tsconfig.json`) the old baseDir-based
+        // lookup silently skipped the typecheck on every write — the whole
+        // session then ran with zero type feedback (observed in ses_mst2r0r5).
+        const projectRoot = findProjectRoot(filePath, baseDir, ["tsconfig.json", "package.json"]);
+        const tsconfigPath = join(projectRoot, "tsconfig.json");
+        if (!existsSync(tsconfigPath)) {
+            return;
+        }
+        const now = Date.now();
+        if (this._checkPromise && now - this._checkTimestamp < TYPE_CHECK_DEBOUNCE_MS) {
+            const error = await this._checkPromise;
+            if (error) {
+                result.output += `\n\n[Project typecheck failed]: ${error}`;
+            }
+            return;
+        }
+        this._checkTimestamp = now;
+        this._checkPromise = this.runTscCheck(projectRoot);
+        const error = await this._checkPromise;
+        if (error) {
+            result.output += `\n\n[Project typecheck failed]: ${error}`;
+        }
+    }
+    async runTscCheck(baseDir) {
+        try {
+            await runAsync(`npx tsc --noEmit --skipLibCheck`, baseDir, 30000);
+            return null;
+        }
+        catch (err) {
+            if (err.status === 127 ||
+                err.message.includes("not found") ||
+                err.message.includes("ENOENT")) {
+                return null;
+            }
+            const stderr = err.stderr?.toString() || err.stdout?.toString() || "";
+            if (stderr.includes("error TS")) {
+                const firstError = stderr.split("\n").find((line) => line.includes("error TS")) ||
+                    "TypeScript type error";
+                return firstError.trim();
+            }
+            return null;
+        }
+    }
+}
+/**
+ * Run a command asynchronously (non-blocking event loop) and resolve when it
+ * exits. Rejects with captured stderr/stdout on non-zero exit or timeout.
+ */
+function runAsync(command, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const decoder = getWinDecoder();
+        child.stdout?.on("data", (d) => {
+            stdout += decoder.decode(d, { stream: true });
+        });
+        child.stderr?.on("data", (d) => {
+            stderr += decoder.decode(d, { stream: true });
+        });
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error(`Command timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            stdout += decoder.decode();
+            stderr += decoder.decode();
+            if (code === 0) {
+                resolve({ stdout, stderr });
+            }
+            else {
+                const err = new Error(`Command failed with exit code ${code}`);
+                err.stdout = stdout;
+                err.stderr = stderr;
+                err.status = code;
+                reject(err);
+            }
+        });
+    });
+}
+export const plugin = new LintOnWritePlugin();

package/dist/modules/plugins/builtin/notify.js

@@ -0,0 +1,9 @@
+export class NotifyPlugin {
+    name = "notify";
+    priority = 5;
+    isBuiltin = true;
+    onSessionEnd(ctx) {
+        ctx.logger.info("Session ended");
+    }
+}
+export const plugin = new NotifyPlugin();

package/dist/modules/plugins/index.js

@@ -0,0 +1 @@
+export { PluginManager } from "./manager";

package/dist/modules/plugins/loader.js

@@ -0,0 +1,70 @@
+import { readdirSync, existsSync, statSync } from "fs";
+import { join, basename } from "path";
+import { t } from "../../i18n/index";
+import { semverGt } from "../updater/checker";
+/**
+ * Entry file candidates for folder plugins. Looked up in order:
+ * `plugin.ts` > `plugin.js` > `index.ts` > `index.js`.
+ */
+const FOLDER_ENTRY_NAMES = ["plugin.ts", "plugin.js", "index.ts", "index.js"];
+export class PluginLoader {
+    loadFromDir(dirPath, pluginManager, logger, options) {
+        if (!existsSync(dirPath))
+            return;
+        const entries = readdirSync(dirPath).sort();
+        for (const entry of entries) {
+            const fullPath = join(dirPath, entry);
+            const stat = statSync(fullPath);
+            if (stat.isFile()) {
+                if (!entry.endsWith(".ts") && !entry.endsWith(".js"))
+                    continue;
+                this.tryLoad(fullPath, entry, pluginManager, logger, options);
+            }
+            else if (stat.isDirectory()) {
+                const entryFile = this.findEntryFile(fullPath);
+                if (entryFile) {
+                    this.tryLoad(entryFile, `${entry}/${basename(entryFile)}`, pluginManager, logger, options);
+                }
+            }
+        }
+    }
+    findEntryFile(dir) {
+        for (const name of FOLDER_ENTRY_NAMES) {
+            const candidate = join(dir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+        return null;
+    }
+    tryLoad(fullPath, label, pluginManager, logger, options) {
+        try {
+            const mod = require(fullPath);
+            const plugin = mod.default || mod.plugin;
+            if (plugin && plugin.name) {
+                if (plugin.minMmaVersion &&
+                    options?.mmaVersion &&
+                    semverGt(plugin.minMmaVersion, options.mmaVersion)) {
+                    logger?.warn(t("plugin.incompatible", {
+                        name: plugin.name,
+                        min: plugin.minMmaVersion,
+                        current: options.mmaVersion,
+                    }));
+                    return;
+                }
+                const result = pluginManager.register(plugin, options?.source);
+                if (result.status === "registered") {
+                    logger?.warn(t("plugin.loaded", { name: plugin.name }));
+                }
+                else if (result.status === "skipped_older") {
+                    logger?.warn(t("plugin.dedup_older", {
+                        name: plugin.name,
+                        version: plugin.version || "0.0.0",
+                    }));
+                }
+            }
+        }
+        catch (e) {
+            logger?.warn(t("plugin.skipped", { entry: label, message: e.message }));
+        }
+    }
+}