micro-models-agent 0.59.0 → 0.60.1

package/dist/core/environment.js

@@ -1,199 +0,0 @@
-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

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

package/dist/core/prompt-builder.js

@@ -1,76 +0,0 @@
-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

@@ -1,251 +0,0 @@
-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

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

package/dist/core/version.js

@@ -1,26 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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();
-}

package/dist/i18n/index.js

@@ -1,46 +0,0 @@
-import en from "./en.json";
-import ru from "./ru.json";
-const locales = { en, ru };
-let currentLocale = "en";
-function flatten(obj, prefix = "") {
-    let result = {};
-    for (const [key, val] of Object.entries(obj)) {
-        const fullKey = prefix ? `${prefix}.${key}` : key;
-        if (typeof val === "string") {
-            result[fullKey] = val;
-        }
-        else if (typeof val === "object" && val !== null) {
-            result = {
-                ...result,
-                ...flatten(val, fullKey),
-            };
-        }
-    }
-    return result;
-}
-const flat = {};
-for (const [name, dict] of Object.entries(locales)) {
-    flat[name] = flatten(dict);
-}
-export function setLocale(locale) {
-    if (flat[locale]) {
-        currentLocale = locale;
-    }
-}
-export function loadLocale(name, dict) {
-    locales[name] = dict;
-    flat[name] = flatten(dict);
-}
-export function t(key, params) {
-    const localeDict = flat[currentLocale];
-    const enDict = flat["en"];
-    let template = localeDict?.[key] ?? enDict?.[key] ?? key;
-    if (!template)
-        return key;
-    if (params) {
-        for (const [k, v] of Object.entries(params)) {
-            template = template.replaceAll(`{${k}}`, String(v));
-        }
-    }
-    return template;
-}