@cspeach/cli 0.6.0

package/dist/renderer/highlighters/abap.js

@@ -0,0 +1,126 @@
+/**
+ * cli-highlight language definition for ABAP.
+ *
+ * Registered as 'abap'. Matches fenced code blocks with ```abap.
+ * 150+ keywords covering SELECT/FROM/WHERE, OOP class/interface/method,
+ * structured data (types/data/field-symbols), control flow, RAP/EML,
+ * CDS annotations are handled separately in cds.ts.
+ */
+// Keywords are unioned into a single Set during grammar build; duplicates
+// are harmless at runtime but noisy in source. Kept alphabetical within
+// each section for diff-friendliness. Keywords that appear in multiple
+// conceptual sections (e.g. READ — both DML and EML, TABLES — declaration
+// and selection-screen) are listed ONCE in the most-DML-like section with a
+// trailing comment noting the other usage.
+const KEYWORDS = [
+    // DML / Open SQL (READ/MODIFY/DELETE/CREATE also used in EML — listed here)
+    'ALL', 'APPENDING', 'AS', 'BY', 'BYPASSING', 'BUFFER', 'CLIENT',
+    'COMMIT', 'CORRESPONDING', 'CREATE', 'DELETE', 'DISTINCT', 'ENTRIES',
+    'FIELDS', 'FOR', 'FROM', 'GROUP', 'HAVING', 'IN', 'INNER', 'INSERT',
+    'INTO', 'JOIN', 'LEFT', 'MODIFY', 'OF', 'ON', 'ORDER', 'OUTER',
+    'READ', 'ROLLBACK', 'ROWS', 'SELECT', 'SINGLE', 'SPECIFIED', 'TABLE',
+    'TO', 'UNION', 'UP', 'UPDATE', 'WHERE', 'WORK',
+    // Data declaration (TABLES also used in selection-screen — listed here)
+    'ALIASES', 'BEGIN', 'CLASS-DATA', 'CLASS-METHODS', 'CONSTANTS', 'DATA',
+    'DEFAULT', 'END', 'EVENTS', 'HASHED', 'HEADER', 'INCLUDE', 'INTERFACES',
+    'KEY', 'LIKE', 'LINE', 'METHODS', 'NEW', 'NON-UNIQUE', 'OCCURS',
+    'REF', 'SORTED', 'STANDARD', 'STRUCTURE', 'TABLES', 'TYPE', 'TYPES',
+    'UNIQUE', 'WITH',
+    // OOP (ABSTRACT/FINAL also in 'misc' — listed here)
+    'ABSTRACT', 'CHANGING', 'CLASS', 'DEFERRED', 'DEFINITION', 'ENDCLASS',
+    'ENDINTERFACE', 'ENDMETHOD', 'EXCEPTIONS', 'EXPORTING', 'FINAL',
+    'FRIENDS', 'IMPLEMENTATION', 'IMPORTING', 'INHERITING', 'INTERFACE',
+    'METHOD', 'OBJECT', 'OPTIONAL', 'OVERRIDING', 'PARAMETER', 'PARAMETERS',
+    'PREFERRED', 'PRIVATE', 'PROTECTED', 'PUBLIC', 'RAISING', 'REDEFINITION',
+    'RETURNING', 'SECTION',
+    // Exception / flow
+    'ASSERT', 'CATCH', 'CLEANUP', 'ENDTRY', 'EXCEPTION', 'MESSAGE',
+    'RAISE', 'RESUME', 'TRY',
+    // Control
+    'AT', 'CASE', 'CHECK', 'CONTINUE', 'DO', 'ELSE', 'ELSEIF', 'ENDAT',
+    'ENDCASE', 'ENDDO', 'ENDIF', 'ENDLOOP', 'ENDWHILE', 'EXIT', 'IF',
+    'LOOP', 'OTHERS', 'RETURN', 'STOP', 'WHEN', 'WHILE',
+    // Field symbols
+    'ASSIGN', 'FIELD-SYMBOLS', 'UNASSIGN',
+    // String / table ops
+    'APPEND', 'BINARY', 'CLEAR', 'COLLECT', 'CONCATENATE', 'CONDENSE',
+    'DESCRIBE', 'FILTER', 'FIND', 'FREE', 'MOVE', 'REDUCE', 'REPLACE',
+    'SEARCH', 'SHIFT', 'SORT', 'SPLIT', 'TRANSLATE', 'VALUE', 'WRITE',
+    // Report / selection screen
+    'CLASS-POOL', 'END-OF-SELECTION', 'FUNCTION-POOL', 'INITIALIZATION',
+    'PROGRAM', 'REPORT', 'SELECT-OPTIONS', 'SELECTION-SCREEN',
+    'START-OF-SELECTION',
+    // FORM / PERFORM (legacy)
+    'CALL', 'ENDFORM', 'FORM', 'FUNCTION', 'PERFORM', 'USING',
+    // Misc
+    'ACTVT', 'AUTHORITY-CHECK', 'CAST', 'COND', 'CONV', 'DEQUEUE',
+    'ENQUEUE', 'EXACT', 'FAIL', 'FIELD', 'ID', 'LET', 'LOCK', 'NOTICE',
+    'STATIC', 'SWITCH', 'UNLOCK',
+    // EML / RAP (only terms NOT already covered above — READ/MODIFY/DELETE/
+    // CREATE/IN/FIELDS/WITH/BY are in the DML section)
+    'ASSIGNING', 'AUTHORITY', 'ENTITIES', 'ENTITY', 'EXECUTE', 'FAILED',
+    'LOCAL', 'MAPPED', 'MODE', 'REPORTED', 'RESPONSE', 'RESULT',
+    'TRANSPORTING',
+];
+const grammar = {
+    case_insensitive: true,
+    keywords: {
+        keyword: KEYWORDS.join(' '),
+    },
+    contains: [
+        // Line comments: * at start of line
+        {
+            className: 'comment',
+            begin: /^\*/,
+            end: /$/,
+            relevance: 5,
+        },
+        // Inline comments: " anywhere mid-line
+        {
+            className: 'comment',
+            begin: /"/,
+            end: /$/,
+            relevance: 3,
+        },
+        // String literals: single-quoted
+        {
+            className: 'string',
+            begin: /'/,
+            end: /'/,
+            illegal: /\n/,
+            contains: [{ begin: /''/ }], // escaped single quote
+            relevance: 4,
+        },
+        // String templates: |...|
+        // Classical begin/end pair with `illegal: /\n/` to prevent the string
+        // from consuming across line boundaries. Using zero-width lookahead as
+        // `end` is non-standard in highlight.js mode syntax and was rejected in
+        // review (H9) — the begin/end/illegal triple is the idiomatic form.
+        {
+            className: 'string',
+            begin: /\|/,
+            end: /\|/,
+            illegal: /\n/,
+            relevance: 0,
+        },
+        // Z* / Y* identifiers — custom namespace (highlight distinctly as 'title')
+        {
+            className: 'title',
+            begin: /\b[ZY][A-Z0-9_]{1,30}\b/,
+            relevance: 3,
+        },
+        // Numeric literals
+        {
+            className: 'number',
+            begin: /\b\d+(\.\d+)?\b/,
+            relevance: 2,
+        },
+        // Built-in type keywords used after TYPE (treated as type keyword)
+        {
+            className: 'type',
+            begin: /\b(string|xstring|i|int1|int2|int4|int8|f|d|t|c|n|x|p|decfloat16|decfloat34|char|numc|dats|tims|clnt|lang|syst|boolean)\b/i,
+            relevance: 3,
+        },
+    ],
+};
+export default grammar;

