mistagent 0.1.18 → 0.1.20

package/dist/src/utils/fileTunnel.js

@@ -110,6 +110,95 @@ export async function executeFileOperation(req) {
                 });
                 break;
             }
+            // ─── code_search 工具（Codebase Investigator 子图） ───
+            case 'grep_search': {
+                const pattern = req.args.pattern;
+                const searchPath = req.args.path || '.';
+                const include = req.args.include || '';
+                const contextLines = parseInt(req.args.context_lines || '2', 10);
+                if (!pattern) {
+                    return fail(req, 'Missing required argument: pattern');
+                }
+                const { execSync } = await import('node:child_process');
+                const cmd = ['grep', '-rn', '--color=never'];
+                if (contextLines > 0)
+                    cmd.push('-C', String(Math.min(contextLines, 5)));
+                if (include)
+                    cmd.push('--include', include);
+                IGNORE_DIRS.forEach((d) => cmd.push('--exclude-dir', d));
+                cmd.push(pattern, searchPath);
+                try {
+                    const stdout = execSync(cmd.join(' '), {
+                        encoding: 'utf-8',
+                        timeout: 30_000,
+                        maxBuffer: 10 * 1024 * 1024,
+                    });
+                    const lines = stdout.split('\n');
+                    result = lines.length > 200
+                        ? lines.slice(0, 200).join('\n') + `\n\n... (结果已截断，共 ${lines.length} 行，显示前 200 行)`
+                        : stdout;
+                }
+                catch (err) {
+                    const exitCode = err.status;
+                    if (exitCode === 1) {
+                        result = `未找到匹配 '${pattern}' 的结果`;
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                break;
+            }
+            case 'find_files': {
+                const pattern = req.args.pattern;
+                const searchPath = req.args.path || '.';
+                if (!pattern) {
+                    return fail(req, 'Missing required argument: pattern');
+                }
+                const root = path.resolve(searchPath);
+                if (!fs.existsSync(root)) {
+                    return fail(req, `路径不存在: ${searchPath}`);
+                }
+                const found = globFiles(root, pattern, 100);
+                result = found.length > 0 ? found.join('\n') : `未找到匹配 '${pattern}' 的文件`;
+                break;
+            }
+            case 'directory_tree': {
+                const treePath = req.args.path || '.';
+                const maxDepth = Math.min(parseInt(req.args.max_depth || '3', 10), 4);
+                const root = path.resolve(treePath);
+                if (!fs.existsSync(root)) {
+                    return fail(req, `路径不存在: ${treePath}`);
+                }
+                result = buildTree(root, maxDepth);
+                break;
+            }
+            case 'replace_in_file': {
+                const filePath = req.args.file_path;
+                const oldStr = req.args.old_string ?? '';
+                const newStr = req.args.new_string ?? '';
+                const allowMultiple = req.args.allow_multiple === 'true';
+                if (!filePath) {
+                    return fail(req, 'Missing required argument: file_path');
+                }
+                if (!fs.existsSync(filePath)) {
+                    return fail(req, `File not found: ${filePath}`);
+                }
+                if (oldStr === newStr) {
+                    return fail(req, 'old_string and new_string are identical');
+                }
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const replaceResult = calculateReplacement(content, oldStr, newStr, allowMultiple);
+                if (replaceResult.occurrences === 0) {
+                    return fail(req, 'No match found for old_string in the file.');
+                }
+                if (replaceResult.strategy.includes('error')) {
+                    return fail(req, `Found ${replaceResult.occurrences} occurrences but allow_multiple=false.`);
+                }
+                fs.writeFileSync(filePath, replaceResult.newContent, 'utf-8');
+                result = `Replaced ${replaceResult.occurrences} occurrence(s) in ${filePath} (strategy: ${replaceResult.strategy})`;
+                break;
+            }
             default:
                 return fail(req, `Unknown tool: ${req.tool_name}`);
         }
@@ -125,17 +214,216 @@ export async function executeFileOperation(req) {
         return fail(req, errorMsg);
     }
 }
