micro-models-agent 0.52.1 → 0.53.0

package/dist/llm/provider.js

@@ -0,0 +1,10 @@
+// src/llm/provider.ts
+/** Helper: extract plain text from message content (for token counting, logging, etc.) */
+export function getMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((p) => p.type === "text")
+        .map((p) => p.text)
+        .join("");
+}

package/dist/llm/response.js

@@ -0,0 +1,39 @@
+export function parseChunks(chunks) {
+    let text = "";
+    let reasoning;
+    const toolCalls = [];
+    let hasToolCalls = false;
+    for (const chunk of chunks) {
+        if (chunk.type === "text" && chunk.content) {
+            text += chunk.content;
+        }
+        if (chunk.type === "reasoning" && chunk.content) {
+            reasoning = (reasoning || "") + chunk.content;
+        }
+        if (chunk.type === "tool_call" && chunk.toolCall) {
+            hasToolCalls = true;
+            let parsedArgs;
+            try {
+                parsedArgs = JSON.parse(chunk.toolCall.arguments);
+            }
+            catch {
+                parsedArgs = {};
+            }
+            toolCalls.push({
+                id: chunk.toolCall.id,
+                name: chunk.toolCall.name,
+                arguments: parsedArgs,
+            });
+        }
+    }
+    if (hasToolCalls) {
+        return { type: "tool_call", calls: toolCalls, reasoning };
+    }
+    if (reasoning && !text) {
+        return { type: "reasoning", content: reasoning };
+    }
+    if (!text && !reasoning) {
+        return { type: "empty" };
+    }
+    return { type: "text", content: text || "", reasoning };
+}

package/dist/llm/token-counter.js

@@ -0,0 +1,39 @@
+// src/llm/token-counter.ts
+import { encodingForModel, getEncoding } from "js-tiktoken";
+import { getMessageText } from "./provider";
+export class TokenCounter {
+    encoder;
+    constructor(model = "gpt-4o") {
+        try {
+            this.encoder = encodingForModel(model);
+        }
+        catch {
+            // Fallback to cl100k_base for unknown models
+            this.encoder = getEncoding("cl100k_base");
+        }
+    }
+    count(text) {
+        if (!text)
+            return 0;
+        return this.encoder.encode(text).length;
+    }
+    countMessages(messages) {
+        let total = 0;
+        for (const msg of messages) {
+            // ~4 tokens per message overhead (role, boundaries)
+            total += 4;
+            const text = getMessageText(msg.content);
+            total += this.count(text);
+            if (msg.role === "tool")
+                total += 2; // tool_call_id
+        }
+        total += 2; // assistant priming
+        return total;
+    }
+    encode(text) {
+        return this.encoder.encode(text);
+    }
+    decode(tokens) {
+        return this.encoder.decode(tokens);
+    }
+}

package/dist/llm/types.js

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

package/dist/logger/app-logger.js

