@deepseek-harness-tui/dsh-tui 0.6.0 → 0.7.0

package/lib/types/cc/markdown.js

@@ -1,9 +1,16 @@
-/* oxlint-disable typescript/no-unsafe-argument, typescript/no-unsafe-assignment,
-   typescript/no-unsafe-call, typescript/no-unsafe-member-access, typescript/no-unsafe-return,
-   typescript/restrict-plus-operands, typescript/no-unnecessary-condition,
-   typescript/no-non-null-assertion, typescript/no-unnecessary-type-assertion,
-   sonarjs/no-duplicated-branches
-   -- ported Claude Code renderer (upstream src/utils/markdown.ts); historical lint debt kept with upstream idioms, like vendor/ */
+/**
+ * Markdown-to-ANSI renderer over marked's token stream.
+ *
+ * Converts the shared marked lexer output into styled terminal text: quote
+ * gutters, syntax-highlighted fenced blocks, indented list bullets with
+ * depth-based numbering, and alignment-padded tables. The visual conventions
+ * (▎ bars for blockquotes, theme-colored inline code, OSC 8 hyperlinks) are
+ * standard terminal markdown idioms, but this is an independent
+ * implementation: a single dispatch switch fans tokens out to dedicated
+ * per-type render functions, and all recursive calls thread one immutable
+ * RenderState (parent token, list depth, list ordinal, highlighter) instead
+ * of passing positional arguments.
+ */
 import chalk from 'chalk';
 import { marked } from 'marked';
 import stripAnsi from 'strip-ansi';
@@ -13,37 +20,44 @@ import { colorize } from '../ink/colorize.js';
 import { getActiveTheme } from '../theme.js';
 import { logForDebugging } from '../utils/debug.js';
 import { createHyperlink } from './hyperlink.js';
-// Ported from the leaked Claude Code source (src/utils/markdown.ts), with the
-// app-level theme/color plumbing replaced by fixed ANSI styling and
-// stripPromptXMLTags inlined. Renders marked tokens to ANSI strings.
-const BLOCKQUOTE_BAR = '\u258e'; // ▎ - left one-quarter block
-const STRIPPED_TAGS_RE = /<(commit_analysis|context|function_analysis|pr_analysis)>.*?<\/\1>\n?/gs;
-/** Inline code color: the active theme's permission accent (Gentle Mist Blue). */
-const permissionColor = (text) => colorize(text, getActiveTheme().permission, 'foreground');
+// '\n' is used unconditionally — os.EOL is '\r\n' on Windows, and the stray
+// '\r' breaks the character-to-segment mapping in applyStylesToWrappedText,
+// shifting styled text to the right.
+const EOL = '\n';
+/** Left one-quarter block (U+258E), the blockquote gutter marker. */
+const QUOTE_BAR = '\u258e';
+/** Tool-analysis tag blocks that carry no user-facing content; dropped before lexing. */
+const TOOL_ANALYSIS_TAG_BLOCKS = /<(commit_analysis|context|function_analysis|pr_analysis)>.*?<\/\1>\n?/gs;
+/**
+ * Matches `owner/repo#NNN` style GitHub issue/PR references. Only the
+ * qualified form is recognized: a bare `#NNN` would guess the current
+ * repository and be wrong whenever the assistant discusses a different one.
+ * The owner segment excludes dots (GitHub usernames are alphanumerics plus
+ * hyphens) so hostnames like docs.example.io/guide#42 don't false-positive;
+ * the repo segment allows dots (e.g. cc.kurs.web). Lookbehind is avoided —
+ * it defeats YARR JIT in JSC.
+ */
+const ISSUE_REFERENCE_PATTERN = /(^|[^\w./-])([A-Za-z0-9][\w-]*\/[A-Za-z0-9][\w.-]*)#(\d+)\b/g;
 /**
- * Strip tool-analysis XML tags (`<commit_analysis>`, `<context>`, `<function_analysis>`,
- * `<pr_analysis>`) and their contents, then trim the result.
- * @param content - Markdown text that may contain the wrapped tool-analysis tag blocks.
- * @returns The content with those blocks removed and surrounding whitespace trimmed.
+ * Strip tool-analysis XML blocks (`<commit_analysis>`, `<context>`,
+ * `<function_analysis>`, `<pr_analysis>`) and their contents, then trim.
+ * @param content - Markdown that may wrap the tool-analysis tag blocks.
+ * @returns The content with those blocks removed and whitespace trimmed.
  */
 export function stripPromptXMLTags(content) {
-    return content.replace(STRIPPED_TAGS_RE, '').trim();
+    return content.replace(TOOL_ANALYSIS_TAG_BLOCKS, '').trim();
 }
