browzy 1.0.0

package/dist/cli/components/Markdown.js

@@ -0,0 +1,324 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { Text } from 'ink';
+import chalk from 'chalk';
+import { getTheme } from '../theme.js';
+const tokenCache = new Map();
+const MAX_CACHE = 500;
+// Check a larger sample for markdown syntax
+const MD_SYNTAX_RE = /[#*`|[\]>\-_]|\n\n|^\d+\. /;
+/**
+ * Render markdown as styled terminal text.
+ * Handles: headers, bold, italic, code blocks, blockquotes,
+ * lists, wiki links, markdown links, horizontal rules, tables.
+ * Strikethrough disabled (~ used for "approximately" too often).
+ */
+export function renderMarkdown(input) {
+    // Fast path: skip parsing for plain text (check first 1000 chars)
+    if (!MD_SYNTAX_RE.test(input.slice(0, 1000))) {
+        return input;
+    }
+    const cached = tokenCache.get(input);
+    if (cached)
+        return cached;
+    const theme = getTheme();
+    const lines = input.split('\n');
+    const result = [];
+    let inCodeBlock = false;
+    let codeBlockLang = '';
+    let codeLines = [];
+    let inTable = false;
+    let tableRows = [];
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx];
+        // Display math blocks $$...$$ (standalone lines)
+        if (line.trim().startsWith('$$') && !inCodeBlock) {
+            // Collect until closing $$
+            let mathContent = line.trim().slice(2);
+            if (mathContent.endsWith('$$')) {
+                // Single-line display math
+                mathContent = mathContent.slice(0, -2);
+                result.push('  ' + chalk.hex(theme.accent)(latexToUnicode(mathContent.trim())));
+                continue;
+            }
+            // Multi-line: collect until $$
+            const mathLines = [mathContent];
+            while (++lineIdx < lines.length) {
+                const ml = lines[lineIdx];
+                if (ml.trim().endsWith('$$')) {
+                    mathLines.push(ml.trim().slice(0, -2));
+                    break;
+                }
+                mathLines.push(ml);
+            }
+            const fullMath = mathLines.join(' ').trim();
+            result.push('  ' + chalk.hex(theme.accent)(latexToUnicode(fullMath)));
+            continue;
+        }
+        // Code blocks
+        if (line.startsWith('```')) {
+            if (inCodeBlock) {
+                result.push(chalk.dim('  ┌─' + (codeBlockLang ? ` ${codeBlockLang} ` : '') + '─'));
+                for (const cl of codeLines) {
+                    result.push(chalk.dim('  │ ') + chalk.hex(theme.text)(cl));
+                }
+                result.push(chalk.dim('  └─'));
+                codeLines = [];
+                codeBlockLang = '';
+                inCodeBlock = false;
+            }
+            else {
+                inCodeBlock = true;
+                codeBlockLang = line.slice(3).trim();
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            codeLines.push(line);
+            continue;
+        }
+        // Tables: detect pipe-delimited lines
+        if (line.includes('|') && line.trim().startsWith('|')) {
+            const cells = line.split('|').slice(1, -1).map(c => c.trim());
+            // Skip separator rows (---|---|---)
+            if (cells.every(c => /^[-:]+$/.test(c)))
+                continue;
+            if (!inTable) {
+                inTable = true;
+                tableRows = [];
+            }
+            tableRows.push(cells);
+            continue;
+        }
+        else if (inTable) {
+            // Flush table
+            result.push(...renderTable(tableRows, theme));
+            tableRows = [];
+            inTable = false;
+        }
+        // Headers
+        const headerMatch = line.match(/^(#{1,3})\s+(.+)/);
+        if (headerMatch) {
+            const level = headerMatch[1].length;
+            const text = headerMatch[2];
+            const color = level === 1 ? theme.brand : level === 2 ? theme.brandLight : theme.accent;
+            result.push(chalk.hex(color).bold(text));
+            continue;
+        }
+        // Blockquotes
+        if (line.startsWith('> ')) {
+            result.push(chalk.hex(theme.textMuted)('  │ ') + chalk.italic(formatInline(line.slice(2), theme)));
+            continue;
+        }
+        // Horizontal rules
+        if (/^[-*_]{3,}\s*$/.test(line.trim())) {
+            result.push(chalk.hex(theme.separator)('─'.repeat(40)));
+            continue;
+        }
+        // List items — numbered and bulleted
+        const bulletMatch = line.match(/^(\s*)([-*+])\s+(.*)/);
+        if (bulletMatch) {
+            const indent = bulletMatch[1];
+            const content = bulletMatch[3];
+            result.push(`${indent}${chalk.hex(theme.accent)('•')} ${formatInline(content, theme)}`);
+            continue;
+        }
+        const numberedMatch = line.match(/^(\s*)(\d+)\.\s+(.*)/);
+        if (numberedMatch) {
+            const indent = numberedMatch[1];
+            const num = numberedMatch[2];
+            const content = numberedMatch[3];
+            result.push(`${indent}${chalk.hex(theme.accent)(num + '.')} ${formatInline(content, theme)}`);
+            continue;
+        }
+        // Regular text with inline formatting
+        result.push(formatInline(line, theme));
+    }
+    // Flush any remaining table
+    if (inTable && tableRows.length > 0) {
+        result.push(...renderTable(tableRows, theme));
+    }
+    const output = result.join('\n');
+    // LRU-ish cache
+    if (tokenCache.size >= MAX_CACHE) {
+        const firstKey = tokenCache.keys().next().value;
+        if (firstKey !== undefined)
+            tokenCache.delete(firstKey);
+    }
+    tokenCache.set(input, output);
+    return output;
+}
+function formatInline(text, theme) {
+    let formatted = text;
+    // LaTeX math: inline $...$ and display $$...$$
+    formatted = formatted.replace(/\$\$([^$]+)\$\$/g, (_m, tex) => chalk.hex(theme.accent)(latexToUnicode(tex.trim())));
+    formatted = formatted.replace(/\$([^$]+)\$/g, (_m, tex) => chalk.hex(theme.accent)(latexToUnicode(tex.trim())));
+    // Bold **text**
+    formatted = formatted.replace(/\*\*([^*]+)\*\*/g, (_m, t) => chalk.bold(t));
+    // Italic *text* (not bold)
+    formatted = formatted.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_m, t) => chalk.italic(t));
+    // Inline code `text`
+    formatted = formatted.replace(/`([^`]+)`/g, (_m, t) => chalk.hex(theme.accent)(t));
+    // Wiki links [[slug]] — internal refs, styled but not clickable
+    formatted = formatted.replace(/\[\[([^\]]+)\]\]/g, (_m, t) => chalk.hex(theme.link)(`[${t}]`));
+    // Markdown links [text](url) — show URL explicitly since OSC 8 is unreliable through Ink
+    formatted = formatted.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, text, url) => {
+        if (text === url) {
+            // URL-only link: just show it
+            return chalk.hex(theme.link).underline(url);
+        }
+        // Named link: show text + URL
+        return chalk.hex(theme.link).underline(text) + chalk.hex(theme.textMuted)(` (${url})`);
+    });
+    // Escaped characters
+    formatted = formatted.replace(/\\([()\\`*_{}[\]#+-.])/g, '$1');
+    return formatted;
+}
+// ── LaTeX to Unicode ────────────────────────────────────────────
+const LATEX_SYMBOLS = {
+    // Greek
+    '\\alpha': 'α', '\\beta': 'β', '\\gamma': 'γ', '\\delta': 'δ',
+    '\\epsilon': 'ε', '\\zeta': 'ζ', '\\eta': 'η', '\\theta': 'θ',
+    '\\iota': 'ι', '\\kappa': 'κ', '\\lambda': 'λ', '\\mu': 'μ',
+    '\\nu': 'ν', '\\xi': 'ξ', '\\pi': 'π', '\\rho': 'ρ',
+    '\\sigma': 'σ', '\\tau': 'τ', '\\upsilon': 'υ', '\\phi': 'φ',
+    '\\chi': 'χ', '\\psi': 'ψ', '\\omega': 'ω',
+    '\\Gamma': 'Γ', '\\Delta': 'Δ', '\\Theta': 'Θ', '\\Lambda': 'Λ',
+    '\\Xi': 'Ξ', '\\Pi': 'Π', '\\Sigma': 'Σ', '\\Phi': 'Φ',
+    '\\Psi': 'Ψ', '\\Omega': 'Ω',
+    // Operators
+    '\\times': '×', '\\div': '÷', '\\cdot': '·', '\\pm': '±',
+    '\\mp': '∓', '\\leq': '≤', '\\geq': '≥', '\\neq': '≠',
+    '\\approx': '≈', '\\equiv': '≡', '\\sim': '∼', '\\propto': '∝',
+    '\\infty': '∞', '\\partial': '∂', '\\nabla': '∇',
+    // Set theory
+    '\\in': '∈', '\\notin': '∉', '\\subset': '⊂', '\\supset': '⊃',
+    '\\subseteq': '⊆', '\\supseteq': '⊇', '\\cup': '∪', '\\cap': '∩',
+    '\\emptyset': '∅', '\\varnothing': '∅',
+    // Logic
+    '\\forall': '∀', '\\exists': '∃', '\\neg': '¬', '\\land': '∧',
+    '\\lor': '∨', '\\implies': '⟹', '\\iff': '⟺',
+    '\\therefore': '∴', '\\because': '∵',
+    // Arrows
+    '\\to': '→', '\\rightarrow': '→', '\\leftarrow': '←',
+    '\\leftrightarrow': '↔', '\\Rightarrow': '⇒', '\\Leftarrow': '⇐',
+    '\\mapsto': '↦',
+    // Big operators
+    '\\sum': '∑', '\\prod': '∏', '\\int': '∫', '\\oint': '∮',
+    '\\bigcup': '⋃', '\\bigcap': '⋂', '\\bigoplus': '⊕',
+    // Misc
+    '\\star': '⋆', '\\circ': '∘', '\\bullet': '•',
+    '\\ldots': '…', '\\cdots': '⋯', '\\vdots': '⋮', '\\ddots': '⋱',
+    '\\langle': '⟨', '\\rangle': '⟩',
+    '\\lceil': '⌈', '\\rceil': '⌉', '\\lfloor': '⌊', '\\rfloor': '⌋',
+    '\\triangle': '△', '\\square': '□', '\\diamond': '◇',
+    '\\perp': '⊥', '\\parallel': '∥', '\\angle': '∠',
+    '\\checkmark': '✓', '\\qed': '∎',
+};
+const SUPERSCRIPTS = {
+    '0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴',
+    '5': '⁵', '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹',
+    '+': '⁺', '-': '⁻', '=': '⁼', '(': '⁽', ')': '⁾',
+    'n': 'ⁿ', 'i': 'ⁱ', 'd': 'ᵈ', 'k': 'ᵏ', 'a': 'ᵃ',
+    'b': 'ᵇ', 'c': 'ᶜ', 'e': 'ᵉ', 'f': 'ᶠ', 'g': 'ᵍ',
+    'h': 'ʰ', 'j': 'ʲ', 'l': 'ˡ', 'm': 'ᵐ', 'o': 'ᵒ',
+    'p': 'ᵖ', 'r': 'ʳ', 's': 'ˢ', 't': 'ᵗ', 'u': 'ᵘ',
+    'v': 'ᵛ', 'w': 'ʷ', 'x': 'ˣ', 'y': 'ʸ', 'z': 'ᶻ',
+    'T': 'ᵀ',
+};
+const SUBSCRIPTS = {
+    '0': '₀', '1': '₁', '2': '₂', '3': '₃', '4': '₄',
+    '5': '₅', '6': '₆', '7': '₇', '8': '₈', '9': '₉',
+    '+': '₊', '-': '₋', '=': '₌', '(': '₍', ')': '₎',
+    'a': 'ₐ', 'e': 'ₑ', 'i': 'ᵢ', 'j': 'ⱼ', 'k': 'ₖ',
+    'n': 'ₙ', 'o': 'ₒ', 'p': 'ₚ', 'r': 'ᵣ', 's': 'ₛ',
+    't': 'ₜ', 'u': 'ᵤ', 'v': 'ᵥ', 'x': 'ₓ',
+};
+const MATHBB = {
+    'A': '𝔸', 'B': '𝔹', 'C': 'ℂ', 'D': '𝔻', 'E': '𝔼',
+    'F': '𝔽', 'G': '𝔾', 'H': 'ℍ', 'I': '𝕀', 'J': '𝕁',
+    'K': '𝕂', 'L': '𝕃', 'M': '𝕄', 'N': 'ℕ', 'O': '𝕆',
+    'P': 'ℙ', 'Q': 'ℚ', 'R': 'ℝ', 'S': '𝕊', 'T': '𝕋',
+    'U': '𝕌', 'V': '𝕍', 'W': '𝕎', 'X': '𝕏', 'Y': '𝕐', 'Z': 'ℤ',
+};
+const MATHCAL = {
+    'A': '𝒜', 'B': 'ℬ', 'C': '𝒞', 'D': '𝒟', 'E': 'ℰ',
+    'F': 'ℱ', 'G': '𝒢', 'H': 'ℋ', 'I': 'ℐ', 'J': '𝒥',
+    'K': '𝒦', 'L': 'ℒ', 'M': 'ℳ', 'N': '𝒩', 'O': '𝒪',
+    'P': '𝒫', 'Q': '𝒬', 'R': 'ℛ', 'S': '𝒮', 'T': '𝒯',
+    'U': '𝒰', 'V': '𝒱', 'W': '𝒲', 'X': '𝒳', 'Y': '𝒴', 'Z': '𝒵',
+};
+function latexToUnicode(tex) {
+    let result = tex;
+    // \mathbb{X} → double-struck
+    result = result.replace(/\\mathbb\{([A-Z])\}/g, (_m, c) => MATHBB[c] || c);
+    // \mathcal{X} → calligraphic
+    result = result.replace(/\\mathcal\{([A-Z])\}/g, (_m, c) => MATHCAL[c] || c);
+    // \text{...} → just the text
+    result = result.replace(/\\text\{([^}]*)\}/g, '$1');
+    result = result.replace(/\\textbf\{([^}]*)\}/g, '$1');
+    result = result.replace(/\\mathrm\{([^}]*)\}/g, '$1');
+    // Fractions \frac{a}{b} → a/b
+    result = result.replace(/\\frac\{([^}]*)\}\{([^}]*)\}/g, '($1/$2)');
+    // Square root \sqrt{x} → √x
+    result = result.replace(/\\sqrt\{([^}]*)\}/g, '√($1)');
+    result = result.replace(/\\sqrt\[(\d+)\]\{([^}]*)\}/g, '$1√($2)');
+    // Superscripts ^{...} → Unicode superscript
+    result = result.replace(/\^{([^}]*)}/g, (_m, inner) => {
+        return inner.split('').map((c) => SUPERSCRIPTS[c] || c).join('');
+    });
+    result = result.replace(/\^([a-zA-Z0-9])/g, (_m, c) => SUPERSCRIPTS[c] || `^${c}`);
+    // Subscripts _{...} → Unicode subscript
+    result = result.replace(/_{([^}]*)}/g, (_m, inner) => {
+        return inner.split('').map((c) => SUBSCRIPTS[c] || c).join('');
+    });
+    result = result.replace(/_([a-zA-Z0-9])/g, (_m, c) => SUBSCRIPTS[c] || `_${c}`);
+    // Named symbols
+    for (const [cmd, sym] of Object.entries(LATEX_SYMBOLS)) {
+        // Use word boundary to avoid partial matches
+        result = result.split(cmd).join(sym);
+    }
+    // \left and \right delimiters
+    result = result.replace(/\\left\s*/g, '');
+    result = result.replace(/\\right\s*/g, '');
+    result = result.replace(/\\big\s*/g, '');
+    result = result.replace(/\\Big\s*/g, '');
+    // Clean up remaining backslash commands we don't handle
+    result = result.replace(/\\[a-zA-Z]+/g, (match) => match.slice(1));
+    // Clean up extra braces
+    result = result.replace(/\{([^{}]*)\}/g, '$1');
+    result = result.replace(/\{([^{}]*)\}/g, '$1'); // Second pass for nested
+    // Clean whitespace
+    result = result.replace(/\s+/g, ' ').trim();
+    return result;
+}
+function renderTable(rows, theme) {
+    if (rows.length === 0)
+        return [];
+    // Calculate column widths
+    const colCount = Math.max(...rows.map(r => r.length));
+    const colWidths = [];
+    for (let c = 0; c < colCount; c++) {
+        colWidths.push(Math.max(...rows.map(r => (r[c] || '').length), 3));
+    }
+    const result = [];
+    const separator = chalk.dim('  ' + colWidths.map(w => '─'.repeat(w + 2)).join('┼'));
+    for (let r = 0; r < rows.length; r++) {
+        const cells = rows[r];
+        const line = cells.map((cell, c) => {
+            const padded = (cell || '').padEnd(colWidths[c] || 3);
+            return r === 0 ? chalk.bold(padded) : padded;
+        }).join(chalk.dim(' │ '));
+        result.push('  ' + line);
+        if (r === 0)
+            result.push(separator);
+    }
+    return result;
+}
+/**
+ * Ink component for rendering markdown.
+ */
+export const MarkdownText = React.memo(({ children }) => {
+    const rendered = renderMarkdown(children);
+    return _jsx(Text, { children: rendered });
+});