+function exactReplace(content, oldStr, newStr, allowMultiple) {
+    const norm = content.replace(/\r\n/g, '\n');
+    const oldNorm = oldStr.replace(/\r\n/g, '\n');
+    const count = norm.split(oldNorm).length - 1;
+    if (count === 0)
+        return null;
+    if (count > 1 && !allowMultiple) {
+        return { newContent: content, occurrences: count, strategy: 'exact_multiple_error' };
+    }
+    const newNorm = newStr.replace(/\r\n/g, '\n');
+    const result = allowMultiple
+        ? norm.split(oldNorm).join(newNorm)
+        : norm.replace(oldNorm, newNorm);
+    return { newContent: result, occurrences: allowMultiple ? count : 1, strategy: 'exact' };
+}
+function flexibleReplace(content, oldStr, newStr, allowMultiple) {
+    const contentLines = content.replace(/\r\n/g, '\n').split('\n');
+    const searchLines = oldStr.replace(/\r\n/g, '\n').split('\n');
+    const replaceLines = newStr.replace(/\r\n/g, '\n').split('\n');
+    const strippedSearch = searchLines.map((l) => l.trim());
+    if (!strippedSearch[0])
+        return null;
+    const matches = [];
+    let i = 0;
+    while (i <= contentLines.length - searchLines.length) {
+        let matched = true;
+        for (let j = 0; j < strippedSearch.length; j++) {
+            if (contentLines[i + j].trim() !== strippedSearch[j]) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched) {
+            matches.push(i);
+            i += searchLines.length;
+        }
+        else {
+            i++;
+        }
+    }
+    if (matches.length === 0)
+        return null;
+    if (matches.length > 1 && !allowMultiple) {
+        return { newContent: content, occurrences: matches.length, strategy: 'flexible_multiple_error' };
+    }
+    const targets = allowMultiple ? matches : [matches[0]];
+    const resultLines = [...contentLines];
+    for (const start of [...targets].reverse()) {
+        const firstLine = contentLines[start];
+        const indent = firstLine.slice(0, firstLine.length - firstLine.trimStart().length);
+        const indented = replaceLines.map((r, k) => k === 0 ? indent + r.trimStart() : (r.trim() ? indent + r : r));
+        resultLines.splice(start, searchLines.length, ...indented);
+    }
+    return { newContent: resultLines.join('\n'), occurrences: targets.length, strategy: 'flexible' };
+}
+function regexReplace(content, oldStr, newStr, allowMultiple) {
+    const norm = content.replace(/\r\n/g, '\n');
+    const oldNorm = oldStr.replace(/\r\n/g, '\n').trim();
+    if (!oldNorm)
+        return null;
+    const tokens = oldNorm.split(/([():\[\]{}<>=,;])/).filter(Boolean).map((t) => t.trim()).filter(Boolean);
+    const parts = tokens.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    if (parts.length === 0)
+        return null;
+    const pattern = '([ \\t]*)' + parts.join('\\s*');
+    let globalRegex;
+    try {
+        globalRegex = new RegExp(pattern, 'gm');
+    }
+    catch {
+        return null;
+    }
+    const matches = [];
+    let m;
+    let lastIndex = 0;
+    while ((m = globalRegex.exec(norm)) !== null) {
+        matches.push(m);
+        if (!allowMultiple)
+            break;
+        if (globalRegex.lastIndex === lastIndex)
+            globalRegex.lastIndex++;
+        lastIndex = globalRegex.lastIndex;
+    }
+    if (matches.length === 0)
+        return null;
+    if (matches.length > 1 && !allowMultiple) {
+        return { newContent: content, occurrences: matches.length, strategy: 'regex_multiple_error' };
+    }
+    const newNorm = newStr.replace(/\r\n/g, '\n');
+    let result = norm;
+    for (const match of [...matches].reverse()) {
+        const indent = match[1] || '';
+        const indented = newNorm.split('\n').map((line, idx) => idx > 0 && line.trim() ? indent + line : line).join('\n');
+        result = result.slice(0, match.index) + indent + indented.trimStart() + result.slice(match.index + match[0].length);
+    }
+    return { newContent: result, occurrences: matches.length, strategy: 'regex' };
+}
+function levenshteinDistance(s1, s2) {
+    if (s1.length < s2.length)
+        return levenshteinDistance(s2, s1);
+    if (s2.length === 0)
+        return s1.length;
+    let prevRow = Array.from({ length: s2.length + 1 }, (_, i) => i);
+    for (let i = 0; i < s1.length; i++) {
+        const currRow = [i + 1];
+        for (let j = 0; j < s2.length; j++) {
+            currRow.push(Math.min(prevRow[j + 1] + 1, currRow[j] + 1, prevRow[j] + (s1[i] !== s2[j] ? 1 : 0)));
+        }
+        prevRow = currRow;
+    }
+    return prevRow[s2.length];
+}
+function fuzzyReplace(content, oldStr, newStr, allowMultiple) {
+    if (oldStr.trim().length < 10)
+        return null;
+    const norm = content.replace(/\r\n/g, '\n');
+    const oldNorm = oldStr.replace(/\r\n/g, '\n');
+    const sourceLines = norm.split('\n');
+    const searchLines = oldNorm.split('\n');
+    const nSearch = searchLines.length;
+    if (nSearch === 0 || sourceLines.length * oldNorm.length ** 2 > 4e8)
+        return null;
+    const searchBlock = oldNorm.replace(/\s/g, '');
+    if (searchBlock.length === 0)
+        return null;
+    const candidates = [];
+    for (let i = 0; i <= sourceLines.length - nSearch; i++) {
+        const window = sourceLines.slice(i, i + nSearch).join('\n');
+        const windowStripped = window.replace(/\s/g, '');
+        if (Math.abs(windowStripped.length - searchBlock.length) > searchBlock.length * 0.2)
+            continue;
+        const dNorm = levenshteinDistance(windowStripped, searchBlock);
+        const dRaw = levenshteinDistance(window, oldNorm);
+        const weighted = dNorm + (dRaw - dNorm) * 0.1;
+        const score = weighted / searchBlock.length;
+        if (score <= 0.1)
+            candidates.push({ score, start: i });
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => a.score - b.score);
+    const selected = [];
+    const usedLines = new Set();
+    for (const { start } of candidates) {
+        let overlap = false;
+        for (let l = start; l < start + nSearch; l++) {
+            if (usedLines.has(l)) {
+                overlap = true;
+                break;
+            }
+        }
+        if (overlap)
+            continue;
+        selected.push(start);
+        for (let l = start; l < start + nSearch; l++)
+            usedLines.add(l);
+        if (!allowMultiple)
+            break;
+    }
+    if (selected.length === 0)
+        return null;
+    const newNorm = newStr.replace(/\r\n/g, '\n');
+    const resultLines = [...sourceLines];
+    for (const start of [...selected].sort((a, b) => b - a)) {
+        const firstLine = sourceLines[start];
+        const indent = firstLine.slice(0, firstLine.length - firstLine.trimStart().length);
+        const replLines = newNorm.split('\n').map((r, k) => k === 0 ? indent + r.trimStart() : (r.trim() ? indent + r : r));
+        resultLines.splice(start, nSearch, ...replLines);
+    }
+    return { newContent: resultLines.join('\n'), occurrences: selected.length, strategy: 'fuzzy' };
+}
+function calculateReplacement(content, oldStr, newStr, allowMultiple) {
+    if (!oldStr)
+        return { newContent: content, occurrences: 0, strategy: 'none' };
+    for (const fn of [exactReplace, flexibleReplace, regexReplace, fuzzyReplace]) {
+        const r = fn(content, oldStr, newStr, allowMultiple);
+        if (r && (r.occurrences > 0 || r.strategy.includes('error')))
+            return r;
+    }
+    return { newContent: content, occurrences: 0, strategy: 'none' };
+}
 // ─── 敏感操作判断 ───
