@pugi/cli 0.1.0-alpha.10 → 0.1.0-alpha.16

package/dist/tui/ask-cli.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, useApp } from 'ink';
+import { AskModal, PlanReviewModal } from './ask-modal.js';
+export async function renderAskCli(options) {
+    let resolveOuter;
+    const outerPromise = new Promise((resolve) => {
+        resolveOuter = resolve;
+    });
+    function App() {
+        const { exit } = useApp();
+        return (_jsx(AskModal, { tag: options.tag, onResolve: (verdict) => {
+                resolveOuter(verdict);
+                // Slight delay so Ink flushes the unmount before the parent
+                // CLI prints the verdict line. Otherwise the modal frame and
+                // the verdict line can interleave on slow terminals.
+                setTimeout(() => exit(), 16);
+            } }));
+    }
+    const instance = render(_jsx(App, {}));
+    const verdict = await outerPromise;
+    try {
+        await instance.waitUntilExit();
+    }
+    catch {
+        // Ink may throw if exit() races with a re-render; the verdict is
+        // already captured so we ignore.
+    }
+    return verdict;
+}
+export async function renderPlanReviewCli(options) {
+    let resolveOuter;
+    const outerPromise = new Promise((resolve) => {
+        resolveOuter = resolve;
+    });
+    function App() {
+        const { exit } = useApp();
+        return (_jsx(PlanReviewModal, { tag: options.tag, onResolve: (result) => {
+                resolveOuter(result);
+                setTimeout(() => exit(), 16);
+            } }));
+    }
+    const instance = render(_jsx(App, {}));
+    const result = await outerPromise;
+    try {
+        await instance.waitUntilExit();
+    }
+    catch {
+        // See renderAskCli — captured verdict supersedes a late Ink throw.
+    }
+    return result;
+}
+//# sourceMappingURL=ask-cli.js.map

package/dist/tui/ask-modal.js