package/dist/cli/components/Message.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export type MessageRole = 'user' | 'assistant' | 'system';
+export interface MessageData {
+    id: string;
+    role: MessageRole;
+    content: string;
+    sources?: string[];
+    timestamp: number;
+}
+interface MessageProps {
+    message: MessageData;
+}
+export declare const Message: React.FC<MessageProps>;
+export {};

package/dist/cli/components/Message.js

@@ -0,0 +1,17 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { Text, Box } from 'ink';
+import { getTheme } from '../theme.js';
+import { renderMarkdown } from './Markdown.js';
+export const Message = React.memo(({ message }) => {
+    const theme = getTheme();
+    if (message.role === 'user') {
+        return (_jsx(Box, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: _jsxs(Text, { bold: true, color: theme.userMessage, children: ['› ', message.content] }) }));
+    }
+    if (message.role === 'system') {
+        return (_jsx(Box, { marginBottom: 1, paddingLeft: 2, children: _jsx(Text, { color: theme.systemMessage, children: message.content }) }));
+    }
+    // Assistant message — render with markdown
+    const rendered = renderMarkdown(message.content);
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 2, children: [_jsx(Text, { children: rendered }), message.sources && message.sources.length > 0 && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.textMuted, children: ["sources: ", message.sources.join(', ')] }) }))] }));
+});