package/dist/renderer/highlighters/bdef.js

@@ -0,0 +1,81 @@
+/**
+ * cli-highlight language definition for BDEF (Behavior Definition).
+ *
+ * Registered as 'bdef'. Matches fenced code blocks with ```bdef.
+ * Covers managed/unmanaged syntax, persistent/draft table, operations,
+ * validations, determinations, actions, feature control, authorization.
+ */
+const BDEF_KEYWORDS = [
+    // Top-level
+    'managed', 'unmanaged', 'abstract', 'projection',
+    'implementation', 'in', 'class', 'unique',
+    'define', 'behavior', 'for', 'alias',
+    // Persistence
+    'persistent', 'table', 'draft', 'lock', 'master', 'dependent',
+    'total', 'etag',
+    // Authorization
+    'authorization', 'instance', 'global',
+    // Operations
+    'create', 'update', 'delete', 'read',
+    'use', 'action', 'function', 'static', 'internal',
+    'validation', 'determination', 'on', 'save', 'modify',
+    'association', 'composition', 'to', 'parent',
+    // Field control
+    'field', 'readonly', 'mandatory', 'features',
+    // RAP features
+    'with', 'draft', 'side', 'effects', 'target',
+    'mapping', 'from', 'numbering', 'managed', 'early', 'late',
+    'result', 'parameter', 'uses', 'augment',
+    // Feature modes
+    'instance', 'global', 'static',
+    // Triggers
+    'create', 'update', 'delete', 'activate', 'discard', 'edit', 'resume',
+];
+const grammar = {
+    case_insensitive: true,
+    keywords: {
+        keyword: BDEF_KEYWORDS.join(' '),
+    },
+    contains: [
+        // Line comments: //
+        {
+            className: 'comment',
+            begin: /\/\//,
+            end: /$/,
+            relevance: 5,
+        },
+        // Block comments: /* ... */
+        {
+            className: 'comment',
+            begin: /\/\*/,
+            end: /\*\//,
+            relevance: 5,
+        },
+        // Class/table names in double-quotes (e.g. implementation in class "zbp_sales_order")
+        {
+            className: 'string',
+            begin: /"/,
+            end: /"/,
+            relevance: 3,
+        },
+        // Z* / Y* identifiers (behavior entity names, class names, table names)
+        {
+            className: 'title',
+            begin: /\b[ZY][A-Za-z0-9_]{1,30}\b/,
+            relevance: 4,
+        },
+        // ZBP_ class references (behavior pool class naming convention)
+        {
+            className: 'title',
+            begin: /\bZBP_[A-Za-z0-9_]+\b/i,
+            relevance: 5,
+        },
+        // Numeric literals
+        {
+            className: 'number',
+            begin: /\b\d+\b/,
+            relevance: 2,
+        },
+    ],
+};
+export default grammar;