@@ -0,0 +1,211 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Office-hours forcing questions + plan-review modals - Sprint α6.3.
+ *
+ * Two Ink components feed by the parsed `<pugi-ask>` / `<pugi-plan-review>`
+ * tag records the session module extracts from persona output.
+ *
+ *   - <AskModal />: numbered options (1-4) + optional "Other" custom-input
+ *     fallback. Operator types `1`, `2`, `3`, `4`, or `o <free text>`.
+ *
+ *   - <PlanReviewModal />: numbered steps + optional risk callout +
+ *     three-way verdict `[a] approve · [m] modify · [c] cancel`.
+ *     Operator types `a`, `m`, or `c`. `m` opens a free-text editor;
+ *     the operator's edited text is returned verbatim to the session.
+ *
+ * Both components are PURE in the Ink sense — they read props + own
+ * useState for the input buffer, and emit one final `onResolve` callback
+ * when the operator submits. The REPL root handles wiring the verdict
+ * back into the session as the next user turn (prefixed with
+ * `[ASK-RESPONSE:<value>]` / `[PLAN-VERDICT:approve|modify|cancel] ...`)
+ * so the persona transcript stays linear.
+ *
+ * Brand voice gate: ASCII glyphs only, no em-dashes, no banned brand
+ * words (journey, explore, delight, magical, friendly, AI-powered,
+ * pug-tastic). The modal copy is power-word neutral so a localized
+ * variant lands cleanly later.
+ */
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export function AskModal(props) {
+    const [mode, setMode] = useState('pick');
+    const [buffer, setBuffer] = useState('');
+    useInput((input, key) => {
+        // Esc cancels the modal in either mode.
+        if (key.escape) {
+            props.onResolve({ value: '', cancelled: true });
+            return;
+        }
+        if (mode === 'pick') {
+            // Numeric keys 1..N select the matching option, capped at the
+            // total option count. Out-of-range keys are ignored.
+            const numeric = Number.parseInt(input, 10);
+            if (!Number.isNaN(numeric) && numeric >= 1 && numeric <= props.tag.options.length) {
+                const opt = props.tag.options[numeric - 1];
+                if (opt) {
+                    props.onResolve({ value: opt.value, cancelled: false });
+                    return;
+                }
+            }
+            // The "Other" sentinel is the index = options.length + 1. We
+            // also accept `o` (lowercase) as a hotkey since the cursor key
+            // for "Other" is always one-past-the-last numeric.
+            const otherIndex = props.tag.options.length + 1;
+            if ((!Number.isNaN(numeric) && numeric === otherIndex)
+                || input === 'o'
+                || input === 'O') {
+                setMode('custom');
+                setBuffer('');
+                return;
+            }
+            // Any other keystroke: ignored. The hint footer tells the
+            // operator the legal keys.
+            return;
+        }
+        // Custom-input mode: line editor.
+        if (key.return) {
+            // Empty buffer + Enter = cancel custom (return to pick).
+            if (buffer.trim().length === 0) {
+                setMode('pick');
+                setBuffer('');
+                return;
+            }
+            props.onResolve({
+                value: '',
+                customInput: buffer.trim(),
+                cancelled: false,
+            });
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setBuffer((prev) => prev.slice(0, -1));
+            return;
+        }
+        if (input && !key.meta && !key.ctrl) {
+            setBuffer((prev) => prev + input);
+        }
+    }, { isActive: props.inert !== true });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: '? ' }), _jsx(Text, { bold: true, children: 'Need your call before I continue' })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: props.tag.question }) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [props.tag.options.map((opt, idx) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${idx + 1}. ` }), _jsx(Text, { children: opt.label })] }), opt.desc ? (_jsx(Box, { marginLeft: 5, children: _jsx(Text, { dimColor: true, children: opt.desc }) })) : null] }, opt.value))), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${props.tag.options.length + 1}. ` }), _jsx(Text, { dimColor: true, children: 'Other (type a custom answer)' })] })] }), mode === 'pick' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: `Press 1-${props.tag.options.length + 1} to choose. Esc cancels.` }) })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type your custom answer. Enter submits. Esc cancels.' }) })] }))] }));
+}
+export function PlanReviewModal(props) {
+    const [mode, setMode] = useState('pick');
+    const [buffer, setBuffer] = useState('');
+    useInput((input, key) => {
+        if (key.escape) {
+            // Escape from EITHER mode means cancel — symmetric with AskModal.
+            props.onResolve({ verdict: 'cancel' });
+            return;
+        }
+        if (mode === 'pick') {
+            if (input === 'a' || input === 'A') {
+                props.onResolve({ verdict: 'approve' });
+                return;
+            }
+            if (input === 'c' || input === 'C') {
+                props.onResolve({ verdict: 'cancel' });
+                return;
+            }
+            if (input === 'm' || input === 'M') {
+                setMode('modify');
+                setBuffer('');
+                return;
+            }
+            return;
+        }
+        // Modify-mode line editor.
+        if (key.return) {
+            if (buffer.trim().length === 0) {
+                setMode('pick');
+                setBuffer('');
+                return;
+            }
+            props.onResolve({ verdict: 'modify', modifyText: buffer.trim() });
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setBuffer((prev) => prev.slice(0, -1));
+            return;
+        }
+        if (input && !key.meta && !key.ctrl) {
+            setBuffer((prev) => prev + input);
+        }
+    }, { isActive: props.inert !== true });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "magenta", children: '? ' }), _jsx(Text, { bold: true, children: 'Plan review - approve before I execute' })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: 'Steps:' }), props.tag.steps.map((step, idx) => (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${idx + 1}. ` }), _jsx(Text, { children: step.text })] }, `step-${idx}`)))] }), props.tag.risk ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "red", children: 'Risk:' }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { children: props.tag.risk }) })] })) : null, mode === 'pick' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: '  [a] approve  ' }), _jsx(Text, { color: "yellow", bold: true, children: '[m] modify  ' }), _jsx(Text, { color: "red", bold: true, children: '[c] cancel' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Press a, m, or c. Esc cancels.' }) })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: 'modify > ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type the revision. Enter submits. Esc cancels.' }) })] }))] }));
+}
+/* ------------------------------------------------------------------ */
+/* Verdict serialisation                                              */
+/* ------------------------------------------------------------------ */
+/**
+ * Encode an ask-modal verdict into the literal string the session
+ * injects as the next operator turn. The persona's prompt teaches it
+ * to recognise this prefix, so the conversation stays coherent without
+ * a side channel.
+ *
+ * Examples:
+ *   { value: 'vercel' }              -> "[ASK-RESPONSE:vercel]"
+ *   { value: '', customInput: 'gcp'} -> "[ASK-RESPONSE:other] gcp"
+ *   { cancelled: true }              -> "[ASK-RESPONSE:cancelled]"
+ *
+ * customInput is stripped of any leading `[ASK-RESPONSE:...]` /
+ * `[PLAN-VERDICT:...]` pattern so a forged operator prefix cannot be
+ * read as a different verdict by a prefix-greedy persona (Claude
+ * triple-review P1, PR #375).
+ */
+export function encodeAskVerdict(verdict) {
+    if (verdict.cancelled)
+        return '[ASK-RESPONSE:cancelled]';
+    if (verdict.value.length > 0)
+        return `[ASK-RESPONSE:${verdict.value}]`;
+    const customInput = verdict.customInput
+        ? sanitiseVerdictText(verdict.customInput)
+        : '';
+    if (customInput.length > 0) {
+        return `[ASK-RESPONSE:other] ${customInput}`;
+    }
+    return '[ASK-RESPONSE:cancelled]';
+}
+/**
+ * Encode a plan-review verdict into the next operator turn. Mirrors
+ * the ask encoding so the persona sees a single grammar.
+ *
+ * modifyText is sanitised against verdict-header forgery the same way
+ * customInput is in encodeAskVerdict (Claude triple-review P1).
+ */
+export function encodePlanReviewVerdict(result) {
+    switch (result.verdict) {
+        case 'approve':
+            return '[PLAN-VERDICT:approve]';
+        case 'cancel':
+            return '[PLAN-VERDICT:cancel]';
+        case 'modify': {
+            const modifyText = result.modifyText
+                ? sanitiseVerdictText(result.modifyText)
+                : '';
+            if (modifyText.length > 0) {
+                return `[PLAN-VERDICT:modify] ${modifyText}`;
+            }
+            return '[PLAN-VERDICT:cancel]';
+        }
+    }
+}
+/**
+ * Strip any leading `[ASK-RESPONSE:...]` or `[PLAN-VERDICT:...]`
+ * pattern from free-text operator input so a malicious or accidental
+ * operator string cannot forge a verdict header. Iterates because the
+ * operator could prepend several forged headers in a row.
+ *
+ * Mirrors the same-named helper in core/repl/session.ts. Kept in both
+ * modules so the test surfaces of ask-modal and session are
+ * independently exercisable without circular imports.
+ */
+function sanitiseVerdictText(raw) {
+    let cleaned = raw;
+    for (let i = 0; i < raw.length + 4; i += 1) {
+        const stripped = cleaned.replace(/^\s*\[(?:ASK-RESPONSE|PLAN-VERDICT):[^\]]*\]\s*/u, '');
+        if (stripped === cleaned)
+            break;
+        cleaned = stripped;
+    }
+    return cleaned.trim();
+}
+//# sourceMappingURL=ask-modal.js.map

package/dist/tui/conversation-pane.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { MarkdownRender } from './markdown-render.js';
 const HUE_COLOR_BY_SLUG = {
     // Mira (Pug) - coordinator
     main: 'cyan',
@@ -23,10 +24,14 @@ const HUE_COLOR_BY_SLUG = {
     analyst: 'gray',
 };
 export function ConversationPane(props) {
+    const showHeader = props.showHeader !== false;
     if (props.rows.length === 0) {
-        return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Brief the workforce to begin. Try a short sentence or /help." }) }));
+        return (_jsxs(Box, { flexDirection: "column", children: [showHeader ? _jsx(PaneHeader, { count: 0 }) : null, _jsx(Text, { dimColor: true, children: "Brief the workforce to begin. Try a short sentence or /help." })] }));
     }
-    return (_jsx(Box, { flexDirection: "column", children: props.rows.map((row) => (_jsx(ConversationRow, { row: row, personaNames: props.personaNames }, row.id))) }));
+    return (_jsxs(Box, { flexDirection: "column", children: [showHeader ? _jsx(PaneHeader, { count: props.rows.length }) : null, props.rows.map((row) => (_jsx(ConversationRow, { row: row, personaNames: props.personaNames }, row.id)))] }));
+}
+function PaneHeader({ count }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { bold: true, dimColor: true, children: '─ conversation ' }), _jsx(Text, { dimColor: true, children: `(${count} row${count === 1 ? '' : 's'})` })] }));
 }
 function ConversationRow({ row, personaNames, }) {
     switch (row.source) {
@@ -38,8 +43,48 @@ function ConversationRow({ row, personaNames, }) {
             const slug = row.personaSlug ?? '';
             const color = HUE_COLOR_BY_SLUG[slug] ?? 'white';
             const displayName = personaNames?.get(slug) ?? slug;
-            return (_jsxs(Box, { children: [_jsx(Text, { color: color, bold: true, children: `▸ ${displayName} ` }), _jsx(Text, { children: row.text })] }));
+            // α6.12: persona bodies travel through MarkdownRender so code
+            // fences, headings, and inline accents land correctly. A row that
+            // carries no Markdown syntax renders as plain text under the same
+            // path (the parser falls through to a single paragraph span), so
+            // there is no regression for the simple "Mira shipped." baseline.
+            const containsMarkdown = looksLikeMarkdown(row.text);
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: color, bold: true, children: `▸ ${displayName} ` }), containsMarkdown ? null : _jsx(Text, { children: row.text })] }), containsMarkdown ? (_jsx(Box, { marginLeft: 2, children: _jsx(MarkdownRender, { source: row.text }) })) : null] }));
         }
     }
 }
+/**
+ * Cheap heuristic for "this transcript row will benefit from Markdown
+ * rendering". We only pay the parser cost when the row plausibly
+ * contains a code fence, heading, list item, or inline accent. A bare
+ * "Mira shipped." line takes the legacy fast path.
+ *
+ * The probe is intentionally generous - false positives just route
+ * through the parser, which renders plain text identically.
+ */
+function looksLikeMarkdown(text) {
+    if (text.length === 0)
+        return false;
+    if (text.includes('```'))
+        return true;
+    // Codex P2 PR #369: intro-plus-list shape ("Summary:\n- bullet")
+    // must route through renderer. Scan EVERY line, not just the first.
+    const lines = text.split('\n');
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (/^#{1,6}\s/.test(line))
+            return true;
+        if (/^[-*+]\s/.test(line))
+            return true;
+        if (/^\d+\.\s/.test(line))
+            return true;
+    }
+    if (/\*\*[^*]+\*\*/.test(text))
+        return true;
+    if (/`[^`]+`/.test(text))
+        return true;
+    if (/\[[^\]]+\]\([^)]+\)/.test(text))
+        return true;
+    return false;
+}
 //# sourceMappingURL=conversation-pane.js.map

package/dist/tui/markdown-render.js

@@ -0,0 +1,266 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+const HEADING_COLORS = ['cyan', 'magenta', 'yellow'];
+/**
+ * Very small keyword table for cosmetic code accent. The fence label is
+ * matched case-insensitively against a handful of languages we expect
+ * the personas to emit (ts/tsx/js/jsx/py/sh). Unknown languages render
+ * the body in white - no syntax error, no warning. Tests assert that
+ * an empty fence label still produces a bordered Box (no crash).
+ */
+const KEYWORDS_BY_LANG = {
+    ts: ['const', 'let', 'var', 'function', 'class', 'interface', 'type', 'import', 'export', 'from', 'return', 'if', 'else', 'for', 'while', 'await', 'async', 'new', 'this', 'static', 'public', 'private', 'protected', 'readonly', 'extends', 'implements'],
+    tsx: ['const', 'let', 'var', 'function', 'class', 'interface', 'type', 'import', 'export', 'from', 'return', 'if', 'else', 'for', 'while', 'await', 'async', 'new', 'this', 'static', 'public', 'private', 'protected', 'readonly', 'extends', 'implements'],
+    js: ['const', 'let', 'var', 'function', 'class', 'import', 'export', 'from', 'return', 'if', 'else', 'for', 'while', 'await', 'async', 'new', 'this'],
+    jsx: ['const', 'let', 'var', 'function', 'class', 'import', 'export', 'from', 'return', 'if', 'else', 'for', 'while', 'await', 'async', 'new', 'this'],
+    py: ['def', 'class', 'import', 'from', 'return', 'if', 'else', 'elif', 'for', 'while', 'with', 'as', 'try', 'except', 'finally', 'raise', 'lambda', 'pass', 'yield', 'None', 'True', 'False'],
+    sh: ['if', 'then', 'else', 'fi', 'for', 'do', 'done', 'while', 'case', 'esac', 'function', 'return', 'export'],
+    bash: ['if', 'then', 'else', 'fi', 'for', 'do', 'done', 'while', 'case', 'esac', 'function', 'return', 'export'],
+};
+/**
+ * Top-level entry point. Splits the source into lines, runs the
+ * block-level state machine, and emits an Ink tree. The component is
+ * memo-friendly (pure function of `source`) but we don't wrap in
+ * React.memo here - the conversation pane already memoises row keys.
+ */
+export function MarkdownRender(props) {
+    const blocks = parseBlocks(props.source);
+    const children = blocks.map((block, index) => renderBlock(block, index));
+    if (props.inline) {
+        return _jsx(_Fragment, { children: children });
+    }
+    return _jsx(Box, { flexDirection: "column", children: children });
+}
+/**
+ * Walk the source line by line and emit one Block per visual unit. The
+ * state machine has two modes: default (heading / list / paragraph) and
+ * in-code (every line is appended verbatim to the current code block).
+ *
+ * Inside a code fence we DO NOT process inline syntax - the body is
+ * preserved literally so the operator sees code that actually runs.
+ */
+function parseBlocks(source) {
+    const lines = source.split(/\r?\n/);
+    const blocks = [];
+    let inCode = false;
+    let codeLang = '';
+    let codeBody = [];
+    for (const raw of lines) {
+        const line = raw;
+        if (inCode) {
+            if (/^```/.test(line)) {
+                blocks.push({ kind: 'code', lang: codeLang, body: codeBody.join('\n') });
+                inCode = false;
+                codeBody = [];
+                codeLang = '';
+                continue;
+            }
+            codeBody.push(line);
+            continue;
+        }
+        const fenceMatch = /^```([A-Za-z0-9_+-]*)\s*$/.exec(line);
+        if (fenceMatch) {
+            inCode = true;
+            codeLang = (fenceMatch[1] ?? '').toLowerCase();
+            continue;
+        }
+        if (line.trim().length === 0) {
+            blocks.push({ kind: 'blank' });
+            continue;
+        }
+        const headingMatch = /^(#{1,3})\s+(.+?)\s*#*\s*$/.exec(line);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const text = headingMatch[2];
+            blocks.push({ kind: 'heading', level, text });
+            continue;
+        }
+        const bulletMatch = /^\s*[-*]\s+(.+)$/.exec(line);
+        if (bulletMatch) {
+            blocks.push({ kind: 'bullet', text: bulletMatch[1] });
+            continue;
+        }
+        const orderedMatch = /^\s*(\d+)\.\s+(.+)$/.exec(line);
+        if (orderedMatch) {
+            blocks.push({ kind: 'ordered', index: orderedMatch[1], text: orderedMatch[2] });
+            continue;
+        }
+        blocks.push({ kind: 'paragraph', text: line });
+    }
+    // Unterminated fence: surface what we have as code so the operator
+    // still sees the body. Mirrors GitHub's render behavior.
+    if (inCode) {
+        blocks.push({ kind: 'code', lang: codeLang, body: codeBody.join('\n') });
+    }
+    return blocks;
+}
+/* ------------------------------------------------------------------ */
+/* Block renderers                                                    */
+/* ------------------------------------------------------------------ */
+function renderBlock(block, key) {
+    switch (block.kind) {
+        case 'heading': {
+            const color = HEADING_COLORS[block.level - 1] ?? 'cyan';
+            const prefix = '#'.repeat(block.level);
+            return (_jsx(Text, { bold: true, color: color, children: `${prefix} ${block.text}` }, key));
+        }
+        case 'paragraph':
+            return (_jsx(Text, { children: renderInline(block.text) }, key));
+        case 'bullet':
+            return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '• ' }), _jsx(Text, { children: renderInline(block.text) })] }, key));
+        case 'ordered':
+            return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: `${block.index}. ` }), _jsx(Text, { children: renderInline(block.text) })] }, key));
+        case 'code':
+            return renderCodeBlock(block.lang, block.body, key);
+        case 'blank':
+            // One-line spacer between blocks. We render an empty Text so the
+            // height accounting in Ink matches what the operator sees.
+            return _jsx(Text, { children: " " }, key);
+    }
+}
+function renderCodeBlock(lang, body, key) {
+    const lines = body.split('\n');
+    const keywords = KEYWORDS_BY_LANG[lang] ?? [];
+    return (_jsx(Box, { borderStyle: "round", borderColor: "gray", flexDirection: "column", paddingX: 1, children: lines.map((line, index) => (_jsx(Text, { children: renderCodeLine(line, keywords) }, index))) }, key));
+}
+/**
+ * Per-line code accent. We do NOT build a real lexer - we split on
+ * whitespace + punctuation boundaries and color matched keywords cyan,
+ * single/double quoted strings green, and `//` / `#` comment tails gray.
+ * The output is a list of Ink Text spans. Anything unmatched stays
+ * plain white.
+ */
+function renderCodeLine(line, keywords) {
+    // Comment tail wins first - we strip it and color the rest.
+    const commentIndex = findCommentStart(line);
+    const code = commentIndex >= 0 ? line.slice(0, commentIndex) : line;
+    const comment = commentIndex >= 0 ? line.slice(commentIndex) : '';
+    const spans = [];
+    // Tokenise the code portion: alternate runs of word chars vs the rest.
+    // Strings are matched as a whole quoted span. The regex is anchored
+    // sticky to avoid catastrophic backtracking on long lines.
+    const tokenRe = /("[^"]*"|'[^']*'|`[^`]*`|\w+|\s+|[^\s\w]+)/g;
+    let match;
+    let key = 0;
+    while ((match = tokenRe.exec(code)) !== null) {
+        const tok = match[0];
+        if (/^["'`].*["'`]$/.test(tok)) {
+            spans.push(_jsx(Text, { color: "green", children: tok }, key));
+        }
+        else if (keywords.includes(tok)) {
+            spans.push(_jsx(Text, { color: "cyan", bold: true, children: tok }, key));
+        }
+        else {
+            spans.push(_jsx(Text, { children: tok }, key));
+        }
+        key += 1;
+    }
+    if (comment.length > 0) {
+        spans.push(_jsx(Text, { color: "gray", children: comment }, "comment"));
+    }
+    return _jsx(_Fragment, { children: spans });
+}
+function findCommentStart(line) {
+    // Single-line // or # outside of string literals. The probe is
+    // adequate for the persona-emitted snippets - a string literal that
+    // contains `//` would mis-color, but the output stays readable.
+    let inString = null;
+    for (let i = 0; i < line.length; i += 1) {
+        const ch = line[i];
+        if (inString) {
+            if (ch === inString && line[i - 1] !== '\\')
+                inString = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            inString = ch;
+            continue;
+        }
+        if (ch === '/' && line[i + 1] === '/')
+            return i;
+        if (ch === '#')
+            return i;
+    }
+    return -1;
+}
+/* ------------------------------------------------------------------ */
+/* Inline tokeniser                                                   */
+/* ------------------------------------------------------------------ */
+/**
+ * Parse one paragraph line into a list of inline spans, then render
+ * them as Ink Text nodes. We walk the source left-to-right and greedily
+ * consume the longest delimiter we find. Unmatched delimiters fall
+ * through as literal text - personas type `**` mid-sentence sometimes.
+ */
+function renderInline(source) {
+    const spans = tokeniseInline(source);
+    return (_jsx(_Fragment, { children: spans.map((span, index) => renderSpan(span, index)) }));
+}
+function tokeniseInline(source) {
+    const spans = [];
+    let buffer = '';
+    let i = 0;
+    while (i < source.length) {
+        const rest = source.slice(i);
+        // Inline code wins over bold/italic so that `**` inside backticks
+        // renders literally.
+        const codeMatch = /^`([^`]+)`/.exec(rest);
+        if (codeMatch) {
+            flush(buffer, spans);
+            buffer = '';
+            spans.push({ kind: 'code', text: codeMatch[1] });
+            i += codeMatch[0].length;
+            continue;
+        }
+        // Link before bold/italic so `[text **bold**](url)` renders linkish.
+        const linkMatch = /^\[([^\]]+)\]\(([^)\s]+)\)/.exec(rest);
+        if (linkMatch) {
+            flush(buffer, spans);
+            buffer = '';
+            spans.push({ kind: 'link', text: linkMatch[1], url: linkMatch[2] });
+            i += linkMatch[0].length;
+            continue;
+        }
+        // Bold (**) before italic (*) so the greedy match wins.
+        const boldMatch = /^\*\*([^*]+)\*\*/.exec(rest);
+        if (boldMatch) {
+            flush(buffer, spans);
+            buffer = '';
+            spans.push({ kind: 'bold', text: boldMatch[1] });
+            i += boldMatch[0].length;
+            continue;
+        }
+        const italicMatch = /^\*([^*]+)\*/.exec(rest);
+        if (italicMatch) {
+            flush(buffer, spans);
+            buffer = '';
+            spans.push({ kind: 'italic', text: italicMatch[1] });
+            i += italicMatch[0].length;
+            continue;
+        }
+        buffer += source[i];
+        i += 1;
+    }
+    flush(buffer, spans);
+    return spans;
+}
+function flush(buffer, spans) {
+    if (buffer.length === 0)
+        return;
+    spans.push({ kind: 'text', text: buffer });
+}
+function renderSpan(span, key) {
+    switch (span.kind) {
+        case 'text':
+            return _jsx(Text, { children: span.text }, key);
+        case 'bold':
+            return _jsx(Text, { bold: true, children: span.text }, key);
+        case 'italic':
+            return _jsx(Text, { italic: true, children: span.text }, key);
+        case 'code':
+            return _jsx(Text, { color: "green", children: span.text }, key);
+        case 'link':
+            return (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", underline: true, children: span.text }), _jsx(Text, { dimColor: true, children: ` (${span.url})` })] }, key));
+    }
+}
+//# sourceMappingURL=markdown-render.js.map