micro-models-agent 0.7.9 → 0.8.0

package/dist/ui/diff.js

@@ -0,0 +1,185 @@
+import { pc } from "./colors";
+const CONTEXT_LINES = 3;
+const MAX_DIFF_LINES = 100;
+function computeLCS(oldLines, newLines) {
+    const m = oldLines.length;
+    const n = newLines.length;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (oldLines[i - 1] === newLines[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    return dp;
+}
+function buildDiff(oldLines, newLines) {
+    const dp = computeLCS(oldLines, newLines);
+    const result = [];
+    let i = oldLines.length;
+    let j = newLines.length;
+    const raw = [];
+    while (i > 0 && j > 0) {
+        if (oldLines[i - 1] === newLines[j - 1]) {
+            raw.unshift({
+                type: "context",
+                oldNum: i,
+                newNum: j,
+                content: oldLines[i - 1],
+            });
+            i--;
+            j--;
+        }
+        else if (dp[i - 1][j] > dp[i][j - 1]) {
+            raw.unshift({
+                type: "remove",
+                oldNum: i,
+                newNum: 0,
+                content: oldLines[i - 1],
+            });
+            i--;
+        }
+        else {
+            raw.unshift({
+                type: "add",
+                oldNum: 0,
+                newNum: j,
+                content: newLines[j - 1],
+            });
+            j--;
+        }
+    }
+    while (i > 0) {
+        raw.unshift({
+            type: "remove",
+            oldNum: i,
+            newNum: 0,
+            content: oldLines[i - 1],
+        });
+        i--;
+    }
+    while (j > 0) {
+        raw.unshift({
+            type: "add",
+            oldNum: 0,
+            newNum: j,
+            content: newLines[j - 1],
+        });
+        j--;
+    }
+    const changed = new Set();
+    for (let k = 0; k < raw.length; k++) {
+        if (raw[k].type !== "context") {
+            changed.add(k);
+        }
+    }
+    const included = new Set();
+    for (const idx of changed) {
+        for (let k = Math.max(0, idx - CONTEXT_LINES); k <= Math.min(raw.length - 1, idx + CONTEXT_LINES); k++) {
+            included.add(k);
+        }
+    }
+    let lastIncluded = -1;
+    for (let k = 0; k < raw.length; k++) {
+        if (included.has(k)) {
+            if (lastIncluded >= 0 && k > lastIncluded + 1) {
+                result.push({
+                    type: "context",
+                    oldNum: null,
+                    newNum: null,
+                    content: "...",
+                });
+            }
+            const line = raw[k];
+            result.push({
+                type: line.type,
+                oldNum: line.type === "add" ? null : line.oldNum,
+                newNum: line.type === "remove" ? null : line.newNum,
+                content: line.content,
+            });
+            lastIncluded = k;
+        }
+    }
+    return result;
+}
+function formatLine(line, maxNumWidth) {
+    const num = line.type === "remove" ? line.oldNum : line.newNum;
+    const numStr = num !== null ? String(num).padStart(maxNumWidth) : " ".repeat(maxNumWidth);
+    if (line.type === "remove") {
+        return pc.red(`${pc.bgRed(`${numStr} - ${line.content}`)}`);
+    }
+    else if (line.type === "add") {
+        return pc.green(`${pc.bgGreen(`${numStr} + ${line.content}`)}`);
+    }
+    else if (line.content === "...") {
+        return pc.dim(`  ${" ".repeat(maxNumWidth)}...`);
+    }
+    else {
+        return `  ${numStr}   ${line.content}`;
+    }
+}
+export function generateDiff(oldContent, newContent) {
+    if (oldContent === newContent)
+        return "";
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    if (oldLines.length === 1 &&
+        oldLines[0] === "" &&
+        newLines.length === 1 &&
+        newLines[0] === "") {
+        return "";
+    }
+    const diff = buildDiff(oldLines, newLines);
+    if (diff.length === 0)
+        return "";
+    const maxOldNum = Math.max(...diff.filter((l) => l.oldNum !== null).map((l) => l.oldNum));
+    const maxNewNum = Math.max(...diff.filter((l) => l.newNum !== null).map((l) => l.newNum));
+    const maxNumWidth = Math.max(String(maxOldNum).length, String(maxNewNum).length, 3);
+    let lines = diff.map((l) => formatLine(l, maxNumWidth));
+    if (lines.length > MAX_DIFF_LINES) {
+        const truncated = lines.slice(0, MAX_DIFF_LINES);
+        truncated.push(pc.dim(`  ... (${lines.length - MAX_DIFF_LINES} more lines)`));
+        lines = truncated;
+    }
+    return lines.join("\n");
+}
+export function generateNewFileDiff(content) {
+    const lines = content.split("\n");
+    const maxNumWidth = Math.max(String(lines.length).length, 3);
+    const diffLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const numStr = String(i + 1).padStart(maxNumWidth);
+        diffLines.push(pc.green(`${pc.bgGreen(`${numStr} + ${lines[i]}`)}`));
+    }
+    if (diffLines.length > MAX_DIFF_LINES) {
+        const truncated = diffLines.slice(0, MAX_DIFF_LINES);
+        truncated.push(pc.dim(`  ... (${diffLines.length - MAX_DIFF_LINES} more lines)`));
+        return truncated.join("\n");
+    }
+    return diffLines.join("\n");
+}
+export function generateDeleteDiff(content) {
+    const lines = content.split("\n");
+    const maxNumWidth = Math.max(String(lines.length).length, 3);
+    const diffLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const numStr = String(i + 1).padStart(maxNumWidth);
+        diffLines.push(pc.red(`${pc.bgRed(`${numStr} - ${lines[i]}`)}`));
+    }
+    if (diffLines.length > MAX_DIFF_LINES) {
+        const truncated = diffLines.slice(0, MAX_DIFF_LINES);
+        truncated.push(pc.dim(`  ... (${diffLines.length - MAX_DIFF_LINES} more lines)`));
+        return truncated.join("\n");
+    }
+    return diffLines.join("\n");
+}
+export function generateMoveDiff(fromPath, toPath) {
+    return [
+        pc.red(`  - ${fromPath}`),
+        pc.green(`  + ${toPath}`),
+    ].join("\n");
+}