@@ -0,0 +1,189 @@
+import { appendFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { sanitizeLogMessage } from "../modules/security/data-sanitizer";
+import { FileLogWriter } from "./file-log";
+import pc from "picocolors";
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+const LEVEL_COLORS = {
+    debug: (s) => pc.dim(s),
+    info: (s) => s,
+    warn: (s) => pc.yellow(s),
+    error: (s) => pc.red(s),
+};
+function isColorEnabled() {
+    return !process.env.NO_COLOR && !process.env.CI && process.stdout.isTTY === true;
+}
+export class Logger {
+    level;
+    prefix;
+    logDir = null;
+    sessionDir = null;
+    fileLog;
+    constructor(level = "info", prefix = "") {
+        this.level = level;
+        this.prefix = prefix;
+        this.fileLog = new FileLogWriter();
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    setLogDir(dir) {
+        this.logDir = dir;
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        this.fileLog.setLogDir(dir);
+    }
+    setSessionDir(dir) {
+        this.sessionDir = dir;
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    clearSessionDir() {
+        this.sessionDir = null;
+    }
+    /** Open a per-session `.log` file (legacy v1 behavior). */
+    initSessionLog(sessionId) {
+        this.fileLog.initSessionLog(sessionId);
+    }
+    /** Fall back to daily log files when no session is active. */
+    closeSessionLog() {
+        this.fileLog.closeSessionLog();
+    }
+    getLogPath() {
+        return this.fileLog.getLogPath();
+    }
+    cleanupOldLogs(maxDays, maxFiles) {
+        this.fileLog.cleanupOldLogs(maxDays, maxFiles);
+    }
+    // --- Tagged helpers (legacy v1 API) ---
+    logLLMRequest(model, messagesCount, promptPreview, caller) {
+        this.fileLog.logLLMRequest(model, messagesCount, sanitizeLogMessage(promptPreview), caller);
+    }
+    logLLMResponse(model, responseLength, genTimeMs, error, caller) {
+        this.fileLog.logLLMResponse(model, responseLength, genTimeMs, error, caller);
+    }
+    logToolCall(tool, preview, result) {
+        this.fileLog.logToolCall(tool, sanitizeLogMessage(preview), result !== undefined ? sanitizeLogMessage(result) : undefined);
+    }
+    logToolOutput(tool, output, exitCode) {
+        this.fileLog.logToolOutput(tool, sanitizeLogMessage(output), exitCode);
+    }
+    logREPL(tag, content) {
+        this.fileLog.logREPL(tag, sanitizeLogMessage(content));
+    }
+    child(prefix) {
+        const childLogger = new Logger(this.level, this.prefix ? `${this.prefix}:${prefix}` : prefix);
+        if (this.logDir)
+            childLogger.setLogDir(this.logDir);
+        if (this.sessionDir)
+            childLogger.setSessionDir(this.sessionDir);
+        return childLogger;
+    }
+    debug(msg, meta) {
+        this.log("debug", msg, meta);
+    }
+    info(msg, meta) {
+        this.log("info", msg, meta);
+    }
+    warn(msg, meta) {
+        this.log("warn", msg, meta);
+    }
+    error(msg, meta) {
+        this.log("error", msg, meta);
+    }
+    log(level, msg, meta) {
+        if (LEVELS[level] < LEVELS[this.level])
+            return;
+        // Sanitize log message to remove sensitive data
+        const sanitizedMsg = sanitizeLogMessage(msg);
+        const sanitizedMeta = meta ? this.sanitizeMeta(meta) : undefined;
+        const ts = new Date().toISOString();
+        const prefix = this.prefix ? ` [${this.prefix}]` : "";
+        const metaStr = sanitizedMeta ? ` ${JSON.stringify(sanitizedMeta)}` : "";
+        const line = `[${level.toUpperCase()}]${prefix} ${ts} — ${sanitizedMsg}${metaStr}`;
+        console.log(isColorEnabled() ? LEVEL_COLORS[level](line) : line);
+        // Legacy v1 behavior: also append to the tagged `.log` file (session or daily).
+        this.fileLog.log(level.toUpperCase(), this.prefix || "MMA", `${ts} — ${sanitizedMsg}${metaStr}`);
+        const logTarget = this.sessionDir ?? this.logDir;
+        if (logTarget) {
+            try {
+                appendFileSync(join(logTarget, "app.jsonl"), JSON.stringify({
+                    level,
+                    ts,
+                    prefix: this.prefix,
+                    msg: sanitizedMsg,
+                    meta: sanitizedMeta ?? null,
+                }) + "\n", "utf-8");
+            }
+            catch {
+                /* file logging is best-effort */
+            }
+        }
+    }
+    /**
+     * Sanitize metadata object to remove sensitive data
+     */
+    sanitizeMeta(meta) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(meta)) {
+            if (typeof value === "string") {
+                sanitized[key] = sanitizeLogMessage(value);
+            }
+            else if (typeof value === "object" && value !== null) {
+                sanitized[key] = this.sanitizeMeta(value);
+            }
+            else {
+                sanitized[key] = value;
+            }
+        }
+        return sanitized;
+    }
+    /**
+     * Write a structured record to app.jsonl only (no console / .log output).
+     * Used for machine-readable reports (environment, etc.) that would be too
+     * noisy on the terminal but are valuable for cross-device diagnosis.
+     */
+    logStructured(type, data) {
+        const logTarget = this.sessionDir ?? this.logDir;
+        if (!logTarget)
+            return;
+        try {
+            appendFileSync(join(logTarget, "app.jsonl"), JSON.stringify({
+                level: "info",
+                ts: new Date().toISOString(),
+                type,
+                meta: this.sanitizeMeta(data),
+            }) + "\n", "utf-8");
+        }
+        catch {
+            /* file logging is best-effort */
+        }
+    }
+    /**
+     * Write a log entry to app.jsonl only — no console output, no .log file.
+     * Use this for noisy subsystems (LSP, probes) whose warnings should be
+     * diagnosable from session files but not pollute the user's terminal.
+     */
+    logSilent(level, msg, meta) {
+        const logTarget = this.sessionDir ?? this.logDir;
+        if (!logTarget)
+            return;
+        const ts = new Date().toISOString();
+        const sanitizedMsg = sanitizeLogMessage(msg);
+        const sanitizedMeta = meta ? this.sanitizeMeta(meta) : undefined;
+        try {
+            appendFileSync(join(logTarget, "app.jsonl"), JSON.stringify({
+                level,
+                ts,
+                prefix: this.prefix,
+                msg: sanitizedMsg,
+                meta: sanitizedMeta ?? null,
+            }) + "\n", "utf-8");
+        }
+        catch {
+            /* file logging is best-effort */
+        }
+    }
+}

package/dist/logger/file-log.js

@@ -0,0 +1,151 @@
+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/logger/index.js

@@ -0,0 +1 @@
+export { Logger } from "./app-logger";