micro-models-agent 2.11.0 → 2.13.1

package/dist/ui/line-math.js

@@ -1,15 +1,19 @@
+// Математика строк редактора: ANSI-стрип, перенос по ширине, буфер↔экран маппинг.
 import stringWidth from "string-width";
 const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+/** Срезает ANSI-последовательности. */
 export function stripAnsi(s) {
     return s.replace(ANSI_RE, "");
 }
+/** Длина в символах (не в байтах/ячейках). */
 export function charLen(s) {
     return Array.from(s).length;
 }
+/** Перенос строки по ширине (по словам, CJK-корректно). */
 export function wrapLine(line, width, firstRowWidth) {
     const w = width > 0 ? width : 80;
-    // Only the FIRST visual row shares its screen line with something else
-    // (e.g. the prompt); every continuation row uses the full width.
+    // Только ПЕРВАЯ визуальная строка делит экранную строку с чем-то ещё
+    // (напр. с промптом); все продолжения — на полную ширину.
     let limit = firstRowWidth !== undefined && firstRowWidth > 0 ? firstRowWidth : w;
     const chars = Array.from(line);
     const rows = [];
@@ -54,6 +58,7 @@ export function wrapLine(line, width, firstRowWidth) {
     rows.push({ text: chars.slice(start).join(""), charStart: start });
     return rows;
 }
+/** Раскладка всех строк буфера в визуальные ряды. */
 export function buildLayout(lines, width, firstRowWidth) {
     const rows = [];
     for (let b = 0; b < lines.length; b++) {
@@ -63,6 +68,7 @@ export function buildLayout(lines, width, firstRowWidth) {
     }
     return rows;
 }
+/** Индекс визуального ряда по позиции буфера. */
 export function layoutIndexFor(rows, bufRow, col) {
     let idx = 0;
     for (let i = 0; i < rows.length; i++) {
@@ -71,11 +77,13 @@ export function layoutIndexFor(rows, bufRow, col) {
     }
     return idx;
 }
+/** Визуальная колонка по смещению в буфере. */
 export function visualColAt(rows, idx, col) {
     const r = rows[idx];
     const upTo = col - r.charStart;
     return stringWidth(Array.from(r.text).slice(0, upTo).join(""));
 }
+/** Смещение в буфере по визуальной колонке. */
 export function charOffsetFor(rows, idx, visualCol) {
     const r = rows[idx];
     const chars = Array.from(r.text);

package/dist/ui/md-formatter.js

@@ -1,7 +1,9 @@
+// Markdown-форматтер чата: стриминг строк, подсветка кода, таблицы (см. STYLE.md).
 import { pc } from "./colors";
 import stringWidth from "string-width";
 import { t } from "../i18n/index";
 import { formatTable, getTerminalWidth } from "./table";
+import { glyph } from "./theme";
 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;
@@ -11,8 +13,8 @@ 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));
+        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)));
@@ -46,6 +48,7 @@ function isTableRow(line) {
 function isHorizontalRule(line) {
     return /^(-{3,}|\*{3,}|_{3,})\s*$/.test(line.trim());
 }
+/** Стриминговый форматтер markdown в терминальные строки. */
 export class FormattingStream {
     buffer = "";
     inCodeBlock = false;
@@ -55,15 +58,15 @@ export class FormattingStream {
     onWrite;
     onRawWrite;
     width;
-    /** Display columns of the raw partial currently shown on the terminal. */
+    /** Колонок сырого партиала, показанного сейчас в терминале. */
     partialWritten = 0;
-    /** How many chars of the pending line have already been streamed raw. */
+    /** Сколько символов pending-строки уже стримлено сырьём. */
     streamedChars = 0;
-    /** Columns reserved on the left (caller prefix) so a partial never wraps. */
+    /** Колонок зарезервировано слева (префикс вызывающего), чтобы партиал не враппился. */
     reservedCols;
     /**
-     * Stream the current (not-yet-newline-terminated) line raw for live
-     * feedback. Off by default — offline callers use `formatMarkdown`.
+     * Стрим текущей (ещё не завершённой переводом строки) строки сырьём для живого
+     * фидбэка. По умолчанию выкл; офлайн-вызывающие используют `formatMarkdown`.
      */
     streamPartials;
     constructor(onWrite, width, onRawWrite, opts = {}) {
@@ -87,16 +90,15 @@ export class FormattingStream {
         }
     }
     /**
-     * Stream the pending line raw for real-time feedback; the formatted line
-     * replaces it once the newline arrives.
+     * Стримит pending-строку сырьём для real-time фидбэка; форматированная строка
+     * заменяет её по приходу перевода строки.
      *
-     * The replacement uses a RELATIVE cursor move (`\x1b[<cols>D`), which is only
-     * correct while the streamed text stays on the single visual line it started
-     * on. If the partial would exceed the terminal width it wraps and every
-     * relative move lands in the wrong place — the garbled output observed after
-     * the 1.0.0 output refactor (missing/swapped characters, leaked markers,
-     * broken tables). So streaming freezes at the last chunk that fits and the
-     * line is rendered when it completes.
+     * Замена — ОТНОСИТЕЛЬНЫМ движением курсора (`\x1b[<cols>D`), корректным лишь
+     * пока стримленный текст сидит на одной визуальной строке, с которой начал.
+     * Если партиал шире терминала, он враппится и каждый относительный сдвиг бьёт
+     * мимо — та самая битая выдача после рефактора вывода 1.0.0 (потерянные/
+     * переставленные символы, потёкшие маркеры, ломаные таблицы). Поэтому стрим
+     * замирает на последнем влезшем чанке, а строка рендерится по завершении.
      */
     streamPartial() {
         if (!this.streamPartials)
@@ -113,36 +115,36 @@ export class FormattingStream {
     }
     emitPartialRewind() {
         if (this.partialWritten > 0) {
-            // Move back over the streamed partial and erase any tail left by a
-            // shorter formatted replacement before the caller renders the line.
+            // Откат поверх стримленного партиала + стереть хвост, оставшийся от более
+            // короткой форматированной замены, до рендера строки вызывающим.
             this.onRawWrite(`\x1b[${this.partialWritten}D\x1b[K`);
             this.partialWritten = 0;
         }
         this.streamedChars = 0;
     }
-    /** True when there is displayed partial output or unprocessed buffered text. @internal */
+    /** Есть ли показанный партиал или необработанный буфер. @internal */
     hasPartial() {
         return this.partialWritten > 0 || this.buffer.length > 0 || this.tableBuffer.length > 0;
     }
     /**
-     * Finalize a displayed raw partial so the next write starts on a fresh line.
-     * Only the already-streamed partial is terminated (with a single newline via
-     * `onRawWrite`); any pending table buffer is flushed. An open code block is
-     * intentionally left untouched — closing it here would make the real closing
-     * fence look like a new opening fence and corrupt all following prose. The
-     * code block is emitted by the final `flush()`. Idempotent.
+     * Финализирует показанный сырой партиал, чтобы следующая запись началась с новой строки.
+     * Терминируется только уже стримленный партиал (одиночный перевод строки через
+     * `onRawWrite`); pending-буфер таблицы сбрасывается. Открытый кодовый блок
+     * осознанно не трогается: закрытие здесь сделало бы настоящий закрывающий fence
+     * похожим на новый открывающий и испортило бы всю прозу дальше. Блок эмитит
+     * финальный `flush()`. Идемпотентно.
      */
     flushPartialNow() {
         if (this.partialWritten > 0) {
-            // The line is already on screen raw; terminate it as-is (it may be
-            // interrupted mid-markdown) and drop it so it is not rendered twice.
+            // Строка уже на экране сырьём; терминируем как есть (может быть оборвана
+            // посреди markdown) и дропаем, чтобы не отрендерить дважды.
             this.onRawWrite("\n");
             this.partialWritten = 0;
             this.streamedChars = 0;
             this.buffer = "";
         }
         else if (this.buffer.length > 0 && !this.inCodeBlock) {
-            // Never streamed (plain mode) — render the pending line now.
+            // Не стримлено (plain-режим) — рендерим pending-строку сейчас.
             const line = this.buffer;
             this.buffer = "";
             this.streamedChars = 0;
@@ -158,8 +160,15 @@ export class FormattingStream {
         }
         if (this.inCodeBlock) {
             if (this.buffer.length > 0) {
-                this.codeLines.push(this.buffer);
-                this.buffer = "";
+                // Закрывающий fence в EOF без trailing newline: считаем закрытием, а не
+                // контентом кода (иначе "```" потечёт в блок).
+                if (this.buffer.trim().startsWith("```")) {
+                    this.buffer = "";
+                }
+                else {
+                    this.codeLines.push(this.buffer);
+                    this.buffer = "";
+                }
             }
             if (this.codeLines.length > 0) {
                 this.emitCodeBlock();
@@ -181,6 +190,10 @@ export class FormattingStream {
                 this.emitCodeBlock();
             }
             else {
+                // Pending-таблица не должна эмититься ПОСЛЕ идущего за ней кодового блока:
+                // сбрасываем до входа в fence.
+                if (this.tableBuffer.length > 0)
+                    this.flushTable();
                 this.inCodeBlock = true;
                 this.codeLang = line.trim().slice(3).trim();
                 this.codeLines = [];
@@ -220,19 +233,19 @@ export class FormattingStream {
         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);
+            // Без рамки: только dim-ярлык языка и левый гуттер. Коробочные кодовые
+            // блоки запрещены стилем чата (docs/design/ui/STYLE.md).
+            if (this.codeLang)
+                this.onWrite(pc.dim(`  ${this.codeLang}`));
             for (const l of highlighted.split("\n")) {
-                this.onWrite(pc.dim("│ ") + l);
+                this.onWrite(pc.dim(`${glyph.group} `) + l);
             }
-            this.onWrite(pc.dim(`└${"─".repeat(Math.max(0, this.width - 1))}┘`));
         }
         this.codeLines = [];
         this.codeLang = "";
     }
     formatLine(line) {
-        let result = line;
+        const result = line;
         const heading = result.match(/^(#{1,6})\s+(.+)$/);
         if (heading) {
             const level = heading[1].length;
@@ -272,18 +285,22 @@ export class FormattingStream {
             codeSpans.push(pc.yellow(c));
             return `\u0000${codeSpans.length - 1}\u0000`;
         });
+        // `***text***` (bold+italic) до одиночных `**`/`*`, иначе вложенность
+        // рвётся и во вложении остаётся висящая звёздочка.
+        result = result.replace(/\*\*\*(.+?)\*\*\*/g, (_, s) => pc.bold(pc.italic(s)));
         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;
+            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;
     }
 }
+/** Форматирует markdown-текст целиком в терминальные строки. */
 export function formatMarkdown(text) {
     const lines = [];
     const stream = new FormattingStream((l) => lines.push(l));
@@ -291,12 +308,15 @@ export function formatMarkdown(text) {
     stream.flush();
     return lines.join("\n");
 }
+/** Форматирует ошибку (красный префикс из i18n). */
 export function formatError(text) {
     return pc.red(pc.bold(t("ui.error_prefix")) + text);
 }
+/** Форматирует успех (зелёный префикс из i18n). */
 export function formatSuccess(text) {
     return pc.green(pc.bold(t("ui.success_prefix")) + text);
 }
+/** Форматирует предупреждение (жёлтый префикс из i18n). */
 export function formatWarning(text) {
     return pc.yellow(pc.bold(t("ui.warning_prefix")) + text);
 }

package/dist/ui/output.js

@@ -1,14 +1,19 @@
+// Короткие писатели в канал: markdown/ошибка/успех/предупреждение.
 import { getDefaultChannel } from "../output";
 import { formatMarkdown, formatError, formatSuccess, formatWarning } from "./md-formatter";
+/** Пишет markdown-текст в stdout. */
 export function writeOutput(text) {
-    getDefaultChannel().writeRaw(formatMarkdown(text) + "\n");
+    getDefaultChannel().writeRaw(`${formatMarkdown(text)}\n`);
 }
+/** Пишет ошибку в stderr. */
 export function writeError(text) {
-    getDefaultChannel().writeRaw(formatError(text) + "\n", "stderr");
+    getDefaultChannel().writeRaw(`${formatError(text)}\n`, "stderr");
 }
+/** Пишет успех в stdout. */
 export function writeSuccess(text) {
-    getDefaultChannel().writeRaw(formatSuccess(text) + "\n");
+    getDefaultChannel().writeRaw(`${formatSuccess(text)}\n`);
 }
+/** Пишет предупреждение блочной строкой. */
 export function writeWarning(text) {
     getDefaultChannel().writeLine(formatWarning(text));
 }

package/dist/ui/plan-view.js

@@ -1,10 +1,14 @@
+// Вид плана в чате: чтение active.json, чеклист с прогресс-баром, контекст шага.
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { pc } from "./colors";
+import { glyph } from "./theme";
 import { extractFileLikeTokens, stripUrls } from "../modules/hallucination/js-identifiers";
 import { t } from "../i18n/index";
+import { projectMmaDir } from "../config/paths";
+/** Читает активный план из .mma/plans/active.json. Нет/бит — null. */
 export function readActivePlan(baseDir) {
-    const p = join(baseDir, ".mma", "plans", "active.json");
+    const p = join(projectMmaDir(baseDir), "plans", "active.json");
     if (!existsSync(p))
         return null;
     try {
@@ -27,34 +31,36 @@ export function readActivePlan(baseDir) {
         return null;
     }
 }
+/** Индекс текущего шага (первый не done/skipped). */
 export function currentStepIndex(plan) {
     return plan.steps.findIndex((s) => s.status !== "done" && s.status !== "skipped");
 }
 function stepMark(step) {
     switch (step.status) {
         case "done":
-            return pc.green("[x]");
+            return pc.green(glyph.success);
         case "in_progress":
-            return pc.yellow("[*]");
+            return pc.cyan(glyph.action);
         case "failed":
-            return pc.red("[!]");
+            return pc.red(glyph.failure);
         case "skipped":
-            return pc.dim("[-]");
+            return pc.dim("–");
         default:
-            return pc.dim("[ ]");
+            return pc.dim("○");
     }
 }
+/** Рендерит чеклист плана с прогресс-баром ▰▱ построчно. */
 export function formatPlanChecklist(plan) {
     const done = plan.steps.filter((s) => s.status === "done" || s.status === "skipped").length;
     const total = plan.steps.length;
     const pct = total === 0 ? 0 : Math.round((done / total) * 100);
     const cur = currentStepIndex(plan);
-    const barLen = 15;
+    const barLen = 10;
     const filled = Math.round((pct / 100) * barLen);
-    const bar = pc.green("█".repeat(filled)) + pc.dim("░".repeat(barLen - filled));
+    const bar = pc.green("▰".repeat(filled)) + pc.dim("▱".repeat(barLen - filled));
     const title = plan.title.replace(/^\[\d+[^]]*\]\s*/, "");
     const lines = [
-        `${pc.cyan(`[${plan.id}]`)} ${pc.bold(title)}  ${bar} ${pc.dim(`${done}/${total} ${pct}%`)}`,
+        `${pc.cyan(glyph.action)} ${pc.bold(title)}  ${bar} ${pc.dim(`${done}/${total}`)}`,
     ];
     for (let i = 0; i < plan.steps.length; i++) {
         const step = plan.steps[i];
@@ -62,13 +68,14 @@ export function formatPlanChecklist(plan) {
         const desc = active ? pc.yellow(step.description) : pc.dim(step.description);
         lines.push(`  ${stepMark(step)} ${step.id}. ${desc}`);
         for (const sub of step.subtasks ?? []) {
-            lines.push(`      ${sub.done ? pc.green("[x]") : pc.dim("[ ]")} ${sub.text}`);
+            lines.push(`      ${sub.done ? pc.green(glyph.success) : pc.dim("○")} [${sub.id}] ${sub.text}`);
         }
     }
     return lines;
 }
 const STRUCTURAL_TOOLS = new Set([
     "plan",
+    "plan_step",
     "todo",
     "verify",
     "project_map",
@@ -78,6 +85,10 @@ const STRUCTURAL_TOOLS = new Set([
 function truncate(s, max = 48) {
     return s.length > max ? `${s.slice(0, max - 1)}…` : s;
 }
+/**
+ * Подбирает шаг плана под вызов тула по файловым токенам аргументов.
+ * Структурные тулы и вызовы без путей — null.
+ */
 export function stepContextForTool(plan, tool, args) {
     if (!plan || STRUCTURAL_TOOLS.has(tool))
         return null;