package/dist/cli/components/Spinner.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface SpinnerProps {
+    label?: string;
+    elapsed?: number;
+}
+export declare const BrowzySpinner: React.FC<SpinnerProps>;
+export {};

package/dist/cli/components/Spinner.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Text } from 'ink';
+import { getTheme } from '../theme.js';
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export const BrowzySpinner = ({ label, elapsed }) => {
+    const [frame, setFrame] = useState(0);
+    const theme = getTheme();
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setFrame(f => (f + 1) % FRAMES.length);
+        }, 80);
+        return () => clearInterval(timer);
+    }, []);
+    const elapsedStr = elapsed !== undefined && elapsed > 2
+        ? ` ${elapsed.toFixed(1)}s`
+        : '';
+    return (_jsxs(Text, { children: [_jsx(Text, { color: theme.accent, children: FRAMES[frame] }), label && _jsxs(Text, { color: theme.textDim, children: [" ", label] }), elapsedStr && _jsx(Text, { color: theme.textMuted, children: elapsedStr })] }));
+};

package/dist/cli/components/StatusBar.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+interface StatusBarProps {
+    model: string;
+    sources: number;
+    articles: number;
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+    hint?: string;
+    temporaryStatus?: string;
+}
+export declare const StatusBar: React.FC<StatusBarProps>;
+export {};

