micro-models-agent 0.61.0 → 0.62.0

package/dist/core/environment.js

@@ -0,0 +1,199 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { spawnSync } from "child_process";
+import { createRequire } from "module";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { arch, homedir, hostname, platform, release } from "os";
+import { env } from "process";
+import { readMmaVersion } from "./version";
+import { sanitizeUrl } from "../modules/security/network-validator";
+import { t } from "../i18n/index";
+/** Tools probed for availability on PATH (real executables only — no .cmd shims). */
+const TOOL_CHECKS = ["bun", "node", "git", "python"];
+function readEngineRequirement() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [join(here, "..", "..", "package.json"), join(here, "..", "package.json")];
+    for (const p of candidates) {
+        if (!existsSync(p))
+            continue;
+        try {
+            const raw = JSON.parse(readFileSync(p, "utf8"));
+            if (raw.engines?.node)
+                return String(raw.engines.node);
+        }
+        catch {
+            // Broken package.json — fall through
+        }
+    }
+    return ">=20";
+}
+/** Numeric tuple comparison: does `version` meet the minimum in `requirement` (e.g. `>=20`)? */
+export function satisfiesMinimum(version, requirement) {
+    const minMatch = requirement.match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (!minMatch)
+        return true;
+    const min = [
+        parseInt(minMatch[1], 10),
+        minMatch[2] ? parseInt(minMatch[2], 10) : 0,
+        minMatch[3] ? parseInt(minMatch[3], 10) : 0,
+    ];
+    const parts = version.replace(/^v/i, "").split(".");
+    const got = [
+        parts[0] ? parseInt(parts[0], 10) : 0,
+        parts[1] ? parseInt(parts[1], 10) : 0,
+        parts[2] ? parseInt(parts[2], 10) : 0,
+    ];
+    for (let i = 0; i < 3; i++) {
+        if (got[i] > min[i])
+            return true;
+        if (got[i] < min[i])
+            return false;
+    }
+    return true;
+}
+export function detectRuntime() {
+    const bun = globalThis.Bun;
+    const isBun = typeof bun !== "undefined" && typeof bun?.version !== "undefined";
+    const engine = readEngineRequirement();
+    const runtime = isBun ? "bun" : "node";
+    const runtimeVersion = isBun ? String(bun.version) : process.version;
+    return {
+        runtime,
+        runtimeVersion,
+        nodeVersion: process.version,
+        engine,
+        // engines.node applies to the Node runtime. Bun satisfies it through its
+        // embedded Node (process.version) — never compare the Bun version itself
+        // against a Node requirement (Bun 1.x would always look "too old").
+        engineOk: satisfiesMinimum(process.version, engine),
+    };
+}
+function toolVersion(cmd) {
+    try {
+        const res = spawnSync(cmd, ["--version"], {
+            encoding: "utf8",
+            timeout: 3000,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (res.error || res.status !== 0)
+            return "missing";
+        const out = ((res.stdout || "") + (res.stderr || "")).trim();
+        return out.split(/\r?\n/)[0].slice(0, 40) || "ok";
+    }
+    catch {
+        return "missing";
+    }
+}
+/** Where Playwright keeps downloaded browser binaries (env override wins). */
+export function playwrightBrowsersDir() {
+    if (process.env.PLAYWRIGHT_BROWSERS_PATH)
+        return process.env.PLAYWRIGHT_BROWSERS_PATH;
+    return process.platform === "win32"
+        ? join(homedir(), "AppData", "Local", "ms-playwright")
+        : join(homedir(), ".cache", "ms-playwright");
+}
+/** Playwright package presence/version + whether browser binaries are downloaded. */
+export function playwrightInfo() {
+    let installed = false;
+    let version = "";
+    const browsersDir = playwrightBrowsersDir();
+    try {
+        // Rule #12: resolve from disk at runtime — works in both src/ and dist/
+        // layouts, and under both Bun and Node (the bridge uses createRequire too).
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve("playwright/package.json");
+        installed = existsSync(pkgPath);
+        version = JSON.parse(readFileSync(pkgPath, "utf8")).version || "";
+    }
+    catch {
+        installed = false;
+    }
+    let browsersInstalled = false;
+    try {
+        if (existsSync(browsersDir)) {
+            browsersInstalled = readdirSync(browsersDir).some((d) => /chrom/i.test(d));
+        }
+    }
+    catch {
+        browsersInstalled = false;
+    }
+    return { installed, version, browsersDir, browsersInstalled };
+}
+/** Pure requirements check — produces warnings from a report (no side effects). */
+export function checkEnvironmentRequirements(report) {
+    const warnings = [];
+    if (report.runtime.runtime === "node") {
+        warnings.push(t("env.runtime_node", { version: report.runtime.nodeVersion }));
+    }
+    if (!report.runtime.engineOk) {
+        warnings.push(t("env.runtime_old", {
+            version: report.runtime.nodeVersion,
+            engine: report.runtime.engine,
+        }));
+    }
+    if (report.tools.bun === "missing") {
+        warnings.push(t("env.tool_missing", { tool: "bun" }));
+    }
+    if (report.tools.git === "missing") {
+        warnings.push(t("env.tool_missing", { tool: "git" }));
+    }
+    if (report.features.browser && report.playwright) {
+        if (!report.playwright.installed) {
+            warnings.push(t("env.playwright_missing"));
+        }
+        else if (!report.playwright.browsersInstalled) {
+            warnings.push(t("env.playwright_browsers_missing", { dir: report.playwright.browsersDir }));
+        }
+    }
+    return warnings;
+}
+export function collectEnvironment(opts) {
+    const runtime = detectRuntime();
+    const tools = {};
+    if (opts.scanTools) {
+        for (const tool of TOOL_CHECKS)
+            tools[tool] = toolVersion(tool);
+    }
+    const provider = opts.config
+        ? {
+            model: opts.config.model,
+            baseUrl: sanitizeUrl(opts.config.provider?.baseUrl || ""),
+            contextWindow: opts.config.contextWindow,
+            retry: {
+                maxRetries: opts.config.retry?.maxRetries ?? 0,
+                baseDelay: opts.config.retry?.baseDelay ?? 0,
+                maxDelay: opts.config.retry?.maxDelay ?? 0,
+                maxStreamRetries: opts.config.retry?.maxStreamRetries ?? 0,
+                noDataTimeoutMs: opts.config.retry?.noDataTimeoutMs ?? 0,
+            },
+        }
+        : null;
+    const report = {
+        ts: new Date().toISOString(),
+        mmaVersion: readMmaVersion(),
+        runtime,
+        os: {
+            platform: platform(),
+            arch: arch(),
+            release: release(),
+            hostname: hostname(),
+            shell: env.SHELL || env.ComSpec || "unknown",
+            home: homedir(),
+            cwd: process.cwd(),
+        },
+        paths: { configDir: opts.configDir, baseDir: opts.baseDir || process.cwd() },
+        tools,
+        provider,
+        features: { browser: Boolean(opts.config?.browser?.enabled) },
+        playwright: playwrightInfo(),
+        warnings: [],
+    };
+    report.warnings = checkEnvironmentRequirements(report);
+    return report;
+}
+/** Compact human line + full structured report into the JSONL log. */
+export function logEnvironment(report, logger) {
+    logger.info(`Environment: ${report.os.platform} ${report.os.arch} | ${report.runtime.runtime} ${report.runtime.runtimeVersion} (node ${report.runtime.nodeVersion}) | mma ${report.mmaVersion} | ${report.provider?.model ?? "no provider"}`);
+    logger.logStructured("environment", report);
+}

package/dist/core/index.js

@@ -0,0 +1,2 @@
+export { PromptBuilder } from "./prompt-builder";
+export { Agent } from "./agent";

package/dist/core/prompt-builder.js

@@ -0,0 +1,76 @@
+const PRIORITY_ORDER = {
+    critical: 0,
+    high: 1,
+    normal: 2,
+    low: 3,
+};
+function blockLabel(content) {
+    const firstLine = content.split("\n")[0].trim();
+    return firstLine.length > 70 ? firstLine.slice(0, 67) + "..." : firstLine;
+}
+export class PromptBuilder {
+    blocks = [];
+    budget;
+    constructor(budget) {
+        this.budget = budget;
+    }
+    addBlock(block) {
+        this.blocks.push(block);
+    }
+    addBlocks(blocks) {
+        for (const b of blocks) {
+            this.blocks.push(b);
+        }
+    }
+    build() {
+        const essential = [];
+        const nonEssential = [];
+        for (const block of this.blocks) {
+            if (block.essential) {
+                essential.push(block);
+            }
+            else {
+                nonEssential.push(block);
+            }
+        }
+        nonEssential.sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
+        let usedTokens = 0;
+        const included = [];
+        const excluded = [];
+        const blocks = [];
+        for (const block of essential) {
+            included.push(block.content);
+            usedTokens += block.estimatedTokens;
+            blocks.push({
+                label: blockLabel(block.content),
+                priority: block.priority,
+                essential: true,
+                tokens: block.estimatedTokens,
+                included: true,
+            });
+        }
+        for (const block of nonEssential) {
+            const tokens = block.estimatedTokens;
+            const fits = usedTokens + tokens <= this.budget;
+            if (fits) {
+                included.push(block.content);
+                usedTokens += tokens;
+            }
+            else {
+                excluded.push(block.content);
+            }
+            blocks.push({
+                label: blockLabel(block.content),
+                priority: block.priority,
+                essential: false,
+                tokens,
+                included: fits,
+            });
+        }
+        return {
+            prompt: included.join("\n\n"),
+            excluded,
+            blocks,
+        };
+    }
+}

package/dist/core/session-logger.js

@@ -0,0 +1,251 @@
+import { setAuditSessionDir } from "../modules/security/audit-log";
+import { sanitizeLogMessage } from "../modules/security/data-sanitizer";
+import { join } from "path";
+import { readFileSync, existsSync } from "fs";
+/**
+ * Thin wrapper around SessionManager that eliminates repetitive
+ * `if (sessionManager)` + `new Date().toISOString()` boilerplate
+ * from the agent loop.
+ *
+ * When constructed, it configures the app logger and audit log to write into
+ * the session directory (instead of global ~/.mma/logs/).
+ */
+export class SessionLogger {
+    session;
+    getCaller;
+    logger;
+    constructor(session, logger, getCaller) {
+        this.session = session;
+        this.getCaller = getCaller;
+        this.logger = logger;
+        this.bindSessionDir();
+    }
+    bindSessionDir() {
+        const meta = this.session?.getActiveMeta();
+        if (!meta)
+            return;
+        const dir = this.session.getSessionDirectory(meta.id);
+        if (this.logger) {
+            this.logger.setSessionDir(dir);
+            this.logger.initSessionLog(meta.id);
+        }
+        setAuditSessionDir(dir);
+    }
+    get active() {
+        return !!this.session?.getActive();
+    }
+    logSystem(content) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "system",
+            content,
+        });
+    }
+    logUser(content) {
+        const sanitized = sanitizeLogMessage(content);
+        this.session?.appendMessage({
+            role: "user",
+            content: sanitized,
+            timestamp: new Date().toISOString(),
+        });
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "user",
+            content: sanitized,
+        });
+    }
+    logAssistant(content, reasoning, toolCalls, iteration) {
+        const caller = this.getCaller?.();
+        if (reasoning) {
+            this.session?.appendLog({
+                ts: new Date().toISOString(),
+                type: "reasoning",
+                content: reasoning,
+                iteration,
+                provider: caller?.provider,
+                model: caller?.model,
+            });
+        }
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "assistant",
+            content,
+            ...(toolCalls
+                ? {
+                    tool_calls: toolCalls.map((tc) => ({
+                        id: tc.id,
+                        name: tc.name,
+                        arguments: tc.arguments,
+                    })),
+                }
+                : {}),
+            iteration,
+            provider: caller?.provider,
+            model: caller?.model,
+        });
+    }
+    saveAssistantMessage(content) {
+        const caller = this.getCaller?.();
+        this.session?.appendMessage({
+            role: "assistant",
+            content: content.slice(0, 500),
+            timestamp: new Date().toISOString(),
+            provider: caller?.provider,
+            model: caller?.model,
+        });
+    }
+    logToolDefs(toolCount, toolNames, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "tool_defs",
+            toolCount,
+            toolNames,
+            iteration,
+        });
+    }
+    logToolCall(call, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "tool_call",
+            tool: call.name,
+            tool_call_id: call.id,
+            args: JSON.parse(sanitizeLogMessage(JSON.stringify(call.arguments))),
+            iteration,
+        });
+    }
+    logToolResult(call, result, duration, iteration) {
+        const caller = this.getCaller?.();
+        this.session?.appendMessage({
+            role: "tool",
+            content: sanitizeLogMessage(result.output.slice(0, 500)),
+            name: call.name,
+            timestamp: new Date().toISOString(),
+            provider: caller?.provider,
+            model: caller?.model,
+        });
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "tool_result",
+            tool: call.name,
+            tool_call_id: call.id,
+            success: result.success,
+            content: sanitizeLogMessage(result.output.slice(0, 1000)),
+            diff: result.diff,
+            duration,
+            iteration,
+            provider: caller?.provider,
+            model: caller?.model,
+        });
+    }
+    logCompaction(info) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "compaction",
+            content: `${info.reason}, iteration ${info.iteration}`,
+            iteration: info.iteration,
+            reason: info.reason,
+            tokensBefore: info.tokensBefore,
+            tokensAfter: info.tokensAfter,
+            qualityBefore: info.qualityBefore,
+            qualityAfter: info.qualityAfter,
+            messagesBefore: info.messagesBefore,
+            messagesAfter: info.messagesAfter,
+            removedTurns: info.removedTurns,
+            keptTurns: info.keptTurns,
+            summary: info.summary,
+        });
+    }
+    logContext(info) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "context",
+            content: info.kind === "start"
+                ? "context snapshot at session start"
+                : `context at iteration ${info.iteration}`,
+            iteration: info.iteration,
+            provider: info.provider,
+            model: info.model,
+            window: info.window,
+            systemBudget: info.systemBudget,
+            reserveBudget: info.reserveBudget,
+            historyBudget: info.historyBudget,
+            systemTokens: info.systemTokens,
+            toolTokens: info.toolTokens,
+            contextTokens: info.tokens,
+            quality: info.quality,
+            messageCount: info.messageCount,
+            compactionCount: info.compactionCount,
+            iterationsSinceCompaction: info.iterationsSinceCompaction,
+            blocks: info.blocks,
+        });
+    }
+    logLlmUsage(iteration, usage) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "llm_usage",
+            iteration,
+            provider: usage.provider,
+            model: usage.model,
+            promptTokens: usage.promptTokens,
+            completionTokens: usage.completionTokens,
+            totalTokens: usage.totalTokens,
+            source: usage.source,
+            durationMs: usage.durationMs,
+        });
+    }
+    logError(message) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "error",
+            content: message,
+        });
+    }
+    logAudit(summary, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "audit",
+            content: summary,
+            iteration,
+        });
+    }
+    logPlan(event, detail, iteration) {
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "plan",
+            content: detail,
+            tool: event,
+            ...(iteration !== undefined ? { iteration } : {}),
+        });
+    }
+    /**
+     * Log session startup diagnostics: environment, LSP probe, plugins, skills.
+     * Should be the FIRST entry in session.jsonl so the file is self-describing.
+     * Skips if a session_start entry already exists (e.g. logged by REPL).
+     */
+    logSessionStart(data) {
+        // Skip if session_start already logged (REPL may have logged it with LSP probe)
+        const meta = this.session?.getActiveMeta();
+        if (meta) {
+            const logPath = join(this.session.getSessionDirectory(meta.id), "session.jsonl");
+            try {
+                if (existsSync(logPath)) {
+                    const content = readFileSync(logPath, "utf-8");
+                    if (content.includes('"type":"session_start"'))
+                        return;
+                }
+            }
+            catch {
+                // File read error — proceed to write
+            }
+        }
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "session_start",
+            content: "session started",
+            environment: data.environment,
+            lspProbe: data.lspProbe,
+            plugins: data.plugins,
+            skills: data.skills,
+        });
+    }
+}