-const SENSITIVE_TOOLS = new Set([
+/** 始终需要确认的写入/修改工具 */
+const WRITE_TOOLS = new Set([
     'write_file',
+    'replace_in_file',
     'file_delete',
     'move_file',
     'copy_file',
-    'bash_shell_run',
 ]);
-/** 是否为需要用户确认的敏感操作 */
-export function isSensitiveOperation(toolName) {
-    return SENSITIVE_TOOLS.has(toolName);
+/**
+ * 只读 bash 命令模式 — 匹配 grep, find, cat, head, tail, ls, wc, git log/diff/show 等
+ * 这些命令在 plan 研究阶段可自动放行
+ */
+const READONLY_CMD_RE = /^\s*(grep|rg|find|cat|head|tail|less|ls|tree|wc|file|stat|which|echo|pwd|env|git\s+(log|diff|show|status|branch|remote|tag|blame|rev-parse))\b/;
+/**
+ * 是否为需要用户确认的敏感操作
+ * - 写入/修改工具：始终 sensitive
+ * - bash_shell_run：只读命令不 sensitive，其他命令 sensitive
+ * - read_file / list_directory 等只读工具：不 sensitive
+ */
+export function isSensitiveOperation(toolName, args) {
+    if (WRITE_TOOLS.has(toolName))
+        return true;
+    if (toolName === 'bash_shell_run') {
+        const cmd = args?.command || '';
+        // 只读命令自动放行
+        return !READONLY_CMD_RE.test(cmd);
+    }
+    return false;
 }
 /**
  * 是否为无论 session 设置都必须确认的高危操作
@@ -152,6 +440,89 @@ export function isAlwaysConfirmRequired(req) {
     }
     return false;
 }
+// ─── code_search 辅助 ───
+const IGNORE_DIRS = new Set([
+    'node_modules', '.git', '__pycache__', '.venv', 'venv',
+    '.tox', '.mypy_cache', '.pytest_cache', 'dist', 'build',
+    '.next', '.nuxt', 'target', 'vendor',
+]);
+/** 递归 glob 匹配文件，返回相对路径列表 */
+function globFiles(root, pattern, maxResults) {
+    const results = [];
+    function walk(dir) {
+        if (results.length >= maxResults)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (results.length >= maxResults)
+                break;
+            if (IGNORE_DIRS.has(entry.name) || entry.name.startsWith('.'))
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (entry.isFile() && minimatch(path.relative(root, full), pattern)) {
+                results.push(path.relative(root, full));
+            }
+        }
+    }
+    walk(root);
+    return results;
+}
+/** 简易 glob 匹配（不依赖外部库，支持 *, **, ? 模式） */
+function minimatch(filePath, pattern) {
+    // 将 glob 转为正则
+    let re = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // 转义特殊字符
+        .replace(/\*\*/g, '{{GLOBSTAR}}') // 占位 **
+        .replace(/\*/g, '[^/]*') // * → 匹配非 / 字符
+        .replace(/\?/g, '[^/]') // ? → 匹配单个非 / 字符
+        .replace(/\{\{GLOBSTAR\}\}/g, '.*'); // ** → 匹配任意路径
+    re = '^' + re + '$';
+    return new RegExp(re).test(filePath);
+}
+/** 构建缩进的目录树文本 */
+function buildTree(root, maxDepth) {
+    const lines = [path.basename(root) + '/'];
+    function walk(dir, prefix, depth) {
+        if (depth >= maxDepth)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries = entries
+            .filter((e) => !IGNORE_DIRS.has(e.name) && !e.name.startsWith('.'))
+            .sort((a, b) => {
+            if (a.isDirectory() !== b.isDirectory())
+                return a.isDirectory() ? -1 : 1;
+            return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
+        });
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            const isLast = i === entries.length - 1;
+            const connector = isLast ? '└── ' : '├── ';
+            const suffix = entry.isDirectory() ? '/' : '';
+            lines.push(`${prefix}${connector}${entry.name}${suffix}`);
+            if (entry.isDirectory()) {
+                const extension = isLast ? '    ' : '│   ';
+                walk(path.join(dir, entry.name), prefix + extension, depth + 1);
+            }
+        }
+    }
+    walk(root, '', 0);
+    return lines.join('\n');
+}
 function fail(req, error) {
     return {
         request_id: req.request_id,

package/dist/src/utils/markdown.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Custom markdown-to-ANSI renderer.
+ *
+ * Replaces `marked-terminal` with a hand-rolled `formatToken()` pipeline
+ * (modelled after Claude Code's `utils/markdown.ts`).  Gives us full control
+ * over styling, performance (token caching + plain-text fast-path), and
+ * terminal-width responsiveness.
+ */
+export declare function applyMarkdown(content: string): string;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/src/utils/markdown.js

@@ -0,0 +1,223 @@
+/**
+ * Custom markdown-to-ANSI renderer.
+ *
+ * Replaces `marked-terminal` with a hand-rolled `formatToken()` pipeline
+ * (modelled after Claude Code's `utils/markdown.ts`).  Gives us full control
+ * over styling, performance (token caching + plain-text fast-path), and
+ * terminal-width responsiveness.
+ */
+import chalk from 'chalk';
+import { marked } from 'marked';
+import { highlight as cliHighlight, supportsLanguage } from 'cli-highlight';
+import stripAnsi from 'strip-ansi';
+import stringWidth from 'string-width';
+import { palette } from './colors.js';
+const EOL = '\n';
+// ── marked configuration (run once) ────────────────────────────
+let configured = false;
+function configureMarked() {
+    if (configured)
+        return;
+    configured = true;
+    // Disable strikethrough — models use ~ for "approximately"
+    marked.use({ tokenizer: { del() { return undefined; } } });
+}
+// ── LRU token cache ────────────────────────────────────────────
+const TOKEN_CACHE_MAX = 256;
+const tokenCache = new Map();
+// Quick regex test: does the string contain any markdown syntax?
+const MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|^\d+\. |\n\d+\. /;
+function cachedLexer(content) {
+    // Fast path: plain text → synthetic paragraph (skip full GFM parse)
+    const sample = content.length > 500 ? content.slice(0, 500) : content;
+    if (!MD_SYNTAX_RE.test(sample)) {
+        return [{
+                type: 'paragraph', raw: content, text: content,
+                tokens: [{ type: 'text', raw: content, text: content }],
+            }];
+    }
+    const key = content;
+    const hit = tokenCache.get(key);
+    if (hit) {
+        // promote to MRU
+        tokenCache.delete(key);
+        tokenCache.set(key, hit);
+        return hit;
+    }
+    const tokens = marked.lexer(content);
+    if (tokenCache.size >= TOKEN_CACHE_MAX) {
+        const first = tokenCache.keys().next().value;
+        if (first !== undefined)
+            tokenCache.delete(first);
+    }
+    tokenCache.set(key, tokens);
+    return tokens;
+}
+// ── Public API ─────────────────────────────────────────────────
+export function applyMarkdown(content) {
+    configureMarked();
+    // Strip internal heading markers
+    const cleaned = content.replace(/\{mist_session_heading:[^}]*\}\s*/g, '');
+    return cachedLexer(cleaned)
+        .map(t => formatToken(t))
+        .join('')
+        .trim();
+}
+// ── Token formatter ────────────────────────────────────────────
+function formatToken(token, listDepth = 0, orderedListNumber = null, parent = null) {
+    switch (token.type) {
+        // ── Headings ──────────────────────────────────────────────
+        case 'heading': {
+            const inner = children(token, 0, null, null);
+            switch (token.depth) {
+                case 1:
+                    return chalk.bold.italic.underline(inner) + EOL + EOL;
+                default:
+                    return chalk.bold(inner) + EOL + EOL;
+            }
+        }
+        // ── Emphasis ──────────────────────────────────────────────
+        case 'strong':
+            return chalk.bold(children(token, 0, null, parent));
+        case 'em':
+            return chalk.italic(children(token, 0, null, parent));
+        // ── Code ─────────────────────────────────────────────────
+        case 'code': {
+            const codeToken = token;
+            let highlighted;
+            if (codeToken.lang && supportsLanguage(codeToken.lang)) {
+                try {
+                    highlighted = cliHighlight(codeToken.text, { language: codeToken.lang });
+                }
+                catch {
+                    highlighted = codeToken.text;
+                }
+            }
+            else {
+                highlighted = codeToken.text;
+            }
+            return highlighted + EOL;
+        }
+        case 'codespan':
+            return chalk.hex(palette.info)(token.text);
+        // ── Blockquote ───────────────────────────────────────────
+        case 'blockquote': {
+            const inner = children(token, 0, null, null);
+            const bar = chalk.dim('│');
+            return inner
+                .split(EOL)
+                .map(line => stripAnsi(line).trim() ? `${bar} ${chalk.italic(line)}` : line)
+                .join(EOL);
+        }
+        // ── Lists ────────────────────────────────────────────────
+        case 'list':
+            return token.items
+                .map((item, i) => formatToken(item, listDepth, token.ordered ? (token.start ?? 1) + i : null, token))
+                .join('');
+        case 'list_item':
+            return (token.tokens ?? [])
+                .map(t => {
+                const indent = '  '.repeat(listDepth);
+                return `${indent}${formatToken(t, listDepth + 1, orderedListNumber, token)}`;
+            })
+                .join('');
+        // ── Paragraph / text ─────────────────────────────────────
+        case 'paragraph':
+            return children(token, 0, null, null) + EOL;
+        case 'text': {
+            if (parent?.type === 'list_item') {
+                const bullet = orderedListNumber === null
+                    ? '-'
+                    : `${orderedListNumber}.`;
+                const inner = token.tokens
+                    ? token.tokens.map(t => formatToken(t, listDepth, orderedListNumber, token)).join('')
+                    : token.text;
+                return `${bullet} ${inner}${EOL}`;
+            }
+            // If the text token has sub-tokens (e.g. bold inside text), render them
+            if (token.tokens) {
+                return token.tokens.map(t => formatToken(t, listDepth, orderedListNumber, token)).join('');
+            }
+            return token.text;
+        }
+        // ── Links ────────────────────────────────────────────────
+        case 'link': {
+            const linkToken = token;
+            if (linkToken.href.startsWith('mailto:')) {
+                return linkToken.href.replace(/^mailto:/, '');
+            }
+            const linkText = children(token, 0, null, token);
+            const plain = stripAnsi(linkText);
+            // If display text differs from URL, show both
+            if (plain && plain !== linkToken.href) {
+                return `${chalk.blue(plain)} ${chalk.dim(`(${linkToken.href})`)}`;
+            }
+            return chalk.blue.underline(linkToken.href);
+        }
+        case 'image':
+            return token.href;
+        // ── Table ────────────────────────────────────────────────
+        case 'table': {
+            const tableToken = token;
+            const getDisplay = (tokens) => stripAnsi(tokens?.map(t => formatToken(t)).join('') ?? '');
+            // Column widths
+            const colWidths = tableToken.header.map((h, i) => {
+                let max = stringWidth(getDisplay(h.tokens));
+                for (const row of tableToken.rows) {
+                    max = Math.max(max, stringWidth(getDisplay(row[i]?.tokens)));
+                }
+                return Math.max(max, 3);
+            });
+            // Header
+            let out = '| ';
+            tableToken.header.forEach((h, i) => {
+                const content = h.tokens?.map(t => formatToken(t)).join('') ?? '';
+                const display = getDisplay(h.tokens);
+                out += padCell(content, stringWidth(display), colWidths[i]) + ' | ';
+            });
+            out = out.trimEnd() + EOL;
+            // Separator
+            out += '|';
+            colWidths.forEach(w => { out += '-'.repeat(w + 2) + '|'; });
+            out += EOL;
+            // Rows
+            tableToken.rows.forEach(row => {
+                out += '| ';
+                row.forEach((cell, i) => {
+                    const content = cell.tokens?.map(t => formatToken(t)).join('') ?? '';
+                    const display = getDisplay(cell.tokens);
+                    out += padCell(content, stringWidth(display), colWidths[i]) + ' | ';
+                });
+                out = out.trimEnd() + EOL;
+            });
+            return out + EOL;
+        }
+        // ── Whitespace / misc ────────────────────────────────────
+        case 'space':
+            return EOL;
+        case 'br':
+            return EOL;
+        case 'hr':
+            return '---' + EOL;
+        case 'escape':
+            return token.text;
+        case 'html':
+        case 'def':
+        case 'del':
+            return '';
+    }
+    return '';
+}
+// ── Helpers ────────────────────────────────────────────────────
+/** Recursively render child tokens. */
+function children(token, listDepth, orderedListNumber, parent) {
+    return (token.tokens ?? [])
+        .map((t) => formatToken(t, listDepth, orderedListNumber, parent))
+        .join('');
+}
+/** Pad cell content to target width, preserving ANSI codes. */
+function padCell(content, displayWidth, targetWidth) {
+    const pad = targetWidth - displayWidth;
+    return pad > 0 ? content + ' '.repeat(pad) : content;
+}
+//# sourceMappingURL=markdown.js.map

package/dist/src/utils/updateChecker.js

@@ -39,9 +39,15 @@ export async function checkForUpdate() {
     }
 }
 export function formatUpdateMessage(info) {
-    return (`\x1b[33m╭───────────────────────────────────────╮\x1b[0m\n` +
-        `\x1b[33m│\x1b[0m  Update available: \x1b[90m${info.current}\x1b[0m → \x1b[32m${info.latest}\x1b[0m${' '.repeat(Math.max(0, 18 - info.current.length - info.latest.length))}\x1b[33m│\x1b[0m\n` +
-        `\x1b[33m│\x1b[0m  Run \x1b[36mnpm install -g ${PACKAGE_NAME}\x1b[0m to update  \x1b[33m│\x1b[0m\n` +
-        `\x1b[33m╰───────────────────────────────────────╯\x1b[0m`);
+    const line1 = `  Update available: ${info.current} → ${info.latest}  `;
+    const line2 = `  Run npm install -g ${PACKAGE_NAME} to update  `;
+    const width = Math.max(line1.length, line2.length);
+    const top = '─'.repeat(width);
+    const pad1 = ' '.repeat(Math.max(0, width - line1.length));
+    const pad2 = ' '.repeat(Math.max(0, width - line2.length));
+    return (`\x1b[33m╭${top}╮\x1b[0m\n` +
+        `\x1b[33m│\x1b[0m  Update available: \x1b[90m${info.current}\x1b[0m → \x1b[32m${info.latest}\x1b[0m  ${pad1}\x1b[33m│\x1b[0m\n` +
+        `\x1b[33m│\x1b[0m  Run \x1b[36mnpm install -g ${PACKAGE_NAME}\x1b[0m to update  ${pad2}\x1b[33m│\x1b[0m\n` +
+        `\x1b[33m╰${top}╯\x1b[0m`);
 }
 //# sourceMappingURL=updateChecker.js.map