package/dist/cli/components/StatusBar.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Text, Box, useStdout } from 'ink';
+import { getTheme } from '../theme.js';
+export const StatusBar = ({ model, sources, articles, tokenUsage, hint, temporaryStatus, }) => {
+    const theme = getTheme();
+    const { stdout } = useStdout();
+    const cols = stdout.columns || 80;
+    const [showTemp, setShowTemp] = useState(false);
+    useEffect(() => {
+        if (temporaryStatus) {
+            setShowTemp(true);
+            const timer = setTimeout(() => setShowTemp(false), 4000);
+            return () => clearTimeout(timer);
+        }
+    }, [temporaryStatus]);
+    const left = `${sources} sources · ${articles} articles${articles > 0 ? ' · growing' : ''}`;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: _jsx(Text, { color: theme.separator, children: '─'.repeat(cols) }) }), _jsxs(Box, { justifyContent: "space-between", children: [_jsx(Box, { children: showTemp && temporaryStatus ? (_jsxs(Text, { color: theme.accent, children: [" ", temporaryStatus] })) : (_jsxs(Text, { color: theme.textMuted, children: [" ", left] })) }), _jsx(Box, { children: _jsxs(Text, { color: theme.textMuted, children: [model, " "] }) })] }), hint && (_jsx(Box, { children: _jsxs(Text, { color: theme.textMuted, children: [" ", hint] }) }))] }));
+};