package/dist/renderer/highlighters/cds.js

@@ -0,0 +1,91 @@
+/**
+ * cli-highlight language definition for CDS (Core Data Services).
+ *
+ * Registered as 'cds'. Matches fenced code blocks with ```cds.
+ * Covers: define view/table syntax, @Annotations, association/composition,
+ * SQL-like keywords used in CDS projections.
+ */
+const CDS_KEYWORDS = [
+    'define', 'view', 'entity', 'as', 'select', 'from', 'projection', 'on',
+    'association', 'composition', 'to', 'parent', 'redirected',
+    'join', 'inner', 'left', 'outer', 'right', 'cross',
+    'where', 'group', 'by', 'having', 'union', 'all', 'distinct',
+    'extend', 'annotate', 'with', 'abstract',
+    'key', 'virtual', 'literal', 'cast', 'case', 'when', 'then', 'else', 'end',
+    'not', 'null', 'is', 'and', 'or', 'in', 'between', 'like',
+    'aspect', 'type', 'element', 'action', 'function', 'returns',
+    'service', 'namespace', 'using', 'context',
+    'managed', 'unmanaged', 'implementation', 'class', 'unique',
+    'draft', 'table', 'lock', 'authorization', 'master', 'instance',
+    'persistent', 'field', 'validation', 'determination',
+    'create', 'update', 'delete',
+];
+const grammar = {
+    case_insensitive: true,
+    keywords: {
+        keyword: CDS_KEYWORDS.join(' '),
+    },
+    contains: [
+        // Line comments: //
+        {
+            className: 'comment',
+            begin: /\/\//,
+            end: /$/,
+            relevance: 5,
+        },
+        // Block comments: /* ... */
+        {
+            className: 'comment',
+            begin: /\/\*/,
+            end: /\*\//,
+            relevance: 5,
+        },
+        // Annotations: @Something or @Something.nested or @Something.nested: value
+        // Annotation value strings handled below; here we color the annotation name.
+        {
+            className: 'meta',
+            begin: /@[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)*/,
+            relevance: 8,
+            contains: [
+                // Annotation value strings inside annotations e.g. @EndUserText.label: 'Sales Order'
+                {
+                    className: 'string',
+                    begin: /'/,
+                    end: /'/,
+                },
+            ],
+        },
+        // String literals
+        {
+            className: 'string',
+            begin: /'/,
+            end: /'/,
+            relevance: 3,
+        },
+        // Z* / Y* / C* identifiers (custom CDS view names)
+        {
+            className: 'title',
+            begin: /\b[ZYC][A-Za-z_][A-Za-z0-9_]{0,29}\b/,
+            relevance: 4,
+        },
+        // $projection, $session, $parameters pseudo-elements
+        {
+            className: 'variable',
+            begin: /\$[a-z_]+/,
+            relevance: 5,
+        },
+        // Numeric literals
+        {
+            className: 'number',
+            begin: /\b\d+(\.\d+)?\b/,
+            relevance: 2,
+        },
+        // Cardinality annotations like [0..1], [1..*]
+        {
+            className: 'number',
+            begin: /\[\d+\.\.[*\d]+\]/,
+            relevance: 3,
+        },
+    ],
+};
+export default grammar;