package/dist/core/types.js

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

package/dist/core/version.js

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+/**
+ * Read the MMA version from package.json at runtime (never a static import —
+ * bundlers inline a stale value at build time, see design rule #12).
+ */
+export function readMmaVersion() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [join(here, "..", "..", "package.json"), join(here, "..", "package.json")];
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            try {
+                const raw = JSON.parse(readFileSync(p, "utf8"));
+                if (raw.version)
+                    return raw.version;
+            }
+            catch {
+                // Broken package.json — fall through to the next candidate
+            }
+        }
+    }
+    return "0.0.0";
+}
+/** Legacy alias — use readMmaVersion(). */
+export const readVersion = readMmaVersion;

package/dist/core/workspace.js

@@ -0,0 +1,76 @@
+import { existsSync, readdirSync } from "fs";
+import { resolve, isAbsolute, join } from "path";
+/** Files/dirs that mark a directory as a project root. */
+const PROJECT_MANIFESTS = [
+    "package.json",
+    "bun.lockb",
+    "bun.lock",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "go.mod",
+    "Cargo.toml",
+    "pyproject.toml",
+    "requirements.txt",
+    "Gemfile",
+    "composer.json",
+];
+/** Immediate subdirectories that are never candidate project roots. */
+const SKIP_DIRS = new Set(["node_modules", "dist", ".git", ".hg", ".svn"]);
+const subdirCache = new Map();
+function scanSubdirs(baseDir) {
+    const cached = subdirCache.get(baseDir);
+    if (cached)
+        return cached;
+    let dirs = [];
+    try {
+        dirs = readdirSync(baseDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+            .map((e) => e.name)
+            .filter((name) => !SKIP_DIRS.has(name));
+    }
+    catch {
+        dirs = [];
+    }
+    if (dirs.length > 0)
+        subdirCache.set(baseDir, dirs);
+    return dirs;
+}
+export function hasProjectManifest(dir) {
+    return PROJECT_MANIFESTS.some((m) => existsSync(join(dir, m)));
+}
+/**
+ * Resolve a file/dir path inside a workspace, tolerating the common case
+ * where the agent runs from a parent directory while the actual project
+ * lives in a single immediate subdirectory (e.g. baseDir=<repo>,
+ * project=<repo>/app). Resolution order:
+ *   1. absolute path as-is;
+ *   2. baseDir/<p> тАФ project rooted directly at baseDir;
+ *   3. <subdir>/<p> for each immediate project subdirectory of baseDir
+ *      (manifest-bearing subdirectories are preferred).
+ * Returns baseDir/<p> as a fallback when nothing exists, so callers that
+ * check existsSync() still correctly report the path as missing.
+ */
+export function resolveProjectPath(baseDir, p) {
+    const abs = isAbsolute(p) ? p : resolve(baseDir, p);
+    if (existsSync(abs))
+        return abs;
+    // baseDir itself is a project root тАФ paths are relative to it. Probing
+    // subdirectories here would match files in unrelated nested packages.
+    if (hasProjectManifest(baseDir))
+        return abs;
+    let fallback = abs;
+    for (const name of scanSubdirs(baseDir)) {
+        const candidate = resolve(baseDir, name, p);
+        if (existsSync(candidate)) {
+            if (hasProjectManifest(join(baseDir, name)))
+                return candidate;
+            if (fallback === abs)
+                fallback = candidate;
+        }
+    }
+    return fallback;
+}
+/** Clear the internal subdirectory cache (used by tests). */
+export function clearWorkspaceCache() {
+    subdirCache.clear();
+}