toolpack-cli 0.1.0-SNAPSHOT

package/dist/commands/registry.js

@@ -0,0 +1,86 @@
+/**
+ * Command Registry
+ * Manages command registration and lookup
+ */
+const commands = new Map();
+/**
+ * Register a command
+ */
+export function registerCommand(command) {
+    commands.set(command.name, command);
+    if (command.aliases) {
+        for (const alias of command.aliases) {
+            commands.set(alias, command);
+        }
+    }
+}
+/**
+ * Get a command by name
+ */
+export function getCommand(name) {
+    return commands.get(name.toLowerCase());
+}
+/**
+ * Get all unique commands (excluding aliases)
+ */
+export function getAllCommands() {
+    const seen = new Set();
+    const result = [];
+    for (const cmd of commands.values()) {
+        if (!seen.has(cmd.name)) {
+            seen.add(cmd.name);
+            result.push(cmd);
+        }
+    }
+    return result.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Check if input is a command
+ */
+export function isCommand(input) {
+    return input.trim().startsWith('/');
+}
+/**
+ * Parse command input into name and arguments
+ */
+export function parseCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/')) {
+        return { name: '', args: [] };
+    }
+    const parts = trimmed.slice(1).split(/\s+/);
+    const name = parts[0]?.toLowerCase() || '';
+    const args = parts.slice(1);
+    return { name, args };
+}
+/**
+ * Execute a command
+ */
+export async function executeCommand(input, context) {
+    const { name, args } = parseCommand(input);
+    if (!name) {
+        return {
+            success: false,
+            message: 'Invalid command. Type /help for available commands.',
+            action: 'display',
+        };
+    }
+    const command = getCommand(name);
+    if (!command) {
+        return {
+            success: false,
+            message: `Unknown command: /${name}. Type /help for available commands.`,
+            action: 'display',
+        };
+    }
+    try {
+        return await command.execute(args, context);
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Command error: ${error.message || 'Unknown error'}`,
+            action: 'display',
+        };
+    }
+}

package/dist/commands/tool-log.d.ts

@@ -0,0 +1,3 @@
+import { Command } from './types.js';
+declare const toolLogCommand: Command;
+export default toolLogCommand;

package/dist/commands/tool-log.js

@@ -0,0 +1,17 @@
+import { registerCommand } from './registry.js';
+const toolLogCommand = {
+    name: 'tool_log',
+    aliases: ['tl', 'log'],
+    description: 'Show tool execution log for current session',
+    usage: '/tool_log',
+    execute: async () => {
+        // Tool history is now managed via SDK events in ToolpackContext.
+        // ChatScreen will display the popup using toolHistory from context.
+        return {
+            success: true,
+            action: 'popup',
+        };
+    },
+};
+registerCommand(toolLogCommand);
+export default toolLogCommand;

package/dist/commands/tool-search.d.ts

@@ -0,0 +1,3 @@
+import { Command } from './types.js';
+declare const toolSearchCommand: Command;
+export default toolSearchCommand;

package/dist/commands/tool-search.js

@@ -0,0 +1,57 @@
+import { registerCommand } from './registry.js';
+const toolSearchCommand = {
+    name: 'tool_search',
+    aliases: ['ts', 'search'],
+    description: 'Search for tools by query',
+    usage: '/tool_search <query>',
+    execute: (args, context) => {
+        if (args.length === 0) {
+            return {
+                success: false,
+                message: 'Usage: /tool_search <query>',
+                action: 'display',
+            };
+        }
+        if (!context.toolpack) {
+            return {
+                success: false,
+                message: 'Toolpack not initialized',
+                action: 'display',
+            };
+        }
+        const query = args.join(' ');
+        const registry = context.toolpack.getToolRegistry?.();
+        if (!registry) {
+            return {
+                success: false,
+                message: 'Tool registry not available',
+                action: 'display',
+            };
+        }
+        // Simple search through tool names and descriptions
+        const tools = registry.getAll();
+        const queryLower = query.toLowerCase();
+        const matches = tools.filter((t) => t.name.toLowerCase().includes(queryLower) ||
+            t.description?.toLowerCase().includes(queryLower) ||
+            t.displayName?.toLowerCase().includes(queryLower));
+        if (matches.length === 0) {
+            return {
+                success: true,
+                message: `No tools found matching: "${query}"`,
+                action: 'display',
+            };
+        }
+        const lines = [
+            `**Tools matching "${query}":** ${matches.length} found`,
+            '',
+            ...matches.map((t) => `- **${t.name}**: ${t.description || 'No description'}`),
+        ];
+        return {
+            success: true,
+            message: lines.join('\n'),
+            action: 'display',
+        };
+    },
+};
+registerCommand(toolSearchCommand);
+export default toolSearchCommand;

package/dist/commands/tools.d.ts

@@ -0,0 +1,3 @@
+import { Command } from './types.js';
+declare const toolsCommand: Command;
+export default toolsCommand;

package/dist/commands/tools.js

@@ -0,0 +1,45 @@
+import { registerCommand } from './registry.js';
+const toolsCommand = {
+    name: 'tools',
+    aliases: ['t'],
+    description: 'List available tools',
+    execute: (_, context) => {
+        if (!context.toolpack) {
+            return {
+                success: false,
+                message: 'Toolpack not initialized',
+                action: 'display',
+            };
+        }
+        const registry = context.toolpack.getToolRegistry?.();
+        if (!registry) {
+            return {
+                success: false,
+                message: 'Tool registry not available',
+                action: 'display',
+            };
+        }
+        const tools = registry.getAll();
+        const byCategory = new Map();
+        for (const tool of tools) {
+            const cat = tool.category || 'uncategorized';
+            if (!byCategory.has(cat)) {
+                byCategory.set(cat, []);
+            }
+            byCategory.get(cat).push(tool.name);
+        }
+        const lines = [`**Available Tools:** ${tools.length} total`, ''];
+        for (const [category, toolNames] of byCategory) {
+            lines.push(`**${category}** (${toolNames.length}):`);
+            lines.push(toolNames.map(n => `  - ${n}`).join('\n'));
+            lines.push('');
+        }
+        return {
+            success: true,
+            message: lines.join('\n'),
+            action: 'display',
+        };
+    },
+};
+registerCommand(toolsCommand);
+export default toolsCommand;

package/dist/commands/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Command types and interfaces
+ */
+export interface CommandContext {
+    toolpack: any;
+    activeMode: any;
+    activeModel: string;
+    activeConversation: any;
+    addMessage: (role: 'user' | 'assistant' | 'system', content: string) => void;
+    clearHistory: () => void;
+    setScreen: (screen: 'home' | 'chat') => void;
+}
+export interface CommandResult {
+    success: boolean;
+    message?: string;
+    action?: 'display' | 'navigate' | 'silent' | 'popup';
+    popupData?: any;
+}
+export interface Command {
+    name: string;
+    aliases?: string[];
+    description: string;
+    usage?: string;
+    execute: (args: string[], context: CommandContext) => Promise<CommandResult> | CommandResult;
+}

package/dist/commands/types.js

@@ -0,0 +1,4 @@
+/**
+ * Command types and interfaces
+ */
+export {};

package/dist/commands/version.d.ts

@@ -0,0 +1,3 @@
+import { Command } from './types.js';
+declare const versionCommand: Command;
+export default versionCommand;

package/dist/commands/version.js

@@ -0,0 +1,25 @@
+import { registerCommand } from './registry.js';
+const versionCommand = {
+    name: 'version',
+    aliases: ['v'],
+    description: 'Show version information',
+    execute: async () => {
+        const { readFileSync } = await import('fs');
+        const { join } = await import('path');
+        let version = 'unknown';
+        try {
+            const pkg = JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf-8'));
+            version = pkg.version || 'unknown';
+        }
+        catch {
+            // Ignore
+        }
+        return {
+            success: true,
+            message: `**Toolpack SDK CLI** v${version}`,
+            action: 'display',
+        };
+    },
+};
+registerCommand(versionCommand);
+export default versionCommand;

package/dist/components/AppInfo.d.ts

@@ -0,0 +1 @@
+export declare function AppInfo(): import("react/jsx-runtime").JSX.Element;

package/dist/components/AppInfo.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useTheme } from '../theme/ThemeContext.js';
+export function AppInfo() {
+    const { theme } = useTheme();
+    // Hardcoded for now, mimicking original behavior
+    const currentPath = process.cwd();
+    const version = 'v1.0.0';
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", marginBottom: 2, children: [_jsx(Text, { color: theme.colors.textSecondary, children: currentPath }), _jsx(Text, { color: theme.colors.textSecondary, children: version })] }));
+}

package/dist/components/HomeInput.d.ts

@@ -0,0 +1,11 @@
+interface HomeInputProps {
+    focusedIndex: number;
+    showModeSelect: boolean;
+    setShowModeSelect: (val: boolean) => void;
+    showModelSelect: boolean;
+    setShowModelSelect: (val: boolean) => void;
+    showHistorySelect: boolean;
+    setShowHistorySelect: (val: boolean) => void;
+}
+export declare function HomeInput({ focusedIndex, showModeSelect, setShowModeSelect, showModelSelect, setShowModelSelect, showHistorySelect, setShowHistorySelect, }: HomeInputProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/HomeInput.js

@@ -0,0 +1,328 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useState, useEffect, useRef } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { useTheme } from '../theme/ThemeContext.js';
+import { useConversation } from '../context/ConversationContext.js';
+import { useToolpack } from '../context/ToolpackContext.js';
+import { ProviderBar } from './ProviderBar.js';
+import clipboardy from 'clipboardy';
+// Bracketed paste mode sequences
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+/**
+ * Wraps text to fit within a given width, preserving existing newlines.
+ */
+function wrapText(text, maxWidth) {
+    if (maxWidth <= 0)
+        return text.split('\n');
+    const result = [];
+    const paragraphs = text.split('\n');
+    for (const paragraph of paragraphs) {
+        if (paragraph.length <= maxWidth) {
+            result.push(paragraph);
+        }
+        else {
+            // Word-wrap long lines
+            let remaining = paragraph;
+            while (remaining.length > maxWidth) {
+                // Try to break at a space
+                let breakPoint = remaining.lastIndexOf(' ', maxWidth);
+                if (breakPoint <= 0) {
+                    // No space found, hard break
+                    breakPoint = maxWidth;
+                }
+                result.push(remaining.slice(0, breakPoint));
+                remaining = remaining.slice(breakPoint).trimStart();
+            }
+            if (remaining) {
+                result.push(remaining);
+            }
+        }
+    }
+    return result;
+}
+function sanitizeText(input) {
+    // Remove ANSI escape sequences
+    let sanitized = input.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+    // Remove any remaining escape characters
+    sanitized = sanitized.replace(/\x1b/g, '');
+    // Normalize line endings
+    sanitized = sanitized.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    // Convert tabs to spaces
+    sanitized = sanitized.replace(/\t/g, '    ');
+    return sanitized;
+}
+export function HomeInput({ focusedIndex, showModeSelect, setShowModeSelect, showModelSelect, setShowModelSelect, showHistorySelect, setShowHistorySelect, }) {
+    const { theme } = useTheme();
+    const { stdout } = useStdout();
+    const [query, setQuery] = useState('');
+    const [cursorPos, setCursorPos] = useState(0);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    // Ref to track current cursor position for use in closures
+    const cursorPosRef = useRef(0);
+    cursorPosRef.current = cursorPos;
+    // Ref to track current query for use in closures
+    const queryRef = useRef('');
+    queryRef.current = query;
+    // Refs for bracketed paste handling
+    const isPastingRef = useRef(false);
+    const pasteBufferRef = useRef('');
+    // Hardcode the max visible lines the input block is allowed to consume
+    const MAX_VISIBLE_LINES = 4;
+    // Calculate available width for text wrapping
+    // The input box is 80% of terminal width, minus border (2) and padding (2)
+    const boxWidth = Math.floor((stdout.columns || 80) * 0.8);
+    const textWidth = Math.max(10, boxWidth - 6); // 2 for border + 2 for paddingX on each side
+    // Wrap text to fit within the available width
+    const wrappedLines = wrapText(query, textWidth);
+    // focusedIndex = 0 means the text input has focus
+    const isInputFocused = focusedIndex === 0 && !showModeSelect && !showModelSelect;
+    const { createConversation } = useConversation();
+    const { activeMode, activeModel } = useToolpack();
+    // Auto-scroll to the bottom when the user adds new lines
+    useEffect(() => {
+        if (wrappedLines.length > MAX_VISIBLE_LINES) {
+            setScrollOffset(wrappedLines.length - MAX_VISIBLE_LINES);
+        }
+        else {
+            setScrollOffset(0);
+        }
+    }, [wrappedLines.length]);
+    // Ref to track if we handled an escape sequence (to prevent useInput from processing it)
+    const handledEscapeRef = useRef(false);
+    // Handle raw stdin for bracketed paste mode, mouse wheel, and Option+arrow keys
+    useEffect(() => {
+        if (!isInputFocused)
+            return;
+        const handleData = (data) => {
+            const str = data.toString();
+            // Option+Left (Esc+b) - move word backward
+            if (str === '\x1bb' || str === '\x1bB') {
+                handledEscapeRef.current = true;
+                const q = queryRef.current;
+                let pos = cursorPosRef.current - 1;
+                // Skip whitespace
+                while (pos > 0 && /\s/.test(q.charAt(pos)))
+                    pos--;
+                // Find start of word
+                while (pos > 0 && !/\s/.test(q.charAt(pos - 1)))
+                    pos--;
+                setCursorPos(Math.max(0, pos));
+                setTimeout(() => { handledEscapeRef.current = false; }, 10);
+                return;
+            }
+            // Option+Right (Esc+f) - move word forward
+            if (str === '\x1bf' || str === '\x1bF') {
+                handledEscapeRef.current = true;
+                const q = queryRef.current;
+                let pos = cursorPosRef.current;
+                // Skip current word
+                while (pos < q.length && !/\s/.test(q.charAt(pos)))
+                    pos++;
+                // Skip whitespace
+                while (pos < q.length && /\s/.test(q.charAt(pos)))
+                    pos++;
+                setCursorPos(pos);
+                setTimeout(() => { handledEscapeRef.current = false; }, 10);
+                return;
+            }
+            // Check for bracketed paste start
+            if (str.includes(PASTE_START)) {
+                isPastingRef.current = true;
+                // Extract content after paste start marker
+                const startIdx = str.indexOf(PASTE_START) + PASTE_START.length;
+                let content = str.slice(startIdx);
+                // Check if paste end is in the same chunk
+                if (content.includes(PASTE_END)) {
+                    const endIdx = content.indexOf(PASTE_END);
+                    content = content.slice(0, endIdx);
+                    isPastingRef.current = false;
+                    const sanitized = sanitizeText(content);
+                    const pos = cursorPosRef.current;
+                    setQuery(prev => prev.slice(0, pos) + sanitized + prev.slice(pos));
+                    setCursorPos(pos + sanitized.length);
+                }
+                else {
+                    pasteBufferRef.current = content;
+                }
+                return;
+            }
+            // If we're in paste mode, accumulate content
+            if (isPastingRef.current) {
+                if (str.includes(PASTE_END)) {
+                    const endIdx = str.indexOf(PASTE_END);
+                    pasteBufferRef.current += str.slice(0, endIdx);
+                    isPastingRef.current = false;
+                    const sanitized = sanitizeText(pasteBufferRef.current);
+                    const pos = cursorPosRef.current;
+                    setQuery(prev => prev.slice(0, pos) + sanitized + prev.slice(pos));
+                    setCursorPos(pos + sanitized.length);
+                    pasteBufferRef.current = '';
+                }
+                else {
+                    pasteBufferRef.current += str;
+                }
+                return;
+            }
+            // Handle mouse wheel events
+            const match = str.match(/\x1b\[<(64|65);\d+;\d+M/);
+            if (match && match[1]) {
+                const button = parseInt(match[1], 10);
+                if (button === 64) {
+                    setScrollOffset(prev => Math.max(0, prev - 1));
+                }
+                else if (button === 65) {
+                    const maxOffset = Math.max(0, wrappedLines.length - MAX_VISIBLE_LINES);
+                    setScrollOffset(prev => Math.min(maxOffset, prev + 1));
+                }
+            }
+        };
+        process.stdin.on('data', handleData);
+        return () => {
+            process.stdin.off('data', handleData);
+        };
+    }, [isInputFocused, wrappedLines.length, MAX_VISIBLE_LINES]);
+    // Handle keyboard input (non-paste)
+    useInput((input, key) => {
+        if (!isInputFocused)
+            return;
+        // Skip if we're in paste mode (handled by raw stdin)
+        if (isPastingRef.current)
+            return;
+        if (key.ctrl && input === 'l') {
+            setQuery('');
+            setCursorPos(0);
+            setScrollOffset(0);
+            return;
+        }
+        if (key.ctrl && input === 'k') {
+            try {
+                clipboardy.writeSync(query);
+            }
+            catch (err) { }
+            return;
+        }
+        // Ctrl+A to go to beginning of line
+        if (key.ctrl && input === 'a') {
+            setCursorPos(0);
+            return;
+        }
+        // Ctrl+E to go to end of line
+        if (key.ctrl && input === 'e') {
+            setCursorPos(queryRef.current.length);
+            return;
+        }
+        // Alt/Option + Left (sends Esc+b in terminal) - move word backward
+        if (input === 'b' && key.escape) {
+            const q = queryRef.current;
+            let pos = cursorPosRef.current - 1;
+            // Skip whitespace
+            while (pos > 0 && /\s/.test(q.charAt(pos)))
+                pos--;
+            // Find start of word
+            while (pos > 0 && !/\s/.test(q.charAt(pos - 1)))
+                pos--;
+            setCursorPos(Math.max(0, pos));
+            return;
+        }
+        // Alt/Option + Right (sends Esc+f in terminal) - move word forward
+        if (input === 'f' && key.escape) {
+            const q = queryRef.current;
+            let pos = cursorPosRef.current;
+            // Skip current word
+            while (pos < q.length && !/\s/.test(q.charAt(pos)))
+                pos++;
+            // Skip whitespace
+            while (pos < q.length && /\s/.test(q.charAt(pos)))
+                pos++;
+            setCursorPos(pos);
+            return;
+        }
+        // Left/Right arrow keys for cursor movement
+        if (key.leftArrow) {
+            setCursorPos(prev => Math.max(0, prev - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursorPos(prev => Math.min(queryRef.current.length, prev + 1));
+            return;
+        }
+        // Up/Down arrow keys for scrolling
+        if (key.upArrow) {
+            setScrollOffset(prev => Math.max(0, prev - 1));
+            return;
+        }
+        if (key.downArrow) {
+            const maxOffset = Math.max(0, wrappedLines.length - MAX_VISIBLE_LINES);
+            setScrollOffset(prev => Math.min(maxOffset, prev + 1));
+            return;
+        }
+        if (key.return) {
+            if (key.shift) {
+                setQuery(prev => prev.slice(0, cursorPos) + '\n' + prev.slice(cursorPos));
+                setCursorPos(prev => prev + 1);
+                return;
+            }
+            if (query.endsWith('\\')) {
+                setQuery(prev => prev.slice(0, -1) + '\n');
+                setCursorPos(query.length);
+                return;
+            }
+            if (query.trim()) {
+                createConversation(query.trim(), activeMode?.name, activeModel);
+                setQuery('');
+                setCursorPos(0);
+                setScrollOffset(0);
+            }
+            return;
+        }
+        const handleBackspace = () => {
+            setCursorPos(prev => {
+                if (prev > 0) {
+                    setQuery(q => q.slice(0, prev - 1) + q.slice(prev));
+                    return prev - 1;
+                }
+                return prev;
+            });
+        };
+        const handleForwardDelete = () => {
+            const pos = cursorPosRef.current;
+            const len = queryRef.current.length;
+            if (pos < len) {
+                setQuery(prev => prev.slice(0, pos) + prev.slice(pos + 1));
+            }
+        };
+        const hasModifier = key.ctrl || key.meta || key.shift;
+        if (key.backspace || (key.delete && !hasModifier)) {
+            handleBackspace();
+            return;
+        }
+        if (key.delete && hasModifier) {
+            handleForwardDelete();
+            return;
+        }
+        if (input) {
+            // Skip if this was part of an escape sequence we already handled
+            if (handledEscapeRef.current) {
+                return;
+            }
+            // Skip 'b' and 'f' if escape key is also pressed (Option+arrow on macOS)
+            if (key.escape && (input === 'b' || input === 'f')) {
+                return;
+            }
+            const sanitized = sanitizeText(input);
+            if (sanitized) {
+                const pos = cursorPosRef.current;
+                setQuery(prev => prev.slice(0, pos) + sanitized + prev.slice(pos));
+                setCursorPos(pos + sanitized.length);
+            }
+        }
+    }, { isActive: true });
+    // The border should be active (primary) if ANYTHING in this box is focused
+    const isActive = focusedIndex !== -1;
+    const borderColor = isActive ? theme.colors.border : theme.colors.secondary;
+    return (_jsxs(Box, { width: "100%", flexDirection: "column", children: [_jsxs(Box, { width: "100%", borderStyle: "single", borderColor: borderColor, flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Box, { height: MAX_VISIBLE_LINES, overflowY: "hidden", width: "100%", flexDirection: "column", children: _jsx(Box, { marginTop: -scrollOffset, flexDirection: "column", width: "100%", children: query ? (_jsxs(Text, { color: theme.colors.text, children: [query.slice(0, cursorPos), isInputFocused && _jsx(Text, { color: theme.colors.primary, children: "\u258E" }), query.slice(cursorPos)] })) : (_jsxs(Text, { color: theme.colors.textMuted, children: [isInputFocused && _jsx(Text, { color: theme.colors.primary, children: "\u258E" }), "Type a message or ask a question..."] })) }) }), _jsx(Box, { width: "100%", flexDirection: "column", marginTop: 1, children: _jsx(Box, { width: "100%", children: _jsx(ProviderBar, { isFocused: isActive, focusedIndex: focusedIndex, showModeSelect: showModeSelect, setShowModeSelect: setShowModeSelect, showModelSelect: showModelSelect, setShowModelSelect: setShowModelSelect, showHistorySelect: showHistorySelect, setShowHistorySelect: setShowHistorySelect }) }) })] }), _jsx(Hints, { theme: theme })] }));
+}
+const Hints = React.memo(({ theme }) => {
+    return (_jsxs(Box, { width: "100%", justifyContent: "flex-end", paddingRight: 1, marginTop: 1, gap: 2, children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.colors.textSecondary, bold: true, children: "^L" }), _jsx(Text, { color: theme.colors.textMuted, children: ":Clear" })] }), _jsxs(Text, { children: [_jsx(Text, { color: theme.colors.textSecondary, bold: true, children: "^K" }), _jsx(Text, { color: theme.colors.textMuted, children: ":Copy" })] }), _jsxs(Text, { children: [_jsx(Text, { color: theme.colors.textSecondary, bold: true, children: "\u2191/\u2193" }), _jsx(Text, { color: theme.colors.textMuted, children: ":Scroll" })] }), _jsxs(Text, { children: [_jsx(Text, { color: theme.colors.textSecondary, bold: true, children: "Tab" }), _jsx(Text, { color: theme.colors.textMuted, children: ":Select" })] }), _jsxs(Text, { children: [_jsx(Text, { color: theme.colors.textSecondary, bold: true, children: "\\+Ent" }), _jsx(Text, { color: theme.colors.textMuted, children: ":Line" })] }), _jsxs(Text, { children: [_jsx(Text, { color: theme.colors.textSecondary, bold: true, children: "Ent" }), _jsx(Text, { color: theme.colors.textMuted, children: ":Send" })] })] }));
+});

package/dist/components/Logo.d.ts

@@ -0,0 +1 @@
+export declare function Logo(): import("react/jsx-runtime").JSX.Element;

package/dist/components/Logo.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useTheme } from '../theme/ThemeContext.js';
+export function Logo() {
+    const { theme } = useTheme();
+    const asciiArt = `
+████████╗ ██████╗  ██████╗ ██╗     ██████╗  █████╗  ██████╗██╗  ██╗    ███████╗██████╗ ██╗  ██╗
+╚══██╔══╝██╔═══██╗██╔═══██╗██║     ██╔══██╗██╔══██╗██╔════╝██║ ██╔╝    ██╔════╝██╔══██╗██║ ██╔╝
+   ██║   ██║   ██║██║   ██║██║     ██████╔╝███████║██║     █████╔╝     ███████╗██║  ██║█████╔╝
+   ██║   ██║   ██║██║   ██║██║     ██╔═══╝ ██╔══██║██║     ██╔═██╗     ╚════██║██║  ██║██╔═██╗
+   ██║   ╚██████╔╝╚██████╔╝███████╗██║     ██║  ██║╚██████╗██║  ██╗    ███████║██████╔╝██║  ██╗
+   ╚═╝    ╚═════╝  ╚═════╝ ╚══════╝╚═╝     ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝    ╚══════╝╚═════╝ ╚═╝  ╚═╝
+  `;
+    return (_jsx(Box, { justifyContent: "center", width: "100%", children: _jsx(Text, { color: theme.colors.text, bold: true, children: asciiArt }) }));
+}

package/dist/components/Markdown.d.ts

@@ -0,0 +1,5 @@
+interface MarkdownProps {
+    children: string;
+}
+export declare function Markdown({ children }: MarkdownProps): import("react/jsx-runtime").JSX.Element;
+export {};