package/dist/ui/index.js

@@ -0,0 +1,6 @@
+export { formatMarkdown, formatError, formatSuccess, formatWarning, FormattingStream } from './md-formatter';
+export { writeOutput, writeError, writeSuccess, writeWarning } from './output';
+export { formatTable, splitRow, isSeparatorRow, getTerminalWidth } from './table';
+export { box, divider, wrapText } from './box';
+export { Spinner, isSpinnerSupported } from './spinner';
+export { Renderer, isRichTerminal, summarizeArgs } from './renderer';

package/dist/ui/md-formatter.js

@@ -0,0 +1,212 @@
+import { pc } from './colors';
+import { t } from '../i18n/index';
+import { formatTable, getTerminalWidth } from './table';
+const KW = /\b(import|export|from|const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|class|extends|implements|interface|type|enum|namespace|module|declare|abstract|async|await|yield|throw|try|catch|finally|typeof|instanceof|in|of|as|is|keyof|readonly|static|private|public|protected|get|set|constructor|this|super|void|never|any|unknown|boolean|string|number|symbol|object|true|false|null|undefined|default)\b/g;
+const STRING = /('[^']*'|"[^"]*"|`[^`]*`)/g;
+const COMMENT = /(\/\/[^\n]*|\/\*[\s\S]*?\*\/|#[^\n]*)/g;
+const NUMBER = /\b(\d+\.?\d*)\b/g;
+const TAG = /<\/?([A-Z][a-zA-Z0-9]*|[a-z][a-zA-Z0-9-]*)/g;
+const ATTR = /\b([a-zA-Z-]+=)"([^"]*)"/g;
+function highlight(code, lang) {
+    if (lang === 'html' || lang === 'xml' || lang === 'svg') {
+        code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
+        code = code.replace(ATTR, (_m, attr, val) => pc.yellow(attr) + '=' + pc.green('"' + val + '"'));
+        code = code.replace(TAG, (_m, tag) => '<' + pc.cyan(tag));
+    }
+    else if (lang === 'css' || lang === 'scss' || lang === 'less') {
+        code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
+        code = code.replace(STRING, (m) => pc.green(m));
+        code = code.replace(NUMBER, (m) => pc.yellow(m));
+    }
+    else if (lang === 'bash' || lang === 'sh' || lang === 'shell' || lang === 'zsh') {
+        code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
+        code = code.replace(STRING, (m) => pc.green(m));
+    }
+    else if (lang === 'json') {
+        code = code.replace(STRING, (m) => pc.green(m));
+        code = code.replace(NUMBER, (m) => pc.yellow(m));
+    }
+    else {
+        // js, ts, jsx, tsx, and fallback
+        code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
+        code = code.replace(STRING, (m) => pc.green(m));
+        code = code.replace(KW, (m) => pc.magenta(m));
+        code = code.replace(NUMBER, (m) => pc.yellow(m));
+    }
+    return code;
+}
+function isTableRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|'))
+        return false;
+    const pipes = trimmed.match(/\|/g);
+    return (pipes?.length ?? 0) >= 2;
+}
+function isHorizontalRule(line) {
+    return /^(-{3,}|\*{3,}|_{3,})\s*$/.test(line.trim());
+}
+export class FormattingStream {
+    buffer = '';
+    inCodeBlock = false;
+    codeLang = '';
+    codeLines = [];
+    tableBuffer = [];
+    onWrite;
+    width;
+    constructor(onWrite, width) {
+        this.onWrite = onWrite;
+        this.width = width ?? getTerminalWidth();
+    }
+    write(chunk) {
+        this.buffer += chunk;
+        let idx;
+        while ((idx = this.buffer.indexOf('\n')) !== -1) {
+            const line = this.buffer.slice(0, idx);
+            this.buffer = this.buffer.slice(idx + 1);
+            this.processLine(line);
+        }
+    }
+    flush() {
+        if (this.inCodeBlock && this.codeLines.length > 0) {
+            this.emitCodeBlock();
+        }
+        if (this.tableBuffer.length > 0) {
+            this.flushTable();
+        }
+        if (this.buffer.length > 0) {
+            const line = this.buffer;
+            this.buffer = '';
+            if (line.trim() === '```' || line.trim().startsWith('```')) {
+                if (this.codeLines.length > 0) {
+                    this.emitCodeBlock();
+                }
+                return;
+            }
+            this.onWrite(this.formatLine(line));
+        }
+    }
+    processLine(line) {
+        if (line.trim() === '```' || line.trim().startsWith('```')) {
+            if (this.inCodeBlock) {
+                this.emitCodeBlock();
+            }
+            else {
+                this.inCodeBlock = true;
+                this.codeLang = line.trim().slice(3).trim();
+                this.codeLines = [];
+            }
+            return;
+        }
+        if (this.inCodeBlock) {
+            this.codeLines.push(line);
+            return;
+        }
+        if (isTableRow(line)) {
+            this.tableBuffer.push(line);
+            return;
+        }
+        if (this.tableBuffer.length > 0) {
+            this.flushTable();
+        }
+        this.onWrite(this.formatLine(line));
+    }
+    flushTable() {
+        const lines = this.tableBuffer;
+        this.tableBuffer = [];
+        const hasSeparator = lines.length >= 2 && /^\s*\|?[\s:|-]+\|?\s*$/.test(lines[1].trim());
+        if (hasSeparator) {
+            for (const l of formatTable(lines, { maxWidth: this.width })) {
+                this.onWrite(l);
+            }
+        }
+        else {
+            for (const l of lines) {
+                this.onWrite(this.formatLine(l));
+            }
+        }
+    }
+    emitCodeBlock() {
+        this.inCodeBlock = false;
+        if (this.codeLines.length > 0) {
+            const code = this.codeLines.join('\n');
+            const highlighted = highlight(code, this.codeLang);
+            const lang = this.codeLang ? ` ${this.codeLang} ` : ' ';
+            const top = pc.dim(`┌─${lang}${'─'.repeat(Math.max(0, this.width - 3 - lang.length))}┐`);
+            this.onWrite(top);
+            for (const l of highlighted.split('\n')) {
+                this.onWrite(pc.dim('│ ') + l);
+            }
+            this.onWrite(pc.dim(`└${'─'.repeat(Math.max(0, this.width - 1))}┘`));
+        }
+        this.codeLines = [];
+        this.codeLang = '';
+    }
+    formatLine(line) {
+        let result = line;
+        const heading = result.match(/^(#{1,6})\s+(.+)$/);
+        if (heading) {
+            const level = heading[1].length;
+            const content = this.formatInline(heading[2]);
+            if (level === 1)
+                return pc.cyan(pc.bold(pc.underline(content)));
+            return pc.cyan(pc.bold(content));
+        }
+        if (isHorizontalRule(result)) {
+            return pc.dim('─'.repeat(Math.max(0, Math.min(this.width, 60))));
+        }
+        const quote = result.match(/^(>+)\s?(.*)$/);
+        if (quote) {
+            const depth = Math.min(quote[1].length, 4);
+            const marker = pc.dim('▍'.repeat(depth));
+            return `${marker} ${this.formatInline(quote[2])}`;
+        }
+        const checkbox = result.match(/^[-*]\s+\[([ xX])\]\s+(.+)$/);
+        if (checkbox) {
+            const checked = checkbox[1].toLowerCase() === 'x';
+            const mark = checked ? pc.green('✓') : pc.dim('☐');
+            return `  ${mark} ${this.formatInline(checkbox[2])}`;
+        }
+        const ordered = result.match(/^(\d+)[.)]\s+(.+)$/);
+        if (ordered) {
+            return ` ${pc.yellow(ordered[1])}. ${this.formatInline(ordered[2])}`;
+        }
+        const bullet = result.match(/^[-*]\s+(.+)$/);
+        if (bullet) {
+            return ` ${pc.dim('•')} ${this.formatInline(bullet[1])}`;
+        }
+        return this.formatInline(result);
+    }
+    formatInline(text) {
+        const codeSpans = [];
+        let result = text.replace(/`([^`]+)`/g, (_m, c) => {
+            codeSpans.push(pc.yellow(c));
+            return `\u0000${codeSpans.length - 1}\u0000`;
+        });
+        result = result.replace(/\*\*(.+?)\*\*/g, (_, s) => pc.bold(s));
+        result = result.replace(/~~(.+?)~~/g, (_, s) => pc.strikethrough(s));
+        result = result.replace(/\*([^*]+)\*/g, (_, s) => pc.italic(s));
+        result = result.replace(/(^|\s)_([^_\n]+)_(?=\s|$)/g, (_m, pre, s) => pre + pc.italic(s));
+        result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => {
+            const short = url.length > 80 ? url.slice(0, 77) + '…' : url;
+            return `${pc.cyan(label)} ${pc.dim(`(${short})`)}`;
+        });
+        result = result.replace(/\u0000(\d+)\u0000/g, (_m, i) => codeSpans[Number(i)]);
+        return result;
+    }
+}
+export function formatMarkdown(text) {
+    const lines = [];
+    const stream = new FormattingStream((l) => lines.push(l));
+    stream.write(text);
+    stream.flush();
+    return lines.join('\n');
+}
+export function formatError(text) {
+    return pc.red(pc.bold(t('ui.error_prefix')) + text);
+}
+export function formatSuccess(text) {
+    return pc.green(pc.bold(t('ui.success_prefix')) + text);
+}
+export function formatWarning(text) {
+    return pc.yellow(pc.bold(t('ui.warning_prefix')) + text);
+}

package/dist/ui/output.js

@@ -0,0 +1,13 @@
+import { formatMarkdown, formatError, formatSuccess, formatWarning } from './md-formatter';
+export function writeOutput(text) {
+    process.stdout.write(formatMarkdown(text) + '\n');
+}
+export function writeError(text) {
+    process.stderr.write(formatError(text) + '\n');
+}
+export function writeSuccess(text) {
+    process.stdout.write(formatSuccess(text) + '\n');
+}
+export function writeWarning(text) {
+    process.stdout.write(formatWarning(text) + '\n');
+}

package/dist/ui/renderer.js

@@ -0,0 +1,141 @@
+import { pc } from "./colors";
+import { FormattingStream } from "./md-formatter";
+import { Spinner } from "./spinner";
+import { box } from "./box";
+import { getTerminalWidth } from "./table";
+import { t } from "../i18n/index";
+export function isRichTerminal() {
+    return Boolean(process.stdout.isTTY) && !process.env.CI;
+}
+/** Short human-friendly summary of tool arguments. */
+export function summarizeArgs(args) {
+    const preferred = ["path", "file", "query", "url", "command", "name"];
+    for (const key of preferred) {
+        const value = args[key];
+        if (typeof value === "string" && value) {
+            return value.length > 60 ? `${value.slice(0, 57)}…` : value;
+        }
+    }
+    const serialized = JSON.stringify(args);
+    if (!serialized || serialized === "{}")
+        return "";
+    return serialized.length > 60 ? `${serialized.slice(0, 57)}…` : serialized;
+}
+function friendlyTool(tool) {
+    const key = `tool.friendly.${tool}`;
+    const value = t(key);
+    return value !== key ? value : tool;
+}
+/**
+ * Streams agent events to the terminal. Rich mode (TTY) adds a spinner
+ * and boxed tool cards; plain mode falls back to simple prefixed lines.
+ * Colors come from `colors.ts`, disabled outside a TTY, in CI, or on NO_COLOR.
+ */
+export class Renderer {
+    rich;
+    spinner;
+    fmt;
+    out;
+    err;
+    width;
+    card = null;
+    constructor(opts = {}) {
+        this.rich = opts.rich ?? isRichTerminal();
+        this.out = opts.out ?? process.stdout;
+        this.err = opts.err ?? process.stderr;
+        this.width = opts.width ?? getTerminalWidth();
+        this.spinner = new Spinner({
+            enabled: this.rich && (opts.spinner ?? true),
+            stream: this.err,
+            width: this.width,
+        });
+        this.fmt = new FormattingStream((line) => this.out.write(`${line}\n`), this.width);
+    }
+    /** Final answer streamed from the model (markdown-formatted). */
+    text(chunk) {
+        this.endCard();
+        this.spinner.stop();
+        this.fmt.write(chunk);
+    }
+    /** Arbitrary status/meta text (tool output, reasoning, MoE status). */
+    meta(chunk) {
+        this.spinner.stop();
+        if (this.card) {
+            this.card.body.push(chunk);
+        }
+        else {
+            this.out.write(chunk);
+        }
+    }
+    /** Dimmed reasoning stream (already colored by the agent). */
+    reasoning(chunk) {
+        this.spinner.stop();
+        this.out.write(pc.dim(chunk));
+    }
+    /** Model is loading / generating — show the thinking spinner. */
+    thinkingStart() {
+        this.spinner.start(t("ui.thinking"));
+    }
+    /** LLM call finished; clear the thinking spinner. */
+    thinkingEnd() {
+        this.spinner.stop();
+    }
+    toolStart(tool, args) {
+        this.endCard();
+        this.spinner.stop();
+        const summary = summarizeArgs(args);
+        if (!this.rich) {
+            this.out.write(`\n${pc.dim("⚙")} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}\n`);
+            return;
+        }
+        this.card = { tool, args, body: [], start: Date.now() };
+        this.spinner.start(`${pc.dim("⚙")} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}`);
+    }
+    toolEnd(_tool, duration, error) {
+        this.spinner.stop();
+        if (!this.rich)
+            return;
+        if (!this.card)
+            return;
+        const { tool, args, body } = this.card;
+        const lines = [];
+        const summary = summarizeArgs(args);
+        if (summary)
+            lines.push(pc.dim(summary));
+        for (const chunk of body) {
+            for (const line of chunk.split("\n")) {
+                if (line.trim() !== "")
+                    lines.push(line);
+            }
+        }
+        const marker = error ? pc.red("✗") : pc.green("✓");
+        lines.push(`${marker} ${pc.dim(`${duration}ms`)}`);
+        const title = `${marker} ${friendlyTool(tool)}`;
+        for (const line of box(lines, { title, width: this.width })) {
+            this.out.write(`${line}\n`);
+        }
+        this.card = null;
+    }
+    /** Raw pre-formatted text (diff blocks, warnings). */
+    raw(text) {
+        this.endCard();
+        this.spinner.stop();
+        this.out.write(text);
+    }
+    error(text) {
+        this.endCard();
+        this.spinner.stop();
+        this.err.write(`${pc.red(text)}\n`);
+    }
+    flush() {
+        this.endCard();
+        this.spinner.stop();
+        this.fmt.flush();
+    }
+    endCard() {
+        if (!this.card)
+            return;
+        const { tool, start } = this.card;
+        this.toolEnd(tool, Date.now() - start, true);
+    }
+}

package/dist/ui/spinner.js

@@ -0,0 +1,70 @@
+import { pc } from "./colors";
+import stringWidth from "string-width";
+import { getTerminalWidth } from "./table";
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export function isSpinnerSupported(stream) {
+    const s = stream ?? process.stderr;
+    return Boolean(s.isTTY) && !process.env.CI;
+}
+/**
+ * Zero-dependency ANSI spinner. Writes to stderr using a single
+ * overwritten line (`\r` + text + clear-to-end). Disabled automatically
+ * when the target stream is not a TTY.
+ */
+export class Spinner {
+    timer = null;
+    frame = 0;
+    message = "";
+    enabled;
+    stream;
+    intervalMs;
+    width;
+    constructor(opts = {}) {
+        this.stream = opts.stream ?? process.stderr;
+        this.enabled = opts.enabled ?? isSpinnerSupported(this.stream);
+        this.intervalMs = opts.intervalMs ?? 80;
+        this.width = opts.width ?? getTerminalWidth();
+    }
+    get running() {
+        return this.timer !== null;
+    }
+    start(message) {
+        if (!this.enabled)
+            return;
+        this.stop();
+        this.message = this.truncate(message);
+        this.frame = 0;
+        this.timer = setInterval(() => this.tick(), this.intervalMs);
+        this.tick();
+    }
+    setMessage(message) {
+        this.message = this.truncate(message);
+        if (this.timer)
+            this.tick();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+            this.stream.write("\r\x1b[K");
+        }
+    }
+    truncate(text) {
+        if (stringWidth(text) <= this.width - 2)
+            return text;
+        let acc = "";
+        for (const ch of text) {
+            if (stringWidth(acc + ch) > this.width - 3)
+                break;
+            acc += ch;
+        }
+        return acc + "…";
+    }
+    tick() {
+        if (!this.timer)
+            return;
+        const frame = FRAMES[this.frame % FRAMES.length];
+        this.frame++;
+        this.stream.write("\r" + pc.cyan(frame) + " " + this.message + "\x1b[K");
+    }
+}