package/dist/renderer/markdown.js

@@ -0,0 +1,291 @@
+/**
+ * Markdown → ANSI via marked + marked-terminal.
+ *
+ * marked-terminal@6 TerminalRenderer options accept CHALK STYLE FUNCTIONS (e.g.,
+ * chalk.cyan.bold) — NOT arg-taking callbacks. See
+ * https://github.com/mikaelbr/marked-terminal/blob/v6.2.0/README.md for the full
+ * option table. Arg-taking callbacks are allowed only for `list(body, ordered)`
+ * and `image(href, title, text)`; every other key is a wrapper applied to the
+ * already-rendered text.
+ *
+ * We cannot distinguish h1/h2/h3/h4 with a single chalk function, so we pick one
+ * styling for all heading levels — terminal output rarely needs a level hierarchy.
+ */
+import chalk from 'chalk';
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import Table from 'cli-table3';
+import { applySeverityToCell } from './severity.js';
+const PEACH = '#FFB88C';
+// marked-terminal uses these sentinels internally. We parse them back out to
+// rebuild a width-capped cli-table3 in our table renderer override below.
+// Source: node_modules/marked-terminal/index.js lines 10-15.
+const MT_CELL_SPLIT = '^*||*^';
+const MT_ROW_WRAP_RE = new RegExp('\\*\\|\\*\\|\\*\\|\\*', 'g');
+// marked-terminal replaces `:` in codespans with `*#COLON|*` before markdown
+// parses the table (otherwise `:` would be read as column alignment syntax).
+// It reverses this via `undoColon` inside its own transform pipeline; we must
+// do the same in our custom table renderer or raw sentinels leak into cells.
+const MT_COLON_RE = /\*#COLON\|\*/g;
+const ANSI_RE = /\x1B\[[0-9;]*[mGKHFABCDsuJSTfrl]|\x1B\][^\x07]*\x07/g;
+function stripAnsi(s) {
+    return s.replace(ANSI_RE, '');
+}
+/** Apply marked-terminal's transform pipeline (undoColon + HTML entity unescape). */
+function mtTransform(s) {
+    return s
+        .replace(MT_COLON_RE, ':')
+        .replace(/&/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'");
+}
+function parseMtTableRows(text, applyTransform = true) {
+    if (!text)
+        return [];
+    const rows = [];
+    const normalized = applyTransform ? mtTransform(text) : text;
+    for (const line of normalized.split('\n')) {
+        if (!line)
+            continue;
+        const cells = line.replace(MT_ROW_WRAP_RE, '').split(MT_CELL_SPLIT);
+        // marked-terminal's tablecell emits `content + TABLE_CELL_SPLIT` — split leaves
+        // one trailing empty element we drop.
+        rows.push(cells.slice(0, -1));
+    }
+    return rows;
+}
+/**
+ * Compute per-column widths that fit within the terminal.
+ *
+ * Strategy:
+ *   1. Natural: widest cell in each column (no wrapping).
+ *   2. Min: longest single word in each column (prevents mid-word truncation).
+ *   3. If natural + padding + borders ≤ termWidth → use natural.
+ *   4. Else → each column gets at least its min, remaining budget scales
+ *      proportionally from (natural - min).
+ *
+ * cli-table3 layout: `│ <content> │ <content> │`
+ *   - Each `│` separator is 1 char → borders = colCount + 1
+ *   - Each cell has 1-char L-pad + content + 1-char R-pad
+ *   - `colWidths[i]` in cli-table3 = content width + 2 (padding)
+ *   - totalTableWidth = sum(colWidths) + colCount + 1
+ */
+function computeColWidths(naturalContentWidths, minContentWidths, termWidth) {
+    const colCount = naturalContentWidths.length;
+    const borders = colCount + 1;
+    const paddingTotal = colCount * 2;
+    const SAFETY = 2; // leave 2 cols headroom at the terminal right edge
+    const contentAvailable = Math.max(minContentWidths.reduce((a, b) => a + b, 0), termWidth - borders - paddingTotal - SAFETY);
+    const naturalSum = naturalContentWidths.reduce((a, b) => a + b, 0);
+    if (naturalSum <= contentAvailable) {
+        // Fits — use natural widths.
+        return naturalContentWidths.map((w) => w + 2);
+    }
+    // Overflow — each col gets its min, remainder distributed proportionally to
+    // the (natural - min) "stretch" of each column. Short columns (fixed-width
+    // severity labels, short IDs) stay at their min; long columns absorb the shrink.
+    const minSum = minContentWidths.reduce((a, b) => a + b, 0);
+    const stretchAvailable = Math.max(0, contentAvailable - minSum);
+    const stretchNatural = naturalSum - minSum;
+    const scale = stretchNatural > 0 ? stretchAvailable / stretchNatural : 0;
+    const widths = naturalContentWidths.map((nat, i) => {
+        const min = minContentWidths[i];
+        const extra = Math.floor((nat - min) * scale);
+        return min + Math.max(0, extra);
+    });
+    // Distribute rounding leftover to the widest natural column (so long-content
+    // columns like Detail get the extra space).
+    let leftover = contentAvailable - widths.reduce((a, b) => a + b, 0);
+    if (leftover > 0) {
+        const widestIdx = naturalContentWidths.indexOf(Math.max(...naturalContentWidths));
+        widths[widestIdx] += leftover;
+    }
+    return widths.map((w) => w + 2);
+}
+// Width for wrapping prose + list items. Use the terminal width minus a small
+// safety margin so we don't render right up to the last column and get
+// double-wrapped by the terminal. Snapshot at module-load — if the terminal
+// is resized mid-session the wrap will be slightly off but still word-safe.
+const PROSE_WIDTH = Math.max(60, (process.stdout.columns || 100) - 2);
+marked.use(markedTerminal({
+    heading: chalk.cyan.bold,
+    firstHeading: chalk.hex(PEACH).bold,
+    // `strong` (markdown bold via `**...**`) was previously plain `chalk.bold`,
+    // which emits only `[1m`. On many terminals — and inside Ink's default
+    // <Text> wrap — bold weight on white text is visually indistinguishable
+    // from normal-weight white. Pair bold with the peach brand colour so
+    // labels like `**Headline:**` stand out even when bold weight isn't
+    // rendered strongly. Cheap, safe, and consistent with firstHeading.
+    strong: chalk.bold.hex(PEACH),
+    em: chalk.italic,
+    codespan: chalk.bgGray.white,
+    code: chalk.gray,
+    blockquote: chalk.gray.italic,
+    link: chalk.blue.underline,
+    href: chalk.blue.underline,
+    listitem: chalk.white,
+    hr: chalk.gray,
+    paragraph: chalk.white,
+    // Enable reflow so paragraphs and list items wrap at WORD boundaries at
+    // the configured width, and continuation lines of list items align under
+    // the bullet content (not at column 0). Without this, marked-terminal
+    // emits unwrapped text and the terminal hard-wraps at its column limit,
+    // producing mid-word breaks like "busine\nss".
+    reflowText: true,
+    width: PROSE_WIDTH,
+    // tableOptions is consumed by our override below, not marked-terminal's default
+    // renderer (we replace it in the next marked.use call).
+}));
+// Override marked-terminal's table renderer with one that caps column widths to the
+// terminal width + word-wraps long cell content. marked-terminal's default auto-sizes
+// each column to fit its widest cell without constraint, so a single long Detail cell
+// (e.g. a radar finding with a 200-char explanation) produces a 235-column table that
+// the terminal then wraps visually, destroying the box layout.
+marked.use({
+    renderer: {
+        table(header, body) {
+            const headerRow = parseMtTableRows(header)[0] ?? [];
+            const rawBodyRows = parseMtTableRows(body);
+            if (headerRow.length === 0)
+                return `${header}${body}\n\n`;
+            // Apply severity pills to EACH CELL before cli-table3 sees them. If we
+            // left severity for the outer pipeline (applySeverity after markdown),
+            // it would wrap "HIGH" (4 chars) with " HIGH " (6 visible chars) AFTER
+            // cli-table3 had already allocated a 4-char column — the extra 2 chars
+            // then push the next `│` border right and break every following row's
+            // alignment. Applying here keeps visible widths correct via string-width.
+            const bodyRows = rawBodyRows.map((row) => row.map((c) => applySeverityToCell(c)));
+            // Natural content width per column (stripped of ANSI escapes) AND
+            // minimum word width per column (so wrap points never cut mid-word).
+            const colCount = headerRow.length;
+            const naturalWidths = new Array(colCount).fill(0);
+            const minWidths = new Array(colCount).fill(1);
+            for (const row of [headerRow, ...bodyRows]) {
+                for (let i = 0; i < colCount; i++) {
+                    const content = row[i] ?? '';
+                    const visible = stripAnsi(content);
+                    if (visible.length > naturalWidths[i])
+                        naturalWidths[i] = visible.length;
+                    // Longest whitespace-separated token — the minimum column width that
+                    // wordWrap can respect without mid-word breakage.
+                    for (const word of visible.split(/\s+/)) {
+                        if (word.length > minWidths[i])
+                            minWidths[i] = word.length;
+                    }
+                }
+            }
+            const termWidth = process.stdout.columns || 120;
+            const colWidths = computeColWidths(naturalWidths, minWidths, termWidth);
+            // Decide whether row separators are needed. When every row fits on one
+            // visual line we suppress them (avoids stairstep on small tables, see
+            // earlier comment). When ANY row will wrap (some cell content exceeds
+            // its allocated column width), the wrap line otherwise looks like a
+            // separate empty row to the reader — so re-enable thin separators
+            // between body rows. The header/body separator is suppressed in both
+            // cases (the cyan-bold header colour already separates them visually).
+            let anyRowWraps = false;
+            for (const row of bodyRows) {
+                for (let i = 0; i < colCount; i++) {
+                    const visible = stripAnsi(row[i] ?? '');
+                    // colWidths[i] = content width + 2 padding. Wrap happens when the
+                    // visible content exceeds the content width (colWidths[i] - 2).
+                    if (visible.length > (colWidths[i] - 2)) {
+                        anyRowWraps = true;
+                        break;
+                    }
+                }
+                if (anyRowWraps)
+                    break;
+            }
+            const tableChars = anyRowWraps
+                ? {} // default chars — keeps `mid: ─` so wrapped rows have separators
+                : { mid: '', 'left-mid': '', 'mid-mid': '', 'right-mid': '' };
+            const table = new Table({
+                head: headerRow,
+                colWidths,
+                wordWrap: true,
+                wrapOnWordBoundary: true,
+                style: { head: ['cyan', 'bold'], border: ['gray'] },
+                chars: tableChars,
+            });
+            for (const row of bodyRows)
+                table.push(row);
+            return zebraStripe(table.toString()) + '\n\n';
+        },
+    },
+});
+/**
+ * Apply subtle dark-gray background to every other body row.
+ *
+ * Since we suppressed the `├─┼─┤` separators (avoids stairstep on variable-height
+ * rows), the rows would otherwise visually blend together. Zebra striping
+ * distinguishes them without adding horizontal rules.
+ *
+ * Approach — post-process the rendered cli-table3 string:
+ *   - First `│…│` line after the `┌─┐` top border = header (pass through).
+ *   - Subsequent `│…│` lines up to the `└─┘` bottom = body.
+ *   - A body line is a NEW row start when the first column (between the first
+ *     two `│` chars) contains non-whitespace (cli-table3 pads continuation
+ *     lines of multi-line cells with whitespace in non-wrapping columns).
+ *   - Odd row indices get wrapped with `\x1b[48;5;235m … \x1b[49m`. Mid-line
+ *     bg-resets (e.g. when a severity pill's `\x1b[49m` ends) are rewritten
+ *     to re-apply the zebra bg so the reset doesn't punch a hole after the pill.
+ */
+const ZEBRA_BG = '\x1b[48;5;235m'; // dark gray — subtle but visible
+const ZEBRA_RESET = '\x1b[49m';
+function applyZebraBg(line) {
+    // Re-apply zebra bg after any in-line bg-reset or full-reset so the stripe
+    // survives through severity pills and inline-code spans.
+    const reZebraed = line
+        .replace(/\x1B\[49m/g, ZEBRA_BG)
+        .replace(/\x1B\[0m/g, '\x1B[0m' + ZEBRA_BG);
+    return ZEBRA_BG + reZebraed + ZEBRA_RESET;
+}
+function zebraStripe(tableText) {
+    const lines = tableText.split('\n');
+    const result = [];
+    let sawTop = false;
+    let sawHeader = false;
+    let rowIndex = -1;
+    for (const line of lines) {
+        const clean = stripAnsi(line);
+        if (clean.startsWith('┌')) {
+            sawTop = true;
+            result.push(line);
+            continue;
+        }
+        if (clean.startsWith('└')) {
+            result.push(line);
+            continue;
+        }
+        if (sawTop && !sawHeader && clean.startsWith('│')) {
+            // First `│…│` line after top border = header. Pass through (cyan+bold already applied).
+            result.push(line);
+            sawHeader = true;
+            continue;
+        }
+        if (sawHeader && clean.startsWith('│')) {
+            // Detect new row: first cell (between first and second `│`) has non-whitespace.
+            const m = clean.match(/^│([^│]*)│/);
+            const firstCellTrimmed = m ? m[1].trim() : '';
+            if (firstCellTrimmed !== '')
+                rowIndex++;
+            if (rowIndex >= 0 && rowIndex % 2 === 1) {
+                result.push(applyZebraBg(line));
+            }
+            else {
+                result.push(line);
+            }
+            continue;
+        }
+        // Pre-table blank lines, etc. — pass through.
+        result.push(line);
+    }
+    return result.join('\n');
+}
+export function renderMarkdown(input) {
+    const result = marked.parse(input);
+    return typeof result === 'string' ? result : input;
+}