package/dist/cli/components/Suggestions.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export interface Suggestion {
+    name: string;
+    description: string;
+    usage?: string;
+}
+interface SuggestionsProps {
+    items: Suggestion[];
+    selectedIndex: number;
+    visible: boolean;
+}
+export declare const SuggestionList: React.FC<SuggestionsProps>;
+export {};

package/dist/cli/components/Suggestions.js

@@ -0,0 +1,14 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Text, Box } from 'ink';
+import { getTheme } from '../theme.js';
+const MAX_VISIBLE = 5;
+export const SuggestionList = ({ items, selectedIndex, visible }) => {
+    const theme = getTheme();
+    if (!visible || items.length === 0)
+        return null;
+    const visibleItems = items.slice(0, MAX_VISIBLE);
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 0, children: [visibleItems.map((item, i) => {
+                const isSelected = i === selectedIndex;
+                return (_jsxs(Box, { children: [_jsxs(Text, { color: isSelected ? theme.accent : theme.textDim, bold: isSelected, children: [isSelected ? '› ' : '  ', (item.usage || item.name).padEnd(28)] }), _jsx(Text, { color: theme.textMuted, children: item.description })] }, item.name));
+            }), items.length > MAX_VISIBLE && (_jsxs(Text, { color: theme.textMuted, children: ["  ... ", items.length - MAX_VISIBLE, " more"] }))] }));
+};

