moqi-tui 0.2.0

package/lib/tui/keys.js

@@ -0,0 +1,205 @@
+/**
+ * Key decoding for raw-mode stdin.
+ *
+ * Node hands the app raw bytes, so escape sequences have to be turned back
+ * into key names. The decoder is chunk-tolerant: a sequence split across two
+ * reads is held until it completes rather than being reported as a stray
+ * escape.
+ * @module
+ */
+const ESC = '';
+/** CSI final bytes mapped to key names. */
+const CSI_NAMES = {
+    A: 'up',
+    B: 'down',
+    C: 'right',
+    D: 'left',
+    H: 'home',
+    F: 'end',
+};
+/** `ESC [ n ~` tilde codes mapped to key names. */
+const TILDE_NAMES = {
+    '1': 'home',
+    '2': 'insert',
+    '3': 'delete',
+    '4': 'end',
+    '5': 'pageup',
+    '6': 'pagedown',
+    '7': 'home',
+    '8': 'end',
+    // Enter as a tilde code, so terminals speaking CSI-u can report
+    // ctrl+enter (`ESC [ 13;5 ~`) for interrupt-and-send.
+    '13': 'enter',
+};
+/** Modifier bitmask from a CSI parameter, per the xterm convention. */
+function modifiers(parameter) {
+    if (parameter === undefined)
+        return '';
+    const value = Number.parseInt(parameter, 10);
+    if (Number.isNaN(value))
+        return '';
+    const bits = value - 1;
+    let prefix = '';
+    if ((bits & 1) !== 0)
+        prefix += 'shift+';
+    if ((bits & 2) !== 0)
+        prefix += 'alt+';
+    if ((bits & 4) !== 0)
+        prefix += 'ctrl+';
+    return prefix;
+}
+/**
+ * Decode a buffer into keys, returning the keys and any trailing bytes that
+ * form an incomplete sequence.
+ */
+export function decode(input) {
+    const keys = [];
+    let index = 0;
+    while (index < input.length) {
+        const char = input[index] ?? '';
+        if (char === ESC) {
+            const rest = input.slice(index);
+            // A lone ESC at the very end may be the start of a longer sequence.
+            if (rest.length === 1)
+                return { keys, rest };
+            // SGR mouse report: ESC [ < button ; column ; row (M press | m release).
+            // Only the wheel is acted on; other buttons are swallowed so a click
+            // cannot leak into the composer as stray text.
+            if (rest.startsWith(`${ESC}[<`)) {
+                const mouse = /^\[<(\d+);(\d+);(\d+)([Mm])/.exec(rest);
+                if (mouse === null) {
+                    if (rest.length < 24)
+                        return { keys, rest };
+                    index += 1;
+                    continue;
+                }
+                const button = Number.parseInt(mouse[1] ?? '0', 10);
+                if (mouse[4] === 'M') {
+                    if (button === 64)
+                        keys.push({ name: 'wheelup', text: '' });
+                    else if (button === 65)
+                        keys.push({ name: 'wheeldown', text: '' });
+                }
+                index += mouse[0].length;
+                continue;
+            }
+            if (rest[1] === '[' || rest[1] === 'O') {
+                const match = /^[[O]([0-9;]*)([A-Za-z~])/.exec(rest);
+                if (match === null) {
+                    // Incomplete CSI: keep it for the next chunk, unless it is clearly junk.
+                    if (rest.length < 16)
+                        return { keys, rest };
+                    index += 1;
+                    continue;
+                }
+                const parameters = (match[1] ?? '').split(';');
+                const final = match[2] ?? '';
+                if (final === '~') {
+                    const name = TILDE_NAMES[parameters[0] ?? ''];
+                    if (name !== undefined)
+                        keys.push({ name: modifiers(parameters[1]) + name, text: '' });
+                }
+                else {
+                    const name = CSI_NAMES[final];
+                    if (name !== undefined)
+                        keys.push({ name: modifiers(parameters[1]) + name, text: '' });
+                }
+                index += match[0].length;
+                continue;
+            }
+            // alt+<char>
+            const next = rest[1] ?? '';
+            if (next >= ' ' && next <= '~') {
+                keys.push({ name: `alt+${next.toLowerCase()}`, text: '' });
+                index += 2;
+                continue;
+            }
+            keys.push({ name: 'esc', text: '' });
+            index += 1;
+            continue;
+        }
+        const code = char.codePointAt(0) ?? 0;
+        if (char === '\r' || char === '\n') {
+            keys.push({ name: 'enter', text: '' });
+            index += 1;
+            continue;
+        }
+        if (char === '\t') {
+            keys.push({ name: 'tab', text: '' });
+            index += 1;
+            continue;
+        }
+        if (code === 127 || code === 8) {
+            keys.push({ name: 'backspace', text: '' });
+            index += 1;
+            continue;
+        }
+        // Control characters map to ctrl+<letter>; ctrl+a is 0x01.
+        if (code < 32) {
+            const letter = String.fromCharCode(code + 96);
+            keys.push({ name: `ctrl+${letter}`, text: '' });
+            index += 1;
+            continue;
+        }
+        const point = String.fromCodePoint(code);
+        keys.push({ name: point, text: point });
+        index += point.length;
+    }
+    return { keys, rest: '' };
+}
+/**
+ * How long a lone escape waits for the rest of a sequence before it is read as
+ * the escape key.
+ *
+ * A terminal sends the same byte for "the user pressed Escape" and for the
+ * first byte of `ESC [ A`; only time tells them apart. Without this, a lone
+ * Escape produced no key at all and the *next* keystroke was misread as an
+ * `alt+` chord, so every documented `esc` — interrupt, close an overlay,
+ * dismiss a menu — was dead. Vim's own `ttimeoutlen` sits in this range.
+ */
+export const ESCAPE_DELAY_MS = 50;
+/**
+ * A stateful decoder that carries an incomplete sequence between chunks.
+ *
+ * @param emit - receives a key that arrives asynchronously (a flushed lone
+ *   escape), because no further chunk will carry it.
+ * @param escapeDelayMs - how long a lone escape waits; see {@link ESCAPE_DELAY_MS}.
+ */
+export function createDecoder(emit, escapeDelayMs = ESCAPE_DELAY_MS) {
+    let pending = '';
+    let timer;
+    const cancel = () => {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+    const decoder = ((chunk) => {
+        cancel();
+        const { keys, rest } = decode(pending + chunk);
+        pending = rest;
+        // A lone escape is ambiguous until time passes: it is either the key
+        // itself or the head of a sequence whose rest has not arrived.
+        if (pending === ESC && emit !== undefined) {
+            timer = setTimeout(() => {
+                timer = undefined;
+                if (pending === ESC) {
+                    pending = '';
+                    emit({ name: 'esc', text: '' });
+                }
+            }, escapeDelayMs);
+            // Never hold the process open for it.
+            timer.unref?.();
+        }
+        return keys;
+    });
+    decoder.flush = () => {
+        cancel();
+        if (pending === ESC) {
+            pending = '';
+            emit?.({ name: 'esc', text: '' });
+        }
+    };
+    decoder.dispose = cancel;
+    return decoder;
+}

package/lib/tui/markdown.js

@@ -0,0 +1,368 @@
+/**
+ * Markdown to ANSI rendering, plus a small syntax highlighter for fenced code.
+ *
+ * The original Go client leaned on glamour and chroma. This is the same job
+ * done with no dependency: the transcript is re-rendered on every frame and
+ * while a reply streams in, so the renderer must tolerate a half-written
+ * document (an unterminated fence, a dangling emphasis run) without throwing
+ * or swallowing text.
+ * @module
+ */
+import { colAccent, colGold, colGreen, colMuted, colRose, colText, style, } from "./theme.js";
+import { displayWidth, wrap } from "./text.js";
+/** Languages the highlighter knows keywords for. */
+const KEYWORDS = {
+    js: ['const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'class', 'new', 'await', 'async', 'import', 'export', 'from', 'try', 'catch', 'finally', 'throw', 'typeof', 'instanceof', 'this', 'null', 'undefined', 'true', 'false', 'switch', 'case', 'break', 'continue', 'default', 'extends', 'static', 'yield', 'delete', 'in', 'of'],
+    ts: ['const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'class', 'new', 'await', 'async', 'import', 'export', 'from', 'try', 'catch', 'finally', 'throw', 'typeof', 'instanceof', 'this', 'null', 'undefined', 'true', 'false', 'switch', 'case', 'break', 'continue', 'default', 'extends', 'implements', 'interface', 'type', 'enum', 'readonly', 'private', 'public', 'protected', 'static', 'satisfies', 'as', 'is', 'keyof', 'declare', 'namespace', 'yield', 'in', 'of'],
+    go: ['package', 'import', 'func', 'return', 'if', 'else', 'for', 'range', 'var', 'const', 'type', 'struct', 'interface', 'map', 'chan', 'go', 'defer', 'switch', 'case', 'default', 'break', 'continue', 'nil', 'true', 'false', 'select', 'fallthrough', 'goto'],
+    python: ['def', 'return', 'if', 'elif', 'else', 'for', 'while', 'import', 'from', 'as', 'class', 'try', 'except', 'finally', 'raise', 'with', 'lambda', 'None', 'True', 'False', 'and', 'or', 'not', 'in', 'is', 'pass', 'yield', 'global', 'nonlocal', 'assert', 'async', 'await', 'del'],
+    bash: ['if', 'then', 'else', 'elif', 'fi', 'for', 'in', 'do', 'done', 'while', 'case', 'esac', 'function', 'return', 'export', 'local', 'readonly', 'set', 'unset', 'echo', 'cd', 'exit', 'source'],
+    yaml: ['true', 'false', 'null', 'yes', 'no', 'on', 'off'],
+    json: ['true', 'false', 'null'],
+    rust: ['fn', 'let', 'mut', 'const', 'struct', 'enum', 'impl', 'trait', 'pub', 'use', 'mod', 'match', 'if', 'else', 'for', 'while', 'loop', 'return', 'self', 'Self', 'where', 'async', 'await', 'move', 'ref', 'dyn', 'true', 'false', 'crate', 'super', 'type', 'unsafe'],
+};
+/** Map a fence's info string onto a keyword set. */
+function languageOf(info) {
+    const name = info.trim().toLowerCase().split(/\s+/)[0] ?? '';
+    switch (name) {
+        case 'js':
+        case 'javascript':
+        case 'mjs':
+        case 'cjs':
+        case 'jsx':
+            return KEYWORDS['js'];
+        case 'ts':
+        case 'typescript':
+        case 'tsx':
+            return KEYWORDS['ts'];
+        case 'go':
+        case 'golang':
+            return KEYWORDS['go'];
+        case 'py':
+        case 'python':
+            return KEYWORDS['python'];
+        case 'sh':
+        case 'bash':
+        case 'zsh':
+        case 'shell':
+        case 'console':
+            return KEYWORDS['bash'];
+        case 'yaml':
+        case 'yml':
+            return KEYWORDS['yaml'];
+        case 'json':
+            return KEYWORDS['json'];
+        case 'rs':
+        case 'rust':
+            return KEYWORDS['rust'];
+        default:
+            return undefined;
+    }
+}
+const COMMENT_PREFIX = {
+    python: '#',
+    bash: '#',
+    yaml: '#',
+};
+/**
+ * Highlight one line of code. A deliberately small tokenizer: strings, line
+ * comments, numbers, and keywords. It never fails, so a language it does not
+ * know simply renders in the plain code color.
+ */
+function highlight(line, keywords, info) {
+    const name = info.trim().toLowerCase().split(/\s+/)[0] ?? '';
+    const hashComment = COMMENT_PREFIX[name] !== undefined;
+    let out = '';
+    let index = 0;
+    while (index < line.length) {
+        const rest = line.slice(index);
+        // Line comments run to the end of the line.
+        if ((hashComment && rest.startsWith('#')) || (!hashComment && rest.startsWith('//'))) {
+            out += style(rest, { fg: colMuted, italic: true });
+            break;
+        }
+        // String literals, single or double quoted, with backslash escapes.
+        const quote = rest[0];
+        if (quote === '"' || quote === "'" || quote === '`') {
+            let end = 1;
+            while (end < rest.length) {
+                if (rest[end] === '\\') {
+                    end += 2;
+                    continue;
+                }
+                if (rest[end] === quote) {
+                    end += 1;
+                    break;
+                }
+                end += 1;
+            }
+            out += style(rest.slice(0, end), { fg: colGold });
+            index += end;
+            continue;
+        }
+        // Identifiers and keywords.
+        const word = /^[A-Za-z_$][A-Za-z0-9_$]*/.exec(rest);
+        if (word !== null) {
+            const text = word[0];
+            out += keywords !== undefined && keywords.includes(text)
+                ? style(text, { fg: colAccent, bold: true })
+                : style(text, { fg: colText });
+            index += text.length;
+            continue;
+        }
+        // Numbers.
+        const number = /^\d[\d_.]*/.exec(rest);
+        if (number !== null) {
+            out += style(number[0], { fg: colRose });
+            index += number[0].length;
+            continue;
+        }
+        out += style(rest[0] ?? '', { fg: colMuted });
+        index += 1;
+    }
+    return out;
+}
+/** Render inline spans: code, bold, italic, strikethrough, and links. */
+export function renderInline(text) {
+    let out = '';
+    let index = 0;
+    while (index < text.length) {
+        const rest = text.slice(index);
+        const code = /^`([^`]+)`/.exec(rest);
+        if (code !== null) {
+            out += style(` ${code[1] ?? ''} `, { fg: colGold });
+            index += code[0].length;
+            continue;
+        }
+        const strong = /^\*\*([^*]+)\*\*/.exec(rest) ?? /^__([^_]+)__/.exec(rest);
+        if (strong !== null) {
+            out += style(strong[1] ?? '', { fg: colText, bold: true });
+            index += strong[0].length;
+            continue;
+        }
+        const strike = /^~~([^~]+)~~/.exec(rest);
+        if (strike !== null) {
+            out += style(strike[1] ?? '', { fg: colMuted, strike: true });
+            index += strike[0].length;
+            continue;
+        }
+        const emphasis = /^\*([^*]+)\*/.exec(rest) ?? /^_([^_]+)_/.exec(rest);
+        if (emphasis !== null) {
+            out += style(emphasis[1] ?? '', { fg: colText, italic: true });
+            index += emphasis[0].length;
+            continue;
+        }
+        const link = /^\[([^\]]*)\]\(([^)]+)\)/.exec(rest);
+        if (link !== null) {
+            out += style(link[1] ?? '', { fg: colOKish, underline: true });
+            out += style(` (${link[2] ?? ''})`, { fg: colMuted });
+            index += link[0].length;
+            continue;
+        }
+        out += text[index] ?? '';
+        index += 1;
+    }
+    return out;
+}
+// Declared after use above for readability of the inline renderer.
+const colOKish = colGreen;
+/** Split a document into blocks, tolerating an unterminated code fence. */
+function parse(source) {
+    const blocks = [];
+    const rows = source.replace(/\r\n/g, '\n').split('\n');
+    let index = 0;
+    while (index < rows.length) {
+        const line = rows[index] ?? '';
+        const fence = /^\s*(`{3,}|~{3,})(.*)$/.exec(line);
+        if (fence !== null) {
+            const marker = (fence[1] ?? '```').slice(0, 3);
+            const info = fence[2] ?? '';
+            const body = [];
+            index += 1;
+            while (index < rows.length) {
+                const candidate = rows[index] ?? '';
+                if (candidate.trimStart().startsWith(marker)) {
+                    index += 1;
+                    break;
+                }
+                body.push(candidate);
+                index += 1;
+            }
+            blocks.push({ kind: 'code', info, lines: body });
+            continue;
+        }
+        if (/^\s*$/.test(line)) {
+            index += 1;
+            continue;
+        }
+        if (/^\s*(?:---+|\*\*\*+|___+)\s*$/.test(line)) {
+            blocks.push({ kind: 'rule' });
+            index += 1;
+            continue;
+        }
+        const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (heading !== null) {
+            blocks.push({ kind: 'heading', level: (heading[1] ?? '#').length, text: heading[2] ?? '' });
+            index += 1;
+            continue;
+        }
+        if (/^\s*\|.*\|\s*$/.test(line)) {
+            const tableRows = [];
+            while (index < rows.length && /^\s*\|.*\|\s*$/.test(rows[index] ?? '')) {
+                const raw = (rows[index] ?? '').trim();
+                const cells = raw.slice(1, -1).split('|').map((cell) => cell.trim());
+                // Skip the alignment row that separates head from body.
+                if (!cells.every((cell) => /^:?-{2,}:?$/.test(cell)))
+                    tableRows.push(cells);
+                index += 1;
+            }
+            blocks.push({ kind: 'table', rows: tableRows });
+            continue;
+        }
+        const quote = /^\s*>\s?(.*)$/.exec(line);
+        if (quote !== null) {
+            const parts = [quote[1] ?? ''];
+            index += 1;
+            while (index < rows.length) {
+                const next = /^\s*>\s?(.*)$/.exec(rows[index] ?? '');
+                if (next === null)
+                    break;
+                parts.push(next[1] ?? '');
+                index += 1;
+            }
+            blocks.push({ kind: 'quote', text: parts.join('\n') });
+            continue;
+        }
+        const bullet = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/.exec(line);
+        if (bullet !== null) {
+            const items = [];
+            while (index < rows.length) {
+                const match = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/.exec(rows[index] ?? '');
+                if (match === null) {
+                    // A plain indented line continues the previous item.
+                    const continuation = /^\s{2,}(\S.*)$/.exec(rows[index] ?? '');
+                    const last = items[items.length - 1];
+                    if (continuation !== null && last !== undefined) {
+                        last.text += ` ${continuation[1] ?? ''}`;
+                        index += 1;
+                        continue;
+                    }
+                    break;
+                }
+                const indent = (match[1] ?? '').length;
+                const raw = match[2] ?? '-';
+                items.push({
+                    marker: /^\d/.test(raw) ? raw : '•',
+                    text: match[3] ?? '',
+                    depth: Math.floor(indent / 2),
+                });
+                index += 1;
+            }
+            blocks.push({ kind: 'list', items });
+            continue;
+        }
+        const paragraph = [line];
+        index += 1;
+        while (index < rows.length) {
+            const next = rows[index] ?? '';
+            if (/^\s*$/.test(next) ||
+                /^\s*(`{3,}|~{3,})/.test(next) ||
+                /^#{1,6}\s/.test(next) ||
+                /^\s*([-*+]|\d+[.)])\s/.test(next) ||
+                /^\s*>/.test(next) ||
+                /^\s*\|.*\|\s*$/.test(next))
+                break;
+            paragraph.push(next);
+            index += 1;
+        }
+        blocks.push({ kind: 'paragraph', text: paragraph.join(' ') });
+    }
+    return blocks;
+}
+/** Render a parsed block to styled lines at `width` columns. */
+function renderBlock(block, width) {
+    switch (block.kind) {
+        case 'heading': {
+            const prefix = block.level <= 1 ? '' : `${'#'.repeat(block.level)} `;
+            const text = `${prefix}${block.text}`;
+            const rendered = wrap(text, width).map((line) => style(line, { fg: block.level <= 2 ? colAccent : colText, bold: true }));
+            return block.level <= 2 ? [...rendered, style('─'.repeat(Math.min(width, displayWidth(text))), { fg: colBorderish })] : rendered;
+        }
+        case 'rule':
+            return [style('─'.repeat(width), { fg: colBorderish })];
+        case 'code': {
+            const keywords = languageOf(block.info);
+            const label = block.info.trim();
+            const head = label === ''
+                ? []
+                : [style(`  ${label}`, { fg: colMuted, italic: true })];
+            const body = block.lines.map((line) => {
+                const clipped = line.length > width - 4 ? line.slice(0, Math.max(width - 4, 0)) : line;
+                return `  ${style('│', { fg: colBorderish })} ${highlight(clipped, keywords, block.info)}`;
+            });
+            return [...head, ...body];
+        }
+        case 'quote':
+            return block.text
+                .split('\n')
+                .flatMap((line) => wrap(line, Math.max(width - 2, 8)))
+                .map((line) => `${style('┃', { fg: colMuted })} ${style(renderInline(line), { fg: colMuted, italic: true })}`);
+        case 'list':
+            return block.items.flatMap((item) => {
+                const indent = '  '.repeat(item.depth);
+                const bullet = style(item.marker, { fg: colAccent });
+                const body = wrap(renderInlineForWrap(item.text), Math.max(width - indent.length - 2, 8));
+                return body.map((line, position) => position === 0
+                    ? `${indent}${bullet} ${renderInline(line)}`
+                    : `${indent}  ${renderInline(line)}`);
+            });
+        case 'table': {
+            const columns = Math.max(...block.rows.map((row) => row.length), 0);
+            if (columns === 0)
+                return [];
+            const widths = [];
+            for (let column = 0; column < columns; column += 1) {
+                widths.push(Math.max(...block.rows.map((row) => displayWidth(row[column] ?? '')), 3));
+            }
+            // Shrink proportionally when the table is wider than the viewport.
+            const total = widths.reduce((sum, value) => sum + value + 3, 1);
+            if (total > width) {
+                const scale = (width - columns * 3 - 1) / (total - columns * 3 - 1);
+                for (let column = 0; column < columns; column += 1) {
+                    widths[column] = Math.max(Math.floor((widths[column] ?? 3) * scale), 3);
+                }
+            }
+            return block.rows.map((row, position) => {
+                const cells = widths.map((cellWidth, column) => {
+                    const value = row[column] ?? '';
+                    const clipped = displayWidth(value) > cellWidth ? `${value.slice(0, Math.max(cellWidth - 1, 0))}…` : value;
+                    return clipped + ' '.repeat(Math.max(cellWidth - displayWidth(clipped), 0));
+                });
+                const line = cells.join(style(' │ ', { fg: colBorderish }));
+                return position === 0 ? style(line, { fg: colText, bold: true }) : renderInline(line);
+            });
+        }
+        case 'paragraph':
+            return wrap(renderInlineForWrap(block.text), width).map((line) => renderInline(line));
+    }
+}
+/**
+ * Wrapping happens on the unstyled text, because escape codes would corrupt
+ * the width arithmetic; the inline renderer then runs per output line.
+ */
+function renderInlineForWrap(text) {
+    return text;
+}
+const colBorderish = colMuted;
+/** Render a markdown document to styled lines at `width` columns. */
+export function renderMarkdown(source, width) {
+    const safeWidth = Math.max(width, 4);
+    const blocks = parse(source);
+    const out = [];
+    blocks.forEach((block, index) => {
+        if (index > 0)
+            out.push('');
+        out.push(...renderBlock(block, safeWidth));
+    });
+    return out.join('\n');
+}

package/lib/tui/mcp.js

@@ -0,0 +1,95 @@
+/**
+ * `/mcp` formatting: which MCP servers' tools are actually mounted.
+ *
+ * The MCP client is a composition-level plugin — servers are declared in the
+ * profile, not registered through a queryable runtime API — so the honest view
+ * is the tool registry filtered to MCP-provided names. This module does the
+ * naming and grouping; the app layer does the probing.
+ * @module
+ */
+/**
+ * The separator conventions MCP bridges use in tool names.
+ *
+ * `mcp__server__tool` is the Claude-style double-underscore form; `server/tool`
+ * and `server:tool` appear in some bridges. Parsing all three means a server
+ * shows up whichever bridge mounted it.
+ */
+export function parseMcpToolName(name) {
+    if (name.startsWith('mcp__')) {
+        const rest = name.slice('mcp__'.length);
+        const at = rest.indexOf('__');
+        if (at <= 0 || at === rest.length - 2)
+            return undefined;
+        return { server: rest.slice(0, at), tool: rest.slice(at + 2) };
+    }
+    if (name.startsWith('mcp_')) {
+        const rest = name.slice('mcp_'.length);
+        const at = rest.indexOf('_');
+        if (at <= 0 || at === rest.length - 1)
+            return undefined;
+        return { server: rest.slice(0, at), tool: rest.slice(at + 1) };
+    }
+    for (const separator of ['/', ':']) {
+        const parts = name.split(separator);
+        // Exactly two segments, neither a path or a filename: `files/read` is a
+        // bridge, `src/tui/state.ts` is a path and must not become a server.
+        if (parts.length !== 2)
+            continue;
+        const [head, tail] = parts;
+        if (head.includes('.') || tail.includes('.'))
+            continue;
+        if (!/^[a-z0-9][a-z0-9_-]*$/i.test(head))
+            continue;
+        if (tail === '')
+            continue;
+        return { server: head, tool: tail };
+    }
+    return undefined;
+}
+/** Group tool names into their MCP servers, alphabetically by server then tool. */
+export function groupMcpTools(toolNames) {
+    const servers = new Map();
+    for (const name of toolNames) {
+        const parsed = parseMcpToolName(name);
+        if (parsed === undefined)
+            continue;
+        const list = servers.get(parsed.server) ?? [];
+        list.push(parsed.tool);
+        servers.set(parsed.server, list);
+    }
+    return [...servers.entries()]
+        .map(([name, tools]) => ({ name, tools: [...tools].sort() }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * The `/mcp` overlay body.
+ *
+ * @param servers - grouped MCP tools, from {@link groupMcpTools}.
+ * @param totalTools - every tool the registry offers, for the empty case.
+ */
+export function renderMcp(servers, totalTools) {
+    if (servers.length === 0) {
+        return [
+            '**MCP servers**',
+            '',
+            totalTools === 0
+                ? 'This profile exposes no tool registry to the app.'
+                : `No MCP-provided tools are mounted (${String(totalTools)} tools in total).`,
+            '',
+            'Servers are declared in the profile, not added at runtime:',
+            '',
+            '- `dsh plugin --profile tui add <mcp-bridge-package>`',
+            '- or an `mcp-client` entry in `$DSH_HOME/profiles/tui/cordis.patch.yml`',
+        ].join('\n');
+    }
+    const lines = ['**MCP servers**', ''];
+    const toolCount = servers.reduce((sum, server) => sum + server.tools.length, 0);
+    lines.push(`${String(servers.length)} server${servers.length === 1 ? '' : 's'}, ${String(toolCount)} tools`, '');
+    for (const server of servers) {
+        lines.push(`- **${server.name}** (${String(server.tools.length)})`);
+        for (const tool of server.tools)
+            lines.push(`  - \`${tool}\``);
+    }
+    lines.push('', 'Tools are granted by composition; nothing is added at runtime.');
+    return lines.join('\n');
+}