micro-models-agent 0.28.17 → 0.29.0

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/logger/file-log.js

@@ -1,151 +0,0 @@
-import { appendFileSync, mkdirSync, existsSync, readdirSync, renameSync, statSync, unlinkSync, } from "node:fs";
-import { join } from "node:path";
-const MAX_LOG_SIZE = 5 * 1024 * 1024;
-const MAX_LOG_FILES = 30;
-const DEFAULT_MAX_DAYS = 30;
-const TOOL_OUTPUT_LIMIT = 2000;
-/**
- * Tagged file logger (legacy MMA v1 behavior).
- *
- * Writes human-readable log lines to `~/.mma/logs/`:
- * - `<sessionId>.log` while a session is active
- * - `YYYY-MM-DD.log` for everything outside a session
- *
- * Features restored from v1:
- * - size-based rotation (5 MB → file.log.1, file.log.2, ...)
- * - cleanup of old logs (age + max file count)
- * - tagged helpers: LLM request/response, tool calls, REPL
- */
-export class FileLogWriter {
-    logDir = null;
-    sessionLogPath = null;
-    setLogDir(dir) {
-        this.logDir = dir;
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-    }
-    /** Open a per-session log file. Triggers cleanup of old logs. */
-    initSessionLog(sessionId) {
-        if (!this.logDir)
-            return;
-        if (!existsSync(this.logDir)) {
-            mkdirSync(this.logDir, { recursive: true });
-        }
-        this.sessionLogPath = join(this.logDir, `${sessionId}.log`);
-        this.cleanupOldLogs();
-    }
-    /** Fall back to daily log files when no session is active. */
-    closeSessionLog() {
-        this.sessionLogPath = null;
-    }
-    getLogPath() {
-        if (this.sessionLogPath)
-            return this.sessionLogPath;
-        if (!this.logDir)
-            return "";
-        const date = new Date().toISOString().slice(0, 10);
-        return join(this.logDir, `${date}.log`);
-    }
-    /** Rotate the file if it exceeds the size limit. */
-    rotateIfNeeded(filePath) {
-        if (!existsSync(filePath))
-            return;
-        const size = statSync(filePath).size;
-        if (size < MAX_LOG_SIZE)
-            return;
-        let idx = 1;
-        while (existsSync(`${filePath}.${idx}`))
-            idx++;
-        renameSync(filePath, `${filePath}.${idx}`);
-    }
-    log(level, tag, message) {
-        const fp = this.getLogPath();
-        if (!fp)
-            return;
-        if (this.logDir && !existsSync(this.logDir)) {
-            mkdirSync(this.logDir, { recursive: true });
-        }
-        this.rotateIfNeeded(fp);
-        const line = `[${new Date().toISOString()}] [${level}] [${tag}] ${message}\n`;
-        try {
-            appendFileSync(fp, line, "utf-8");
-        }
-        catch {
-            /* file logging is best-effort */
-        }
-    }
-    logLLMRequest(model, messagesCount, promptPreview, caller) {
-        const tag = caller ? `LLM/${caller}` : "LLM";
-        this.log("INFO", tag, `→ ${model} | ${messagesCount} messages | "${promptPreview.slice(0, 100)}"`);
-    }
-    logLLMResponse(model, responseLength, genTimeMs, error, caller) {
-        const tag = caller ? `LLM/${caller}` : "LLM";
-        if (error) {
-            this.log("ERROR", tag, `← ${model} | ${responseLength} chars | ${genTimeMs}ms | ERROR: ${error}`);
-        }
-        else {
-            this.log("INFO", tag, `← ${model} | ${responseLength} chars | ${genTimeMs}ms`);
-        }
-    }
-    logToolCall(tool, preview, result) {
-        const previewTrimmed = preview.length > 200 ? preview.slice(0, 200) + "..." : preview;
-        if (result !== undefined) {
-            const resultTrimmed = result.length > 200 ? result.slice(0, 200) + "..." : result;
-            this.log("INFO", "TOOL", `${tool} | ${previewTrimmed} → ${resultTrimmed}`);
-        }
-        else {
-            this.log("INFO", "TOOL", `${tool} | ${previewTrimmed}`);
-        }
-    }
-    logToolOutput(tool, output, exitCode) {
-        const trimmed = output.length > TOOL_OUTPUT_LIMIT
-            ? output.slice(0, TOOL_OUTPUT_LIMIT) +
-                `\n... (truncated ${output.length - TOOL_OUTPUT_LIMIT} chars)`
-            : output;
-        this.log("DEBUG", "TOOL_OUTPUT", `${tool} exit:${exitCode}\n${trimmed}`);
-    }
-    logREPL(tag, content) {
-        const trimmed = content.length > 400 ? content.slice(0, 400) + "..." : content;
-        this.log("INFO", `REPL/${tag}`, trimmed);
-    }
-    /**
-     * Clean up old log files.
-     * - Deletes files older than maxDays
-     * - Keeps at most maxFiles most recent .log files
-     */
-    cleanupOldLogs(maxDays = DEFAULT_MAX_DAYS, maxFiles = MAX_LOG_FILES) {
-        if (!this.logDir || !existsSync(this.logDir))
-            return;
-        const now = Date.now();
-        const list = () => readdirSync(this.logDir)
-            .filter((f) => f.endsWith(".log") || /\.log\.\d+$/.test(f))
-            .map((f) => ({
-            name: f,
-            path: join(this.logDir, f),
-            mtime: statSync(join(this.logDir, f)).mtimeMs,
-        }))
-            .sort((a, b) => b.mtime - a.mtime);
-        // 1. Delete by age.
-        for (const f of list()) {
-            if (now - f.mtime > maxDays * 24 * 60 * 60 * 1000) {
-                try {
-                    unlinkSync(f.path);
-                }
-                catch {
-                    /* ignore */
-                }
-            }
-        }
-        // 2. Delete excess (fresh but more than maxFiles).
-        const remaining = list();
-        for (let i = maxFiles; i < remaining.length; i++) {
-            try {
-                unlinkSync(remaining[i].path);
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-}

package/dist/modules/certification/cli.js

@@ -1,176 +0,0 @@
-import { rmSync } from "fs";
-import { homedir } from "os";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { existsSync, readFileSync } from "fs";
-import { t } from "../../i18n/index";
-import { pc } from "../../ui/colors";
-import { loadScenarios, filterByTags } from "./loader";
-import { runScenario, findMmaRoot } from "./runner";
-import { readManifest, upsertCertification, removeCertification, } from "./manifest";
-const HERE = dirname(fileURLToPath(import.meta.url));
-const MMA_ROOT = findMmaRoot(HERE);
-const USER_SCENARIO_DIR = join(homedir(), ".mma", "certification", "scenarios");
-function readVersion() {
-    const candidates = [join(MMA_ROOT, "package.json")];
-    for (const p of candidates) {
-        if (existsSync(p)) {
-            try {
-                const raw = JSON.parse(readFileSync(p, "utf-8"));
-                if (raw.version)
-                    return raw.version;
-            }
-            catch {
-                // Broken package.json — fall back to the default version
-            }
-        }
-    }
-    return "0.0.0";
-}
-export function parseTags(s) {
-    return s
-        .split(",")
-        .map((x) => x.trim())
-        .filter(Boolean);
-}
-export async function certify(opts) {
-    const providerUrl = opts.providerUrl || opts.config.provider.baseUrl;
-    if (opts.tags.includes("security") && !opts.config.security?.enabled) {
-        console.error(pc.red(t("cli.cert_security_required")));
-        process.exitCode = 1;
-        return;
-    }
-    const { scenarios, errors } = loadScenarios(USER_SCENARIO_DIR);
-    for (const e of errors)
-        console.error(pc.yellow(`  ${e}`));
-    const selected = filterByTags(scenarios, opts.tags);
-    if (selected.length === 0) {
-        console.error(pc.red(t("cli.cert_no_scenarios", { tags: opts.tags.join(",") })));
-        process.exitCode = 1;
-        return;
-    }
-    const manifest = readManifest();
-    const existing = manifest.certifications.find((e) => e.model === opts.name && e.providerUrl === providerUrl);
-    if (existing && !opts.force) {
-        console.error(pc.yellow(t("cli.cert_exists", { model: opts.name })));
-        console.error(pc.yellow(t("cli.cert_exists_hint")));
-        process.exitCode = 1;
-        return;
-    }
-    console.log(t("cli.cert_started", { model: opts.name, provider: providerUrl }));
-    const sandboxBase = join(process.cwd(), ".mma", "certification");
-    const results = [];
-    const total = selected.length;
-    let idx = 0;
-    for (const scenario of selected) {
-        idx++;
-        if (scenario.mode === "skip") {
-            console.log(pc.dim(`[${idx}/${total}] ${scenario.id} ... skipped`));
-            results.push({
-                id: scenario.id,
-                title: scenario.title,
-                status: "skipped",
-                passed: 0,
-                of: 0,
-            });
-            continue;
-        }
-        const res = await runScenario(scenario, {
-            model: opts.name,
-            providerUrl,
-            providerKey: opts.providerKey,
-            contextWindow: opts.contextWindow,
-            mmaRoot: MMA_ROOT,
-            sandboxBase,
-            defaultReps: opts.reps,
-            defaultThreshold: 2,
-            onRep: (id, rep, reps, passed, failures) => {
-                const word = passed
-                    ? pc.green(t("cli.cert_rep_pass"))
-                    : pc.red(t("cli.cert_rep_fail"));
-                console.log(`[${idx}/${total}] ${id} (${rep}/${reps})... ${word}`);
-                if (!passed)
-                    console.log(`    ${pc.dim(failures.join("; "))}`);
-            },
-        });
-        results.push(res);
-    }
-    if (opts.clean) {
-        try {
-            rmSync(sandboxBase, { recursive: true, force: true });
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    const suite = summarize(results);
-    const entry = {
-        model: opts.name,
-        providerUrl,
-        mmaVersion: readVersion(),
-        certifiedAt: new Date().toISOString(),
-        suite,
-        results,
-    };
-    upsertCertification(entry);
-    console.log(t("cli.cert_done", {
-        passed: String(suite.passed),
-        failed: String(suite.failed),
-        skipped: String(suite.skipped),
-        total: String(suite.total),
-    }));
-    printResults(results);
-}
-export async function certStatus(name, config) {
-    const m = readManifest();
-    const providerUrl = config.provider.baseUrl;
-    const entry = m.certifications.find((e) => e.model === name && e.providerUrl === providerUrl);
-    if (!entry) {
-        console.log(t("cli.cert_not_found", { model: name }));
-        return;
-    }
-    console.log(`${t("cli.cert_provider_col")}: ${entry.providerUrl}`);
-    console.log(`${t("cli.cert_version_col")}: ${entry.mmaVersion}  ${t("cli.cert_date_col")}: ${entry.certifiedAt.slice(0, 10)}`);
-    console.log(`${t("cli.cert_suite_col")}: ${entry.suite.passed} pass / ${entry.suite.failed} fail / ${entry.suite.skipped} skipped`);
-    printResults(entry.results);
-}
-export async function certList() {
-    const m = readManifest();
-    if (m.certifications.length === 0) {
-        console.log(t("cli.cert_empty"));
-        return;
-    }
-    for (const e of m.certifications) {
-        console.log(`  ${pc.green("✔")} ${e.model}  ${pc.dim(e.providerUrl)}  ${e.mmaVersion}  ${e.certifiedAt.slice(0, 10)}  ${e.suite.passed}/${e.suite.total} pass`);
-    }
-}
-export async function uncertify(name, config) {
-    const removed = removeCertification(name, config.provider.baseUrl);
-    if (removed)
-        console.log(t("cli.cert_uncertified", { model: name }));
-    else
-        console.log(t("cli.cert_not_found", { model: name }));
-}
-function summarize(results) {
-    return {
-        passed: results.filter((r) => r.status === "pass").length,
-        failed: results.filter((r) => r.status === "fail").length,
-        skipped: results.filter((r) => r.status === "skipped").length,
-        total: results.length,
-    };
-}
-function printResults(results) {
-    for (const r of results) {
-        const icon = r.status === "pass"
-            ? pc.green("✔")
-            : r.status === "fail"
-                ? pc.red("✘")
-                : r.status === "skipped"
-                    ? pc.dim("–")
-                    : pc.yellow("!");
-        const detail = r.status === "skipped" ? pc.dim(r.title) : `${r.passed}/${r.of}`;
-        console.log(`  ${icon} ${r.id}  ${detail}`);
-        if (r.error)
-            console.log(`    ${pc.dim(r.error)}`);
-    }
-}

package/dist/modules/certification/fact-checker.js

@@ -1,84 +0,0 @@
-import { existsSync, readFileSync, statSync } from "fs";
-import { join } from "path";
-export function checkSandbox(sandboxDir, checks, exitCode, output) {
-    const failures = [];
-    for (const check of checks) {
-        if (!runCheck(sandboxDir, check, exitCode, output)) {
-            failures.push(describe(check));
-        }
-    }
-    return { pass: failures.length === 0, failures };
-}
-function runCheck(sandboxDir, check, exitCode, output) {
-    switch (check.type) {
-        case "exitCode":
-            return exitCode === (check.code ?? 0);
-        case "outputContains":
-            return output.includes(check.text);
-        case "fileExists":
-            return isFile(join(sandboxDir, check.path));
-        case "fileNotExists":
-            return !existsSync(join(sandboxDir, check.path));
-        case "dirExists":
-            return isDir(join(sandboxDir, check.path));
-        case "fileContent": {
-            const abs = join(sandboxDir, check.path);
-            if (!isFile(abs))
-                return false;
-            const content = readFileSync(abs, "utf-8");
-            if (check.contains !== undefined)
-                return content.includes(check.contains);
-            if (check.equals !== undefined)
-                return content === check.equals;
-            return false;
-        }
-        case "fileRegex": {
-            const abs = join(sandboxDir, check.path);
-            if (!isFile(abs))
-                return false;
-            return new RegExp(check.pattern).test(readFileSync(abs, "utf-8"));
-        }
-        default:
-            return false;
-    }
-}
-function isFile(p) {
-    try {
-        return existsSync(p) && statSync(p).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function isDir(p) {
-    try {
-        return existsSync(p) && statSync(p).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-function describe(check) {
-    switch (check.type) {
-        case "exitCode":
-            return `expected exit code ${check.code ?? 0}`;
-        case "outputContains":
-            return `output missing "${check.text}"`;
-        case "fileExists":
-            return `file missing: ${check.path}`;
-        case "fileNotExists":
-            return `file unexpectedly exists: ${check.path}`;
-        case "dirExists":
-            return `directory missing: ${check.path}`;
-        case "fileContent": {
-            const what = check.contains !== undefined
-                ? `contains "${check.contains}"`
-                : `equals "${check.equals}"`;
-            return `${check.path} does not ${what}`;
-        }
-        case "fileRegex":
-            return `${check.path} does not match ${check.pattern}`;
-        default:
-            return "unknown check";
-    }
-}

package/dist/modules/certification/loader.js

@@ -1,111 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { join } from "path";
-import { parse as parseYaml } from "yaml";
-import { BUILTIN_SCENARIOS } from "./scenarios";
-const TAGS = ["core", "security", "image", "network", "browser"];
-const CHECK_TYPES = [
-    "fileExists",
-    "fileNotExists",
-    "dirExists",
-    "fileContent",
-    "fileRegex",
-    "exitCode",
-    "outputContains",
-];
-export function validateScenario(s) {
-    const errors = [];
-    const isSkip = s.mode === "skip";
-    if (!s.id || !s.title || (!isSkip && !s.prompt)) {
-        errors.push(`[${s.id ?? "?"}] missing id, title or prompt`);
-    }
-    if (!Array.isArray(s.tags) || s.tags.length === 0) {
-        errors.push(`[${s.id}] tags required`);
-    }
-    for (const tag of s.tags) {
-        if (!TAGS.includes(tag))
-            errors.push(`[${s.id}] unknown tag: ${tag}`);
-    }
-    if (s.mode !== "run" && s.mode !== "skip") {
-        errors.push(`[${s.id}] mode must be run or skip`);
-    }
-    if (!Array.isArray(s.checks) || (!isSkip && s.checks.length === 0)) {
-        errors.push(`[${s.id}] at least one check required`);
-    }
-    for (const c of s.checks) {
-        if (!CHECK_TYPES.includes(c.type)) {
-            errors.push(`[${s.id}] unknown check type: ${c.type}`);
-        }
-        if (c.type === "fileContent" &&
-            c.contains === undefined &&
-            c.equals === undefined) {
-            errors.push(`[${s.id}] fileContent needs contains or equals`);
-        }
-    }
-    if (s.reps !== undefined && (!Number.isInteger(s.reps) || s.reps < 1)) {
-        errors.push(`[${s.id}] reps must be a positive integer`);
-    }
-    if (s.passThreshold !== undefined &&
-        (!Number.isInteger(s.passThreshold) || s.passThreshold < 1)) {
-        errors.push(`[${s.id}] passThreshold must be a positive integer`);
-    }
-    if (s.passThreshold !== undefined &&
-        s.reps !== undefined &&
-        s.passThreshold > s.reps) {
-        errors.push(`[${s.id}] passThreshold > reps (must be <= reps)`);
-    }
-    return errors;
-}
-export function loadScenarios(userDir) {
-    const errors = [];
-    const scenarios = [];
-    for (const s of BUILTIN_SCENARIOS) {
-        const errs = validateScenario(s);
-        if (errs.length > 0)
-            errors.push(...errs);
-        else
-            scenarios.push(s);
-    }
-    if (userDir && existsSync(userDir)) {
-        for (const file of readdirSync(userDir)) {
-            if (!file.endsWith(".yaml") && !file.endsWith(".yml"))
-                continue;
-            try {
-                const raw = readFileSync(join(userDir, file), "utf-8");
-                const data = parseYaml(raw);
-                const parsed = normalizeScenario(data, file);
-                const errs = validateScenario(parsed);
-                if (errs.length > 0)
-                    errors.push(...errs);
-                else
-                    scenarios.push(parsed);
-            }
-            catch (e) {
-                errors.push(`[${file}] failed to parse: ${e.message}`);
-            }
-        }
-    }
-    return { scenarios, errors };
-}
-function normalizeScenario(data, file) {
-    const d = (data ?? {});
-    return {
-        id: String(d.id ?? file),
-        title: String(d.title ?? d.id ?? file),
-        tags: Array.isArray(d.tags) ? d.tags : [],
-        mode: d.mode === "skip" ? "skip" : "run",
-        prompt: String(d.prompt ?? ""),
-        reps: typeof d.reps === "number" ? d.reps : undefined,
-        passThreshold: typeof d.passThreshold === "number" ? d.passThreshold : undefined,
-        fixtures: Array.isArray(d.fixtures)
-            ? d.fixtures
-            : undefined,
-        checks: Array.isArray(d.checks) ? d.checks : [],
-        skipReason: typeof d.skipReason === "string" ? d.skipReason : undefined,
-    };
-}
-export function filterByTags(scenarios, tags) {
-    if (!tags || tags.length === 0) {
-        return scenarios.filter((s) => s.tags.includes("core"));
-    }
-    return scenarios.filter((s) => s.tags.some((t) => tags.includes(t)));
-}

package/dist/modules/certification/manifest.js

@@ -1,50 +0,0 @@
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-export const MANIFEST_PATH = join(homedir(), ".mma", "certifications.json");
-export function readManifest(path = MANIFEST_PATH) {
-    try {
-        if (existsSync(path)) {
-            const raw = JSON.parse(readFileSync(path, "utf-8"));
-            return { version: 1, certifications: raw.certifications ?? [] };
-        }
-    }
-    catch {
-        /* corrupted manifest → start fresh */
-    }
-    return { version: 1, certifications: [] };
-}
-export function saveManifest(m, path = MANIFEST_PATH) {
-    mkdirSync(join(homedir(), ".mma"), { recursive: true });
-    writeFileSync(path, JSON.stringify(m, null, 2), "utf-8");
-}
-export function upsertCertification(entry, path = MANIFEST_PATH) {
-    const m = readManifest(path);
-    const idx = m.certifications.findIndex((e) => e.model === entry.model && e.providerUrl === entry.providerUrl);
-    if (idx >= 0)
-        m.certifications[idx] = entry;
-    else
-        m.certifications.push(entry);
-    saveManifest(m, path);
-    return m;
-}
-export function removeCertification(model, providerUrl, path = MANIFEST_PATH) {
-    const m = readManifest(path);
-    const before = m.certifications.length;
-    m.certifications = m.certifications.filter((e) => !(e.model === model && e.providerUrl === providerUrl));
-    if (m.certifications.length !== before) {
-        saveManifest(m, path);
-        return true;
-    }
-    return false;
-}
-export function isStale(entry, currentVersion) {
-    return entry.mmaVersion !== currentVersion;
-}
-export function getCertMark(model, providerUrl, currentVersion, path = MANIFEST_PATH) {
-    const m = readManifest(path);
-    const entry = m.certifications.find((e) => e.model === model && e.providerUrl === providerUrl);
-    if (!entry)
-        return "none";
-    return isStale(entry, currentVersion) ? "stale" : "certified";
-}