package/dist/cli/entry.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import 'dotenv/config';

package/dist/cli/entry.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import React from 'react';
+import { render } from 'ink';
+import { Command } from 'commander';
+import { BrowzyApp, BrowzyErrorBoundary } from './app.js';
+import { needsOnboarding, runOnboarding } from './onboarding.js';
+import { initCommand } from './commands/init.js';
+import { ingestCommand } from './commands/ingest.js';
+import { compileCommand } from './commands/compile.js';
+import { queryCommand } from './commands/query.js';
+import { lintCommand } from './commands/lint.js';
+import { statusCommand } from './commands/status.js';
+import { searchCommand } from './commands/search.js';
+// Prevent corepack issues
+process.env.COREPACK_ENABLE_AUTO_PIN = '0';
+// Signal handlers for graceful shutdown
+process.on('SIGTERM', () => process.exit(143));
+process.on('SIGHUP', () => process.exit(129));
+process.on('unhandledRejection', (reason) => {
+    console.error('Unhandled rejection:', reason instanceof Error ? reason.message : reason);
+    process.exit(1);
+});
+async function main() {
+    if (process.argv.length <= 2) {
+        if (needsOnboarding()) {
+            const success = await runOnboarding();
+            if (!success)
+                process.exit(0);
+        }
+        try {
+            const { waitUntilExit } = render(React.createElement(BrowzyErrorBoundary, null, React.createElement(BrowzyApp)), { exitOnCtrlC: false });
+            await waitUntilExit();
+        }
+        catch (err) {
+            // Ensure terminal is restored even on crash
+            process.stdout.write('\x1B[?25h'); // Show cursor
+            console.error('browzy error:', err);
+            process.exit(1);
+        }
+        return;
+    }
+    const program = new Command();
+    program
+        .name('browzy')
+        .description('LLM-powered personal knowledge base engine')
+        .version('1.0.0');
+    program.addCommand(initCommand);
+    program.addCommand(ingestCommand);
+    program.addCommand(compileCommand);
+    program.addCommand(queryCommand);
+    program.addCommand(lintCommand);
+    program.addCommand(statusCommand);
+    program.addCommand(searchCommand);
+    program.parse();
+}
+main().catch(err => {
+    process.stdout.write('\x1B[?25h'); // Show cursor
+    console.error(err);
+    process.exit(1);
+});

package/dist/cli/helpers.d.ts

