@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.2

package/dist/tui/login-picker.js

@@ -1,69 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-const ITEMS = [
-    {
-        provider: 'device',
-        title: 'Browser OAuth',
-        hint: 'Opens app.pugi.io in your browser to approve this device',
-    },
-    {
-        provider: 'token',
-        title: 'API key',
-        hint: 'Paste a personal access token (pugi.io/settings/api-keys)',
-    },
-    {
-        provider: 'env',
-        title: 'Environment variable',
-        hint: 'Use PUGI_API_KEY from the current shell',
-    },
-];
-/**
- * Arrow-key login picker. Driven entirely by Ink's `useInput`. The
- * component does NOT perform the OAuth flow itself, it only resolves
- * the selected provider back to the caller (CLI dispatcher), which
- * then unmounts Ink and hands control to the existing handlers in
- * runtime/cli.ts.
- */
-export function LoginPicker(props) {
-    const [index, setIndex] = useState(Math.min(Math.max(props.initialIndex ?? 0, 0), ITEMS.length - 1));
-    useInput((input, key) => {
-        if (key.upArrow || input === 'k') {
-            setIndex((current) => (current === 0 ? ITEMS.length - 1 : current - 1));
-            return;
-        }
-        if (key.downArrow || input === 'j') {
-            setIndex((current) => (current === ITEMS.length - 1 ? 0 : current + 1));
-            return;
-        }
-        if (key.return) {
-            const selected = ITEMS[index];
-            if (selected)
-                props.onSelect(selected.provider);
-            return;
-        }
-        if (key.escape || input === 'q') {
-            props.onCancel();
-            return;
-        }
-        // Number shortcuts mirror the legacy text picker for muscle memory.
-        if (input === '1')
-            props.onSelect('device');
-        if (input === '2')
-            props.onSelect('token');
-        if (input === '3')
-            props.onSelect('env');
-    });
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Sign in to Pugi" }), _jsx(Text, { dimColor: true, children: `     (endpoint: ${props.apiUrl})` })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: ITEMS.map((item, itemIndex) => {
-                    const isSelected = itemIndex === index;
-                    return (_jsx(PickerRow, { isSelected: isSelected, title: item.title, hint: item.hint }, item.provider));
-                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '↑/↓ select  Enter confirm  Esc cancel' }) })] }));
-}
-function PickerRow({ isSelected, title, hint, }) {
-    // Arrow glyph + padded title so highlighted and dim rows share
-    // column alignment.
-    const indicator = isSelected ? '▸ ' : ' ';
-    const padded = title.padEnd(22, ' ');
-    return (_jsxs(Text, { children: [_jsxs(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: [indicator, padded] }), _jsx(Text, { dimColor: true, children: hint })] }));
-}
-//# sourceMappingURL=login-picker.js.map

package/dist/tui/markdown-render.js

@@ -1,266 +0,0 @@
-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: "#3da9fc", children: '• ' }), _jsx(Text, { children: renderInline(block.text) })] }, key));
-        case 'ordered':
-            return (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", 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: "#3da9fc", 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: "#3da9fc", underline: true, children: span.text }), _jsx(Text, { dimColor: true, children: ` (${span.url})` })] }, key));
-    }
-}
-//# sourceMappingURL=markdown-render.js.map