@pugi/cli 0.1.0-alpha.9 → 0.1.0-beta.10

package/dist/tui/input-box.js

@@ -131,14 +131,57 @@ export function InputBox(props) {
     useInput((input, key) => {
         if (key.ctrl && input === 'c') {
             const t = now();
-            if (typeof lastCtrlCAt === 'number' && t - lastCtrlCAt <= CTRL_C_DOUBLE_TAP_MS) {
+            // α6.9: Claude Code-style double-press semantics. First Ctrl+C
+            // ALWAYS attempts to cancel an in-flight dispatch (when the
+            // session reports non-idle); second Ctrl+C within 1s exits the
+            // process. If onCancel is omitted (legacy callers, tests), the
+            // old behaviour is preserved: first Ctrl+C clears the buffer +
+            // arms the exit timer, second Ctrl+C exits.
+            const withinDoubleTapWindow = typeof lastCtrlCAt === 'number' && t - lastCtrlCAt <= CTRL_C_DOUBLE_TAP_MS;
+            if (withinDoubleTapWindow) {
+                // Second press inside the window — always exit. This matches
+                // Claude Code: even mid-dispatch, the second Ctrl+C wins so
+                // the operator can always escape a stuck REPL.
                 props.onExit();
                 return;
             }
+            // First press in a fresh window. If the host wired a cancel
+            // surface and there is something to cancel, abort the dispatch.
+            // The buffer is left untouched on a cancel (the operator's
+            // current input is NOT trashed by an accidental Ctrl+C while a
+            // tool is running).
+            //
+            // Three-valued onCancel return (see prop docstring):
+            //   - true       → dispatch cancelled, keep buffer, arm exit timer
+            //   - false      → idle, clear buffer (legacy), arm exit timer
+            //   - undefined  → handler bypassed (modal owns input); NO state
+            //                  change at all. Buffer stays, exit timer NOT
+            //                  armed (otherwise the modal would silently
+            //                  promote a Ctrl+C to "press again to exit",
+            //                  which is wrong context for a modal cancel).
+            let cancelResult;
+            if (props.onCancel) {
+                cancelResult = props.onCancel();
+            }
+            if (cancelResult === undefined && props.onCancel) {
+                // Bypass path - modal owns the input. Drop the press silently
+                // so the modal's own cancel surface (Esc / its own Ctrl+C
+                // binding inside the modal component) takes effect on its own
+                // terms. P2 fix: previously this fell through to the
+                // legacy buffer-clear + setLastCtrlCAt path and wiped modal
+                // draft text on first Ctrl+C.
+                return;
+            }
             setLastCtrlCAt(t);
-            setLine('');
-            setCursor(0);
-            setSearch(undefined);
+            // Legacy behaviour: on idle (or no onCancel wired), clear the
+            // buffer + reset search so the operator's screen is calm before
+            // they confirm exit. When we DID cancel a live dispatch, keep
+            // the buffer so a half-typed brief is not lost.
+            if (cancelResult !== true) {
+                setLine('');
+                setCursor(0);
+                setSearch(undefined);
+            }
             return;
         }
         // Search-mode key handling. Ctrl+R / Ctrl+S cycle, Enter accepts,
@@ -456,7 +499,7 @@ export function InputBox(props) {
         : Math.min(paletteIndex, paletteView.rows.length - 1);
     const divider = '─'.repeat(innerWidth);
     const focusedMatch = search ? search.matches[search.focusedIndex] : undefined;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", dimColor: true, children: divider }), _jsx(Box, { paddingX: 1, flexDirection: "column", children: search ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '(reverse-i-search) ' }), _jsx(Text, { children: `\`${search.query}\`: ` }), _jsx(Text, { color: "yellow", children: focusedMatch ? focusedMatch.brief : '(no match)' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `Ctrl+R next  ·  Ctrl+S prev  ·  Enter accept  ·  Esc cancel  ·  ${search.matches.length} match${search.matches.length === 1 ? '' : 'es'}` }) })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '› ' }), _jsx(Text, { children: renderLineWithCursor(line, cursor, cursorVisible) })] })) }), _jsx(Text, { color: "cyan", dimColor: true, children: divider }), line.length > innerWidth - 4 ? (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: '┊ ' }), _jsx(Text, { dimColor: true, children: 'line wraps - Enter still submits' })] })) : null, _jsx(SlashPalette, { rows: paletteView.rows, focusedIndex: clampedPaletteIndex, totalBeforeLimit: paletteView.totalBeforeLimit }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '↑/↓ history  ·  Ctrl+R search  ·  / commands  ·  Enter brief  ·  Esc cancel  ·  Ctrl+C ×2 exit' }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", dimColor: true, children: divider }), _jsx(Box, { paddingX: 1, flexDirection: "column", children: search ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '(reverse-i-search) ' }), _jsx(Text, { children: `\`${search.query}\`: ` }), _jsx(Text, { color: "yellow", children: focusedMatch ? focusedMatch.brief : '(no match)' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `Ctrl+R next  ·  Ctrl+S prev  ·  Enter accept  ·  Esc cancel  ·  ${search.matches.length} match${search.matches.length === 1 ? '' : 'es'}` }) })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '› ' }), _jsx(Text, { children: renderLineWithCursor(line, cursor, cursorVisible) })] })) }), _jsx(Text, { color: "cyan", dimColor: true, children: divider }), line.length > innerWidth - 4 ? (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: '┊ ' }), _jsx(Text, { dimColor: true, children: 'line wraps - Enter still submits' })] })) : null, _jsx(SlashPalette, { rows: paletteView.rows, focusedIndex: clampedPaletteIndex, totalBeforeLimit: paletteView.totalBeforeLimit }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '↑/↓ history  ·  Ctrl+R search  ·  / commands  ·  Enter brief  ·  Esc cancel  ·  Ctrl+C abort / ×2 exit' }) })] }));
 }
 /**
  * Render the line with the cursor glyph inserted at `cursor`. The cursor

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