@@ -0,0 +1,14 @@
+import type { BrowzyConfig } from '../core/types.js';
+import type { LLMProvider } from '../core/llm/provider.js';
+export declare function getConfig(): BrowzyConfig;
+export declare function getConfigAndLLM(): {
+    config: BrowzyConfig;
+    llm: LLMProvider;
+};
+export declare function ensureDirs(config: BrowzyConfig): void;
+export declare function spinner(text: string): import("ora").Ora;
+export declare function success(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function error(msg: string): void;
+export declare function info(msg: string): void;
+export declare function table(data: Record<string, unknown>[]): void;

package/dist/cli/helpers.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, ensureDataDirs, createProvider } from '../core/index.js';
+export function getConfig() {
+    return loadConfig();
+}
+export function getConfigAndLLM() {
+    const config = loadConfig();
+    const llm = createProvider(config.llm);
+    return { config, llm };
+}
+export function ensureDirs(config) {
+    ensureDataDirs(config);
+}
+export function spinner(text) {
+    return ora({ text, color: 'cyan' });
+}
+export function success(msg) {
+    console.log(chalk.green('✓'), msg);
+}
+export function warn(msg) {
+    console.log(chalk.yellow('⚠'), msg);
+}
+export function error(msg) {
+    console.log(chalk.red('✗'), msg);
+}
+export function info(msg) {
+    console.log(chalk.blue('ℹ'), msg);
+}
+export function table(data) {
+    console.table(data);
+}

package/dist/cli/hooks/useAutocomplete.d.ts

@@ -0,0 +1,11 @@
+import type { Suggestion } from '../components/Suggestions.js';
+export declare function useAutocomplete(): {
+    getMatches: (input: string) => Suggestion[];
+    selectedIndex: number;
+    visible: boolean;
+    updateForInput: (input: string) => void;
+    moveSelection: (direction: "up" | "down", input: string) => void;
+    acceptSuggestion: (input: string) => string | null;
+    getGhostText: (input: string) => string;
+    setVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};

package/dist/cli/hooks/useAutocomplete.js

@@ -0,0 +1,71 @@
+import { useState, useCallback } from 'react';
+const COMMANDS = [
+    { name: '/add', description: 'Feed your browzy new knowledge', usage: '/add <urls or paths...>' },
+    { name: '/health', description: 'How is your browzy doing?' },
+    { name: '/model', description: 'Switch models', usage: '/model [model-id]' },
+    { name: '/rebuild', description: 'Recompile from scratch' },
+    { name: '/export', description: 'Save this session as markdown' },
+    { name: '/help', description: 'All commands' },
+    { name: '/quit', description: 'Exit' },
+];
+export function useAutocomplete() {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [visible, setVisible] = useState(false);
+    const getMatches = useCallback((input) => {
+        if (!input.startsWith('/'))
+            return [];
+        const query = input.toLowerCase();
+        return COMMANDS.filter(c => c.name.startsWith(query));
+    }, []);
+    const updateForInput = useCallback((input) => {
+        if (input.startsWith('/') && !input.includes(' ')) {
+            const matches = getMatches(input);
+            setVisible(matches.length > 0 && input !== matches[0]?.name);
+            setSelectedIndex(0);
+        }
+        else {
+            setVisible(false);
+        }
+    }, [getMatches]);
+    const moveSelection = useCallback((direction, input) => {
+        const matches = getMatches(input);
+        if (matches.length === 0)
+            return;
+        setSelectedIndex(prev => {
+            if (direction === 'up')
+                return Math.max(0, prev - 1);
+            return Math.min(matches.length - 1, prev + 1);
+        });
+    }, [getMatches]);
+    const acceptSuggestion = useCallback((input) => {
+        const matches = getMatches(input);
+        if (matches.length === 0 || !visible)
+            return null;
+        const selected = matches[selectedIndex];
+        if (!selected)
+            return null;
+        setVisible(false);
+        return selected.name + ' ';
+    }, [getMatches, selectedIndex, visible]);
+    const getGhostText = useCallback((input) => {
+        if (!visible)
+            return '';
+        const matches = getMatches(input);
+        if (matches.length === 0)
+            return '';
+        const match = matches[selectedIndex] || matches[0];
+        if (!match || !match.name.startsWith(input))
+            return '';
+        return match.name.slice(input.length);
+    }, [getMatches, selectedIndex, visible]);
+    return {
+        getMatches,
+        selectedIndex,
+        visible,
+        updateForInput,
+        moveSelection,
+        acceptSuggestion,
+        getGhostText,
+        setVisible,
+    };
+}