-// Use \n unconditionally — os.EOL is \r\n on Windows, and the extra \r
-// breaks the character-to-segment mapping in applyStylesToWrappedText,
-// causing styled text to shift right.
-const EOL = '\n';
-let markedConfigured = false;
+let markedInitialized = false;
 /**
- * Configure the shared `marked` instance once: disable strikethrough parsing so
- * `~100` renders literally instead of as deleted text.
+ * Configure the shared `marked` instance once. Strikethrough parsing is
+ * disabled so that `~100` renders literally instead of as deleted text —
+ * models use `~` far more often for "approximate" than for real
+ * strikethrough.
  */
 export function configureMarked() {
-    if (markedConfigured)
+    if (markedInitialized)
         return;
-    markedConfigured = true;
-    // Disable strikethrough parsing - the model often uses ~ for "approximate"
-    // (e.g., ~100) and rarely intends actual strikethrough formatting
+    markedInitialized = true;
     marked.use({
         tokenizer: {
             del() {
@@ -52,6 +66,34 @@ export function configureMarked() {
         },
     });
 }
+/** Inline code is painted with the active theme's permission accent. */
+function paintInlineCode(text) {
+    return colorize(text, getActiveTheme().permission, 'foreground');
+}
+/** A fresh context for block-level children: list state reset, no parent. */
+function fresh(state) {
+    return { highlight: state.highlight, parent: null, listDepth: 0, ordinal: null };
+}
+/** Same context, different parent token. */
+function withParent(state, parent) {
+    return { ...state, parent };
+}
+/** Inline-styled children keep the outer parent but shed list context. */
+function inlineChildren(state) {
+    return { ...state, listDepth: 0, ordinal: null };
+}
+/**
+ * Render one marked token to ANSI text, recursing into child tokens.
+ * @param token - The marked token to render.
+ * @param listDepth - Nesting depth of the enclosing list; drives indentation and numbering style.
+ * @param orderedListNumber - Current ordinal of the enclosing ordered list item, or null for unordered lists.
+ * @param parent - The parent token; linkification is skipped inside links and prefixes are added inside list items.
+ * @param highlight - Optional cli-highlight surface for code blocks; null disables syntax highlighting.
+ * @returns The rendered ANSI string for the token, or '' for unrendered token types.
+ */
+export function formatToken(token, listDepth = 0, orderedListNumber = null, parent = null, highlight = null) {
+    return dispatch(token, { highlight, parent, listDepth, ordinal: orderedListNumber });
+}
 /**
  * Render markdown content to ANSI-styled text via the shared `marked` instance.
  * @param content - Markdown source to render.
@@ -60,231 +102,225 @@ export function configureMarked() {
  */
 export function applyMarkdown(content, highlight = null) {
     configureMarked();
+    const rootState = {
+        highlight,
+        parent: null,
+        listDepth: 0,
+        ordinal: null,
+    };
     return marked
         .lexer(stripPromptXMLTags(content))
-        .map(_ => formatToken(_, 0, null, null, highlight))
+        .map(token => dispatch(token, rootState))
         .join('')
         .trim();
 }
 /**
- * Render one marked token to ANSI text, recursing into child tokens.
- * @param token - The marked token to render.
- * @param listDepth - Nesting depth of the enclosing list; drives indentation and numbering style.
- * @param orderedListNumber - Current ordinal of the enclosing ordered list item, or null for unordered lists.
- * @param parent - The parent token; linkification is skipped inside links and prefixes are added inside list items.
- * @param highlight - Optional cli-highlight surface for code blocks; null disables syntax highlighting.
- * @returns The rendered ANSI string for the token, or '' for unrendered token types.
+ * Type guard that narrows to the concrete marked token of `kind`.
+ * Plain `switch` narrowing fails here: Tokens.Generic declares `type: string`,
+ * so every case keeps Generic in the union. Guarding against MarkedToken
+ * (which excludes Generic) yields exact types for the per-type renderers.
  */
-export function formatToken(token, listDepth = 0, orderedListNumber = null, parent = null, highlight = null) {
-    switch (token.type) {
-        case 'blockquote': {
-            const inner = (token.tokens ?? [])
-                .map(_ => formatToken(_, 0, null, null, highlight))
-                .join('');
-            // Prefix each line with a dim vertical bar. Keep text italic but at
-            // normal brightness — chalk.dim is nearly invisible on dark themes.
-            const bar = chalk.dim(BLOCKQUOTE_BAR);
-            return inner
-                .split(EOL)
-                .map(line => stripAnsi(line).trim() ? `${bar} ${chalk.italic(line)}` : line)
-                .join(EOL);
-        }
-        case 'code': {
-            if (!highlight) {
-                return token.text + EOL;
-            }
-            let language = 'plaintext';
-            if (token.lang) {
-                if (highlight.supportsLanguage(token.lang)) {
-                    language = token.lang;
-                }
-                else {
-                    logForDebugging(`Language not supported while highlighting code, falling back to plaintext: ${token.lang}`);
-                }
-            }
-            return highlight.highlight(token.text, { language }) + EOL;
-        }
-        case 'codespan': {
-            // inline code
-            return permissionColor(token.text);
-        }
-        case 'em':
-            return chalk.italic((token.tokens ?? [])
-                .map(_ => formatToken(_, 0, null, parent, highlight))
-                .join(''));
-        case 'strong':
-            return chalk.bold((token.tokens ?? [])
-                .map(_ => formatToken(_, 0, null, parent, highlight))
-                .join(''));
-        case 'heading':
-            switch (token.depth) {
-                case 1: // h1
-                    return (chalk.bold.italic.underline((token.tokens ?? [])
-                        .map(_ => formatToken(_, 0, null, null, highlight))
-                        .join('')) +
-                        EOL +
-                        EOL);
-                case 2: // h2
-                    return (chalk.bold((token.tokens ?? [])
-                        .map(_ => formatToken(_, 0, null, null, highlight))
-                        .join('')) +
-                        EOL +
-                        EOL);
-                default: // h3+
-                    return (chalk.bold((token.tokens ?? [])
-                        .map(_ => formatToken(_, 0, null, null, highlight))
-                        .join('')) +
-                        EOL +
-                        EOL);
-            }
-        case 'hr':
-            return '---';
-        case 'image':
-            return token.href;
-        case 'link': {
-            // Prevent mailto links from being displayed as clickable links
-            if (token.href.startsWith('mailto:')) {
-                // Extract email from mailto: link and display as plain text
-                const email = token.href.replace(/^mailto:/, '');
-                return email;
-            }
-            // Extract display text from the link's child tokens
-            const linkText = (token.tokens ?? [])
-                .map(_ => formatToken(_, 0, null, token, highlight))
-                .join('');
-            const plainLinkText = stripAnsi(linkText);
-            // If the link has meaningful display text (different from the URL),
-            // show it as a clickable hyperlink. In terminals that support OSC 8,
-            // users see the text and can hover/click to see the URL.
-            if (plainLinkText && plainLinkText !== token.href) {
-                return createHyperlink(token.href, linkText);
-            }
-            // When the display text matches the URL (or is empty), just show the URL
-            return createHyperlink(token.href);
-        }
-        case 'list': {
-            return token.items
-                .map((_, index) => formatToken(_, listDepth, token.ordered ? token.start + index : null, token, highlight))
-                .join('');
+function isToken(token, kind) {
+    return token.type === kind;
+}
+/** Fan-out point: narrows the token union, then delegates to the per-type render functions. */
+function dispatch(token, state) {
+    if (isToken(token, 'blockquote'))
+        return renderBlockquote(token, state);
+    if (isToken(token, 'code'))
+        return renderCodeBlock(token, state);
+    if (isToken(token, 'codespan'))
+        return paintInlineCode(token.text);
+    if (isToken(token, 'em'))
+        return renderEmphasis(token, state);
+    if (isToken(token, 'strong'))
+        return renderStrong(token, state);
+    if (isToken(token, 'heading'))
+        return renderHeading(token, state);
+    if (isToken(token, 'hr'))
+        return '---';
+    if (isToken(token, 'image'))
+        return token.href;
+    if (isToken(token, 'link'))
+        return renderLink(token, state);
+    if (isToken(token, 'list'))
+        return renderList(token, state);
+    if (isToken(token, 'list_item'))
+        return renderListItem(token, state);
+    if (isToken(token, 'paragraph'))
+        return renderParagraph(token, state);
+    if (isToken(token, 'space') || isToken(token, 'br'))
+        return EOL;
+    if (isToken(token, 'text'))
+        return renderText(token, state);
+    if (isToken(token, 'table'))
+        return renderTable(token, state);
+    if (isToken(token, 'escape'))
+        return token.text;
+    if (isToken(token, 'def') || isToken(token, 'del') || isToken(token, 'html')) {
+        // Link definitions, strikethrough, and raw HTML carry no ANSI
+        // representation.
+        return '';
+    }
+    // Unknown / extension token types render as nothing.
+    return '';
+}
+function renderBlockquote(token, state) {
+    const inner = token.tokens.map(child => dispatch(child, fresh(state))).join('');
+    // Dim gutter bar per line; keep the text italic but at normal brightness —
+    // chalk.dim is nearly invisible on dark themes.
+    const gutter = chalk.dim(QUOTE_BAR);
+    return inner
+        .split(EOL)
+        .map(line => (stripAnsi(line).trim() ? `${gutter} ${chalk.italic(line)}` : line))
+        .join(EOL);
+}
+function renderCodeBlock(token, state) {
+    if (!state.highlight) {
+        return token.text + EOL;
+    }
+    let language = 'plaintext';
+    if (token.lang) {
+        if (state.highlight.supportsLanguage(token.lang)) {
+            language = token.lang;
         }
-        case 'list_item':
-            return (token.tokens ?? [])
-                .map(_ => `${'  '.repeat(listDepth)}${formatToken(_, listDepth + 1, orderedListNumber, token, highlight)}`)
-                .join('');
-        case 'paragraph':
-            return ((token.tokens ?? [])
-                .map(_ => formatToken(_, 0, null, null, highlight))
-                .join('') + EOL);
-        case 'space':
-            return EOL;
-        case 'br':
-            return EOL;
-        case 'text':
-            if (parent?.type === 'link') {
-                // Already inside a markdown link — the link handler will wrap this
-                // in an OSC 8 hyperlink. Linkifying here would nest a second OSC 8
-                // sequence, and terminals honor the innermost one, overriding the
-                // link's actual href.
-                return token.text;
-            }
-            if (parent?.type === 'list_item') {
-                return `${orderedListNumber === null ? '-' : getListNumber(listDepth, orderedListNumber) + '.'} ${token.tokens ? token.tokens.map(_ => formatToken(_, listDepth, orderedListNumber, token, highlight)).join('') : linkifyIssueReferences(token.text)}${EOL}`;
-            }
-            return linkifyIssueReferences(token.text);
-        case 'table': {
-            const tableToken = token;
-            // Helper function to get the text content that will be displayed (after stripAnsi)
-            function getDisplayText(tokens) {
-                return stripAnsi(tokens
-                    ?.map(_ => formatToken(_, 0, null, null, highlight))
-                    .join('') ?? '');
-            }
-            // Determine column widths based on displayed content (without formatting)
-            const columnWidths = tableToken.header.map((header, index) => {
-                let maxWidth = stringWidth(getDisplayText(header.tokens));
-                for (const row of tableToken.rows) {
-                    const cellLength = stringWidth(getDisplayText(row[index]?.tokens));
-                    maxWidth = Math.max(maxWidth, cellLength);
-                }
-                return Math.max(maxWidth, 3); // Minimum width of 3
-            });
-            // Format header row
-            let tableOutput = '| ';
-            tableToken.header.forEach((header, index) => {
-                const content = header.tokens
-                    ?.map(_ => formatToken(_, 0, null, null, highlight))
-                    .join('') ?? '';
-                const displayText = getDisplayText(header.tokens);
-                const width = columnWidths[index];
-                const align = tableToken.align?.[index];
-                tableOutput +=
-                    padAligned(content, stringWidth(displayText), width, align) + ' | ';
-            });
-            tableOutput = tableOutput.trimEnd() + EOL;
-            // Add separator row
-            tableOutput += '|';
-            columnWidths.forEach((width) => {
-                // Always use dashes, don't show alignment colons in the output
-                const separator = '-'.repeat(width + 2); // +2 for spaces on each side
-                tableOutput += separator + '|';
-            });
-            tableOutput += EOL;
-            // Format data rows
-            tableToken.rows.forEach((row) => {
-                tableOutput += '| ';
-                row.forEach((cell, index) => {
-                    const content = cell.tokens
-                        ?.map(_ => formatToken(_, 0, null, null, highlight))
-                        .join('') ?? '';
-                    const displayText = getDisplayText(cell.tokens);
-                    const width = columnWidths[index];
-                    const align = tableToken.align?.[index];
-                    tableOutput +=
-                        padAligned(content, stringWidth(displayText), width, align) + ' | ';
-                });
-                tableOutput = tableOutput.trimEnd() + EOL;
-            });
-            return tableOutput + EOL;
+        else {
+            logForDebugging(`Language not supported while highlighting code, falling back to plaintext: ${token.lang}`);
         }
-        case 'escape':
-            // Markdown escape: \) → ), \\ → \, etc.
-            return token.text;
-        case 'def':
-        case 'del':
-        case 'html':
-            // These token types are not rendered
-            return '';
     }
-    return '';
+    return state.highlight.highlight(token.text, { language }) + EOL;
+}
+function renderEmphasis(token, state) {
+    const inner = token.tokens.map(child => dispatch(child, inlineChildren(state))).join('');
+    return chalk.italic(inner);
+}
+function renderStrong(token, state) {
+    const inner = token.tokens.map(child => dispatch(child, inlineChildren(state))).join('');
+    return chalk.bold(inner);
+}
+function renderHeading(token, state) {
+    const text = token.tokens.map(child => dispatch(child, fresh(state))).join('');
+    // H1 gets the full banner treatment; every deeper level shares the bold style.
+    const styled = token.depth === 1 ? chalk.bold.italic.underline(text) : chalk.bold(text);
+    return styled + EOL + EOL;
+}
+function renderLink(token, state) {
+    // mailto: links are shown as plain email addresses, not clickable links.
+    if (token.href.startsWith('mailto:')) {
+        return token.href.slice('mailto:'.length);
+    }
+    const label = token.tokens
+        .map(child => dispatch(child, withParent(fresh(state), token)))
+        .join('');
+    const plainLabel = stripAnsi(label);
+    // Meaningful display text (different from the URL) becomes a clickable
+    // hyperlink; otherwise just show the URL.
+    if (plainLabel && plainLabel !== token.href) {
+        return createHyperlink(token.href, label);
+    }
+    return createHyperlink(token.href);
+}
+function renderList(token, state) {
+    // ordered lists always carry a numeric start ("" only occurs for unordered),
+    // but the type says otherwise, so coerce defensively.
+    const start = typeof token.start === 'number' ? token.start : 1;
+    return token.items
+        .map((item, index) => {
+        const ordinal = token.ordered ? start + index : null;
+        return dispatch(item, { ...state, ordinal });
+    })
+        .join('');
+}
+function renderListItem(token, state) {
+    const indent = '  '.repeat(state.listDepth);
+    const childState = withParent({ ...state, listDepth: state.listDepth + 1 }, token);
+    return token.tokens.map(child => indent + dispatch(child, childState)).join('');
+}
+function renderParagraph(token, state) {
+    return token.tokens.map(child => dispatch(child, fresh(state))).join('') + EOL;
+}
+function renderText(token, state) {
+    const { parent, listDepth, ordinal } = state;
+    if (parent?.type === 'link') {
+        // Already inside a link: the link handler wraps everything in one OSC 8
+        // sequence, and a nested one would override the real href. Stay plain.
+        return token.text;
+    }
+    if (parent?.type === 'list_item') {
+        const bullet = ordinal === null ? '-' : `${formatListMarker(listDepth, ordinal)}.`;
+        const body = token.tokens
+            ? token.tokens.map(child => dispatch(child, withParent(state, token))).join('')
+            : linkifyIssueReferences(token.text);
+        return `${bullet} ${body}${EOL}`;
+    }
+    return linkifyIssueReferences(token.text);
+}
+function renderTable(token, state) {
+    const rows = [token.header, ...token.rows];
+    // Column widths derive from the visible (ANSI-stripped) cell text; 3 is
+    // the minimum so a separator row always reads as a table divider.
+    const columnWidths = token.header.map((_, colIndex) => {
+        let widest = 3;
+        for (const row of rows) {
+            widest = Math.max(widest, stringWidth(cellDisplayText(row[colIndex], state)));
+        }
+        return widest;
+    });
+    const headerLine = renderTableRow(token.header, columnWidths, token.align, state);
+    // Dashes only — alignment colons are not echoed into the output.
+    const divider = `|${columnWidths.map(width => `${'-'.repeat(width + 2)}|`).join('')}${EOL}`;
+    const bodyLines = token.rows
+        .map(row => renderTableRow(row, columnWidths, token.align, state))
+        .join('');
+    return headerLine + divider + bodyLines + EOL;
+}
+/** Rendered cell content, stripped of ANSI codes, for width measurement. */
+function cellDisplayText(cell, state) {
+    return stripAnsi(cell.tokens.map(child => dispatch(child, fresh(state))).join(''));
+}
+function renderTableRow(cells, columnWidths, aligns, state) {
+    let line = '| ';
+    cells.forEach((cell, index) => {
+        const content = cell.tokens.map(child => dispatch(child, fresh(state))).join('');
+        line +=
+            padAligned(content, stringWidth(cellDisplayText(cell, state)), columnWidths[index], aligns[index]) + ' | ';
+    });
+    return line.trimEnd() + EOL;
 }
-// Matches owner/repo#NNN style GitHub issue/PR references. The qualified form
-// is unambiguous — bare #NNN was removed because it guessed the current repo
-// and was wrong whenever the assistant discussed a different one.
-// Owner segment disallows dots (GitHub usernames are alphanumerics + hyphens
-// only) so hostnames like docs.github.io/guide#42 don't false-positive. Repo
-// segment allows dots (e.g. cc.kurs.web). Lookbehind is avoided — it defeats
-// YARR JIT in JSC.
-const ISSUE_REF_PATTERN = /(^|[^\w./-])([A-Za-z0-9][\w-]*\/[A-Za-z0-9][\w.-]*)#(\d+)\b/g;
 /**
- * Replaces owner/repo#123 references with clickable hyperlinks to GitHub.
+ * Replace `owner/repo#123` references with clickable GitHub links.
+ * No-op when the terminal lacks OSC 8 hyperlink support.
  */
 function linkifyIssueReferences(text) {
     if (!supportsHyperlinks()) {
         return text;
     }
-    return text.replace(ISSUE_REF_PATTERN, (_match, prefix, repo, num) => prefix +
-        createHyperlink(`https://github.com/${repo}/issues/${num}`, `${repo}#${num}`));
+    return text.replace(ISSUE_REFERENCE_PATTERN, (_match, prefix, repo, issueNumber) => prefix +
+        createHyperlink(`https://github.com/${repo}/issues/${issueNumber}`, `${repo}#${issueNumber}`));
 }
-function numberToLetter(n) {
-    let result = '';
-    while (n > 0) {
-        n--;
-        result = String.fromCharCode(97 + (n % 26)) + result;
-        n = Math.floor(n / 26);
+/**
+ * Ordered-list marker for a given nesting depth: decimal at depth 1,
+ * letters at depth 2, roman numerals at depth 3, decimal beyond.
+ */
+function formatListMarker(listDepth, ordinal) {
+    switch (listDepth) {
+        case 2:
+            return toAlphaIndex(ordinal);
+        case 3:
+            return toRomanNumeral(ordinal);
+        default:
+            return ordinal.toString();
     }
-    return result;
 }
-const ROMAN_VALUES = [
+/** Bijective base-26 conversion: 1 → a, 26 → z, 27 → aa. */
+function toAlphaIndex(n) {
+    if (n <= 0)
+        return '';
+    const digit = String.fromCharCode(97 + ((n - 1) % 26));
+    return toAlphaIndex(Math.floor((n - 1) / 26)) + digit;
+}
+/** Standard greedy roman-numeral symbol table (lowercase). */
+const ROMAN_SYMBOLS = [
     [1000, 'm'],
     [900, 'cm'],
     [500, 'd'],
@@ -299,33 +335,20 @@ const ROMAN_VALUES = [
     [4, 'iv'],
     [1, 'i'],
 ];
-function numberToRoman(n) {
-    let result = '';
-    for (const [value, numeral] of ROMAN_VALUES) {
+function toRomanNumeral(n) {
+    let out = '';
+    for (const [value, glyph] of ROMAN_SYMBOLS) {
         while (n >= value) {
-            result += numeral;
+            out += glyph;
             n -= value;
         }
     }
-    return result;
-}
-function getListNumber(listDepth, orderedListNumber) {
-    switch (listDepth) {
-        case 0:
-        case 1:
-            return orderedListNumber.toString();
-        case 2:
-            return numberToLetter(orderedListNumber);
-        case 3:
-            return numberToRoman(orderedListNumber);
-        default:
-            return orderedListNumber.toString();
-    }
+    return out;
 }
 /**
- * Pad `content` to `targetWidth` according to alignment. `displayWidth` is the
- * visible width of `content` (caller computes this, e.g. via stringWidth on
- * stripAnsi'd text, so ANSI codes in `content` don't affect padding).
+ * Pad `content` to `targetWidth` according to alignment. `displayWidth` is
+ * the visible width of `content` (callers compute it via stringWidth on the
+ * ANSI-stripped text, so embedded escape codes don't affect padding).
  * @param content - The text to pad, which may carry ANSI codes.
  * @param displayWidth - Visible width of `content` without ANSI codes.
  * @param targetWidth - Column width to pad `content` to.
@@ -333,13 +356,13 @@ function getListNumber(listDepth, orderedListNumber) {
  * @returns `content` padded with spaces to `targetWidth`.
  */
 export function padAligned(content, displayWidth, targetWidth, align) {
-    const padding = Math.max(0, targetWidth - displayWidth);
+    const extra = Math.max(0, targetWidth - displayWidth);
     if (align === 'center') {
-        const leftPad = Math.floor(padding / 2);
-        return ' '.repeat(leftPad) + content + ' '.repeat(padding - leftPad);
+        const left = Math.floor(extra / 2);
+        return ' '.repeat(left) + content + ' '.repeat(extra - left);
     }
     if (align === 'right') {
-        return ' '.repeat(padding) + content;
+        return ' '.repeat(extra) + content;
     }
-    return content + ' '.repeat(padding);
+    return content + ' '.repeat(extra);
 }

package/lib/types/cc/terminal.d.ts

@@ -1,15 +1,18 @@
-/** `(ctrl+o to expand)` hint in dim chalk, like the leak's ctrlOToExpand().
+/**
+ * The `(ctrl+o to expand)` hint, dimmed.
  * @returns The dim hint text.
  */
 export declare function ctrlOToExpand(): string;
 /**
- * Renders the content with line-based truncation for terminal display.
- * If the content exceeds the maximum number of lines, it truncates the content
- * and adds a message indicating the number of additional lines.
+ * Render `content` with line-based truncation for terminal display.
+ * Content that fits in the visible budget is returned unchanged (modulo
+ * trailing whitespace); longer content is folded with an overflow hint.
  * @param content - Text to render; trailing whitespace is trimmed.
- * @param terminalWidth - Terminal width in columns; the wrap width reserves 4 columns of padding.
- * @param suppressExpandHint - When true, omit the `(ctrl+o to expand)` suffix from the overflow hint.
- * @returns The truncated text, or '' when `content` is blank after trimming.
+ * @param terminalWidth - Terminal width in columns; the wrap width reserves
+ *                        4 columns of padding.
+ * @param suppressExpandHint - When true, omit the `(ctrl+o to expand)`
+ *                             suffix from the overflow hint.
+ * @returns The truncated text, or `''` when `content` is blank after trimming.
  */
 export declare function renderTruncatedContent(content: string, terminalWidth: number, suppressExpandHint?: boolean): string;
 //# sourceMappingURL=terminal.d.ts.map

package/lib/types/cc/terminal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../../src/cc/terminal.ts"],"names":[],"mappings":"AAsDA;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,kBAAkB,UAAQ,GACzB,MAAM,CAsCR"}
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../../src/cc/terminal.ts"],"names":[],"mappings":"AA+DA;;;GAGG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,kBAAkB,UAAQ,GACzB,MAAM,CAuCR"}