moth-ai 1.0.3

package/dist/ui/App.js

@@ -0,0 +1,387 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput, Newline } from 'ink';
+import * as os from 'os';
+import { loadConfig, saveConfig, addProfile } from '../config/configManager.js';
+import { TodoManager } from '../planning/todoManager.js';
+import { AgentOrchestrator } from '../agent/orchestrator.js';
+import { createToolRegistry } from '../tools/factory.js';
+import { findProjectRoot } from '../utils/paths.js';
+import { ProjectScanner } from '../context/scanner.js';
+import { CustomTextInput } from './components/CustomTextInput.js';
+import { WordMoth } from './components/WordMoth.js';
+import { FileChip } from './components/FileChip.js';
+import { FileAutocomplete } from './components/FileAutocomplete.js';
+import { CommandPalette } from './components/CommandPalette.js';
+import { ProfileManager } from './ProfileManager.js';
+import { LLMWizard } from './wizards/LLMWizard.js';
+import { LLMRemover } from './wizards/LLMRemover.js';
+export const App = ({ command, args, todoManager: propTodoManager, username }) => {
+    const [messages, setMessages] = useState([]);
+    const [inputVal, setInputVal] = useState('');
+    const [status, setStatus] = useState('Ready');
+    // UX State
+    const [showWelcome, setShowWelcome] = useState(true);
+    const [isPaused, setIsPaused] = useState(false);
+    const [autopilot, setAutopilot] = useState(false);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [thinkingText, setThinkingText] = useState('Sauting...');
+    // File Reference State
+    const [selectedFiles, setSelectedFiles] = useState([]);
+    const [showAutocomplete, setShowAutocomplete] = useState(false);
+    const [autocompleteQuery, setAutocompleteQuery] = useState('');
+    const [autocompleteIndex, setAutocompleteIndex] = useState(0);
+    const [availableFiles, setAvailableFiles] = useState([]);
+    const [showFileChips, setShowFileChips] = useState(false); // Collapsed by default
+    // Command Palette State
+    const [showCommandPalette, setShowCommandPalette] = useState(false);
+    // Active Wizard State (for command palette execution)
+    const [activeWizard, setActiveWizard] = useState(null);
+    // Effect for cycling thinking text
+    useEffect(() => {
+        if (isProcessing) {
+            const words = ['Sauting...', 'Bubbling...', 'Cooking...', 'Chopping...', 'Simmering...', 'Whisking...', 'Seasoning...'];
+            const interval = setInterval(() => {
+                setThinkingText(words[Math.floor(Math.random() * words.length)]);
+            }, 800);
+            return () => clearInterval(interval);
+        }
+    }, [isProcessing]);
+    // Load available files on mount
+    useEffect(() => {
+        const loadFiles = async () => {
+            try {
+                const root = findProjectRoot() || process.cwd();
+                const scanner = new ProjectScanner(root);
+                const files = await scanner.scan();
+                setAvailableFiles(files);
+            }
+            catch (e) {
+                console.error('Failed to load files:', e);
+            }
+        };
+        loadFiles();
+    }, []);
+    // Permission State
+    const [pendingPermission, setPendingPermission] = useState(null);
+    const [feedbackMode, setFeedbackMode] = useState(false);
+    const [permissionSelection, setPermissionSelection] = useState(0);
+    // Initialize TodoManager
+    const [todoManager] = useState(() => propTodoManager || new TodoManager());
+    // --- Run Command Logic ---
+    const client = args.client;
+    const initialPrompt = args.prompt;
+    const activeProfile = args.profile;
+    useEffect(() => {
+        if (initialPrompt && messages.length === 0) {
+            if (showWelcome)
+                setShowWelcome(false);
+            runAgent(initialPrompt);
+        }
+    }, [initialPrompt]);
+    const runAgent = async (userPrompt, attachedFiles) => {
+        if (showWelcome)
+            setShowWelcome(false);
+        setIsProcessing(true);
+        // Create new user message with attached files
+        const userMsg = {
+            role: 'user',
+            content: userPrompt,
+            attachedFiles: attachedFiles && attachedFiles.length > 0 ? attachedFiles : undefined
+        };
+        setMessages(prev => [...prev, userMsg]);
+        try {
+            const root = findProjectRoot() || process.cwd();
+            // Permission Callback
+            const checkPermission = async (toolName, args) => {
+                if (autopilot) {
+                    return { allowed: true };
+                }
+                return new Promise((resolve) => {
+                    setPendingPermission({
+                        id: Date.now().toString(),
+                        toolName,
+                        args,
+                        resolve: (response) => {
+                            setPendingPermission(null);
+                            resolve(response);
+                        }
+                    });
+                });
+            };
+            const registry = createToolRegistry(root, todoManager, checkPermission);
+            const orchestrator = new AgentOrchestrator({
+                model: client,
+                tools: registry.getDefinitions(),
+                maxSteps: 10
+            }, registry, root);
+            let finalAnswer = "";
+            // Pass accumulated history to the agent
+            // 'messages' state contains history prior to this turn.
+            // We do NOT include the pending userMsg in the 'history' arg because orchestrator.run 
+            // treats the prompt separately. Or we can include it in history and pass empty prompt?
+            // Orchestrator.run logic: [System, ...history, CurrentPrompt]
+            // So we pass 'messages' (which excludes current UserPrompt yet in this render cycle, 
+            // but wait, we called setMessages above). 
+            // Actually, setMessages update is invisible in this render closure.
+            // So 'messages' here IS the history before this turn. Perfect.
+            for await (const step of orchestrator.run(userPrompt, messages)) {
+                if (isPaused)
+                    break; // Basic pause handling (not perfect resonance)
+                if (step.thought) {
+                    // Ambient status update
+                    setStatus(step.thought);
+                }
+                if (step.toolCall) {
+                    setStatus(`Act: ${step.toolCall.name}`);
+                }
+                if (step.finalAnswer)
+                    finalAnswer = step.finalAnswer;
+            }
+            const assistantMsg = { role: 'assistant', content: finalAnswer || "Done." };
+            setMessages(prev => [...prev, assistantMsg]);
+        }
+        catch (e) {
+            setMessages(prev => [...prev, { role: 'assistant', content: `Error: ${e.message}` }]);
+        }
+        finally {
+            setStatus('Ready');
+            setIsProcessing(false);
+        }
+    };
+    // Handle input changes to detect @ for autocomplete
+    const handleInputChange = (value) => {
+        setInputVal(value);
+        // Extract and track file references from @ mentions
+        const referencedFiles = extractFileReferences(value);
+        setSelectedFiles(referencedFiles);
+        // Detect @ symbol for file autocomplete
+        const atIndex = value.lastIndexOf('@');
+        if (atIndex !== -1) {
+            const afterAt = value.slice(atIndex + 1);
+            // Close autocomplete if there's a space after @ (end of filename)
+            if (afterAt.includes(' ')) {
+                setShowAutocomplete(false);
+                return;
+            }
+            const query = afterAt;
+            // Only show autocomplete if @ is at start or after a space
+            if (atIndex === 0 || value[atIndex - 1] === ' ') {
+                setAutocompleteQuery(query);
+                setShowAutocomplete(true);
+                setAutocompleteIndex(0);
+            }
+        }
+        else {
+            setShowAutocomplete(false);
+        }
+    };
+    // Get filtered files for autocomplete
+    const getFilteredFiles = () => {
+        return availableFiles
+            .filter(file => {
+            const lowerFile = file.toLowerCase();
+            const lowerQuery = autocompleteQuery.toLowerCase();
+            return lowerFile.includes(lowerQuery);
+        })
+            .filter(file => !selectedFiles.includes(file)) // Exclude already selected
+            .slice(0, 10);
+    };
+    const handleFileSelect = (file) => {
+        // Replace the entire input value to ensure cursor ends up at the end
+        const atIndex = inputVal.lastIndexOf('@');
+        if (atIndex !== -1) {
+            const beforeAt = inputVal.slice(0, atIndex);
+            // Set the complete new value - this places cursor at the end automatically
+            const newInput = beforeAt + '@' + file + ' ';
+            setInputVal(newInput);
+        }
+        setShowAutocomplete(false);
+        setAutocompleteQuery('');
+    };
+    const handleFileRemove = (file) => {
+        setSelectedFiles(prev => prev.filter(f => f !== file));
+    };
+    // Extract file references from input text
+    const extractFileReferences = (text) => {
+        const atMatches = text.match(/@[\w\/.\-]+/g) || [];
+        return atMatches.map(match => match.slice(1)); // Remove @ prefix
+    };
+    // Execute command from command palette
+    const executeCommand = (action) => {
+        setShowCommandPalette(false);
+        switch (action) {
+            case 'autopilot':
+                setAutopilot(prev => !prev);
+                setMessages(prev => [...prev, {
+                        role: 'assistant',
+                        content: `Autopilot ${!autopilot ? 'enabled' : 'disabled'}.`
+                    }]);
+                break;
+            case 'llm-list':
+                setActiveWizard('llm-list');
+                break;
+            case 'llm-add':
+                setActiveWizard('llm-add');
+                break;
+            case 'llm-use':
+                setActiveWizard('llm-use');
+                break;
+            case 'llm-remove':
+                setActiveWizard('llm-remove');
+                break;
+            case 'help':
+                setMessages(prev => [...prev, {
+                        role: 'assistant',
+                        content: 'Moth AI - Your terminal coding assistant.\n\nKeyboard Shortcuts:\n- Ctrl+U: Open command palette\n- Ctrl+O: Toggle file references\n- Esc: Pause/Resume\n\nFor full help, run: moth --help'
+                    }]);
+                break;
+        }
+    };
+    useInput((input, key) => {
+        // Autocomplete Navigation
+        if (showAutocomplete && !pendingPermission) {
+            const filteredFiles = getFilteredFiles();
+            if (key.escape) {
+                setShowAutocomplete(false);
+                return;
+            }
+            if (key.upArrow) {
+                setAutocompleteIndex(prev => (prev - 1 + filteredFiles.length) % filteredFiles.length);
+                return;
+            }
+            if (key.downArrow) {
+                setAutocompleteIndex(prev => (prev + 1) % filteredFiles.length);
+                return;
+            }
+            // Use Enter to select file from autocomplete
+            if (key.return && filteredFiles.length > 0) {
+                handleFileSelect(filteredFiles[autocompleteIndex]);
+                return;
+            }
+        }
+        // Ctrl+O to toggle file chips visibility
+        if (input === 'o' && key.ctrl) {
+            setShowFileChips(prev => !prev);
+            return;
+        }
+        // Ctrl+U to toggle command palette
+        if (input === 'u' && key.ctrl) {
+            setShowCommandPalette(prev => !prev);
+            return;
+        }
+        // ESC Pause
+        if (key.escape && !showAutocomplete) {
+            setIsPaused(prev => !prev);
+            setStatus(prev => prev === 'Paused' ? 'Resumed' : 'Paused');
+            return;
+        }
+        // Permission Handling
+        if (pendingPermission) {
+            if (feedbackMode) {
+                if (key.return) {
+                    pendingPermission.resolve({ allowed: false, feedback: inputVal });
+                    setInputVal('');
+                    setFeedbackMode(false);
+                }
+                else if (key.backspace || key.delete) {
+                    setInputVal(prev => prev.slice(0, -1));
+                }
+                else {
+                    setInputVal(prev => prev + input);
+                }
+                return;
+            }
+            // Arrow Key Navigation
+            if (key.upArrow) {
+                setPermissionSelection(prev => (prev - 1 + 3) % 3);
+                return;
+            }
+            if (key.downArrow) {
+                setPermissionSelection(prev => (prev + 1) % 3);
+                return;
+            }
+            if (key.return) {
+                if (permissionSelection === 0) {
+                    pendingPermission.resolve({ allowed: true });
+                }
+                else if (permissionSelection === 1) {
+                    setAutopilot(true);
+                    pendingPermission.resolve({ allowed: true });
+                }
+                else if (permissionSelection === 2) {
+                    setFeedbackMode(true);
+                }
+                return;
+            }
+            if (input === 'a' || input === 'A') {
+                // Yes - execute once
+                pendingPermission.resolve({ allowed: true });
+            }
+            else if (input === 'b' || input === 'B') {
+                // Yes - autopilot
+                setAutopilot(true);
+                pendingPermission.resolve({ allowed: true });
+            }
+            else if (input === 'c' || input === 'C') {
+                // Tell Moth what to do instead
+                setFeedbackMode(true);
+            }
+            return;
+        }
+    });
+    // --- RENDER ---
+    // Render wizards if active
+    if (activeWizard === 'llm-list' || activeWizard === 'llm-use') {
+        const config = loadConfig();
+        return (_jsx(ProfileManager, { config: config, onSelect: (profile) => {
+                setActiveWizard(null);
+                setMessages(prev => [...prev, {
+                        role: 'assistant',
+                        content: `Switched to profile '${profile.name}'.`
+                    }]);
+            } }));
+    }
+    if (activeWizard === 'llm-add') {
+        return (_jsx(LLMWizard, { onComplete: (newProfile) => {
+                const config = loadConfig();
+                const updatedConfig = addProfile(config, newProfile);
+                saveConfig(updatedConfig);
+                setActiveWizard(null);
+                setMessages(prev => [...prev, {
+                        role: 'assistant',
+                        content: `Profile '${newProfile.name}' added successfully!`
+                    }]);
+            }, onCancel: () => {
+                setActiveWizard(null);
+                setMessages(prev => [...prev, {
+                        role: 'assistant',
+                        content: 'Cancelled.'
+                    }]);
+            } }));
+    }
+    if (activeWizard === 'llm-remove') {
+        const config = loadConfig();
+        return (_jsx(LLMRemover, { config: config, onExit: () => {
+                setActiveWizard(null);
+                setMessages(prev => [...prev, {
+                        role: 'assistant',
+                        content: 'Returned to chat.'
+                    }]);
+            } }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [command === 'run' && (_jsxs(Box, { flexDirection: "row", paddingX: 1, paddingY: 0, borderStyle: "round", borderColor: "#0192e5", children: [_jsxs(Box, { flexDirection: "column", marginTop: -1, paddingRight: 1, children: [_jsx(WordMoth, { text: "MOTH", big: true }), _jsx(Box, { marginTop: -1, children: _jsx(Text, { dimColor: true, children: "v1.0.0" }) }), _jsxs(Text, { color: "#3EA0C3", children: ["Welcome, ", username || os.userInfo().username] })] }), _jsxs(Box, { flexDirection: "column", alignItems: "flex-start", marginLeft: 2, children: [_jsxs(Text, { color: "green", children: ["Active_AI: ", activeProfile?.name || 'None'] }), _jsxs(Text, { dimColor: true, children: ["Path: ", process.cwd()] }), _jsx(Text, { dimColor: true, children: "Use Ctrl+U to view commands" })] })] })), messages.length > 0 && (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: messages.map((m, i) => (_jsxs(Box, { flexDirection: "row", marginBottom: 1, children: [_jsxs(Text, { color: m.role === 'user' ? 'blue' : 'green', bold: true, children: [m.role === 'user' ? 'You' : 'Moth', ":"] }), _jsxs(Text, { children: [" ", m.content] })] }, i))) })), pendingPermission && (_jsxs(Box, { borderStyle: "double", borderColor: "red", flexDirection: "column", padding: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "red", children: "PERMISSION REQUIRED" }), _jsxs(Text, { children: ["Tool: ", pendingPermission.toolName] }), _jsxs(Text, { children: ["Args: ", JSON.stringify(pendingPermission.args)] }), _jsx(Newline, {}), !feedbackMode ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsxs(Text, { color: permissionSelection === 0 ? "green" : undefined, bold: permissionSelection === 0, children: [permissionSelection === 0 ? "> " : "  ", " [a] Yes - execute this action"] }) }), _jsx(Text, { children: _jsxs(Text, { color: permissionSelection === 1 ? "green" : undefined, bold: permissionSelection === 1, children: [permissionSelection === 1 ? "> " : "  ", " [b] Yes - enable autopilot (approve all)"] }) }), _jsx(Text, { children: _jsxs(Text, { color: permissionSelection === 2 ? "green" : undefined, bold: permissionSelection === 2, children: [permissionSelection === 2 ? "> " : "  ", " [c] Tell Moth what to do instead"] }) })] })) : (_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Feedback: " }), _jsx(Text, { children: inputVal })] }))] })), !pendingPermission && (_jsxs(Box, { flexDirection: "column", children: [isProcessing && (_jsxs(Box, { flexDirection: "column", marginBottom: 0, children: [_jsx(Text, { color: "yellow", italic: true, children: thinkingText }), status !== 'Ready' && _jsxs(Text, { color: "gray", dimColor: true, children: ["  ", status] })] })), autopilot && (_jsx(Text, { color: "magenta", children: "AUTOPILOT MODE" })), selectedFiles.length > 0 && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { dimColor: true, children: ["Referenced Files (", selectedFiles.length, ") "] }), _jsxs(Text, { color: "gray", dimColor: true, children: ["[Ctrl+O to ", showFileChips ? 'hide' : 'show', "]"] })] }), showFileChips && (_jsx(Box, { flexDirection: "row", flexWrap: "wrap", marginTop: 1, children: selectedFiles.map((file) => (_jsx(FileChip, { filePath: file, onRemove: () => handleFileRemove(file) }, file))) }))] })), _jsxs(Box, { borderStyle: "round", borderColor: isProcessing ? "gray" : "blue", paddingX: 1, children: [_jsx(Text, { color: isProcessing ? "gray" : "cyan", children: '> ' }), _jsx(CustomTextInput, { value: inputVal, onChange: handleInputChange, onSubmit: (val) => {
+                                    // Don't submit if autocomplete is open
+                                    if (showAutocomplete) {
+                                        return;
+                                    }
+                                    if (val.trim() && !isProcessing) {
+                                        // Extract file references from @ mentions in text
+                                        const referencedFiles = extractFileReferences(val);
+                                        const allFiles = [...new Set([...selectedFiles, ...referencedFiles])];
+                                        runAgent(val, allFiles.length > 0 ? allFiles : undefined);
+                                        setInputVal('');
+                                        setSelectedFiles([]);
+                                    }
+                                }, focus: !isProcessing && !pendingPermission })] }), showAutocomplete && (_jsx(FileAutocomplete, { files: availableFiles, query: autocompleteQuery, selectedIndex: autocompleteIndex, onSelect: handleFileSelect })), showCommandPalette && (_jsx(CommandPalette, { onExecute: executeCommand, onClose: () => setShowCommandPalette(false) })), _jsx(Box, { flexDirection: "row", justifyContent: "flex-end", children: _jsx(Text, { color: "gray", dimColor: true, children: activeProfile?.name }) })] }))] }));
+};

package/dist/ui/ProfileManager.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput, Newline, useApp } from 'ink';
+import { setActiveProfile, saveConfig } from '../config/configManager.js';
+export const ProfileManager = ({ config: initialConfig, onSelect }) => {
+    const { exit } = useApp();
+    const [localConfig, setLocalConfig] = useState(initialConfig);
+    const [selectionIndex, setSelectionIndex] = useState(() => {
+        const idx = initialConfig.profiles.findIndex(p => p.name === initialConfig.activeProfile);
+        return idx >= 0 ? idx : 0;
+    });
+    const [message, setMessage] = useState('');
+    useInput((input, key) => {
+        // Ctrl+X to Exit
+        if (input === '\x18' || (key.ctrl && input === 'x')) {
+            exit();
+            // Only hard exit if we're not in a larger flow, but for now safe to exit app
+            if (!onSelect)
+                process.exit(0);
+            return;
+        }
+        if (key.upArrow) {
+            setSelectionIndex(prev => (prev - 1 + localConfig.profiles.length) % localConfig.profiles.length);
+            return;
+        }
+        if (key.downArrow) {
+            setSelectionIndex(prev => (prev + 1) % localConfig.profiles.length);
+            return;
+        }
+        if (key.return) {
+            const selectedProfile = localConfig.profiles[selectionIndex];
+            let newConfig = setActiveProfile(localConfig, selectedProfile.name);
+            saveConfig(newConfig);
+            setLocalConfig(newConfig);
+            if (onSelect) {
+                // Give a tiny visual feedback before unmounting? 
+                // Or just instant. Instant is better for "flow".
+                onSelect(selectedProfile);
+            }
+            else {
+                setMessage(`Active profile set to '${selectedProfile.name}'`);
+                setTimeout(() => setMessage(''), 3000);
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan", children: [_jsx(Text, { bold: true, children: "MOTH LLM PROFILES" }), _jsx(Text, { color: "green", children: "Hint: Press Enter to select new model or Ctrl+X to exit nav." }), _jsx(Newline, {}), localConfig.profiles.map((p, i) => {
+                const isSelected = i === selectionIndex;
+                const isActive = p.name === localConfig.activeProfile;
+                return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: isSelected ? "green" : undefined, bold: isSelected, children: isSelected ? "* " : "  " }), _jsx(Text, { bold: isActive, color: isActive ? "green" : undefined, children: p.name }), _jsxs(Text, { children: [" (", p.provider, " / ", p.model, ")"] }), isActive && _jsx(Text, { color: "green", dimColor: true, children: " (active)" })] }, i));
+            }), message && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "green", children: message }) }))] }));
+};

package/dist/ui/components/CommandPalette.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+const commands = [
+    { name: 'LLM: List Profiles', description: 'Show all configured LLM profiles', action: 'llm-list' },
+    { name: 'LLM: Add Profile', description: 'Add a new LLM profile', action: 'llm-add' },
+    { name: 'LLM: Switch Profile', description: 'Switch to a different LLM profile', action: 'llm-use' },
+    { name: 'LLM: Remove Profile', description: 'Remove an LLM profile', action: 'llm-remove' },
+    { name: 'Toggle Autopilot', description: 'Enable/disable autopilot mode', action: 'autopilot' },
+    { name: 'Show Help', description: 'Display help information', action: 'help' },
+];
+export const CommandPalette = ({ onExecute, onClose }) => {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useInput((input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex(prev => Math.max(0, prev - 1));
+        }
+        else if (key.downArrow) {
+            setSelectedIndex(prev => Math.min(commands.length - 1, prev + 1));
+        }
+        else if (key.return) {
+            onExecute(commands[selectedIndex].action);
+        }
+        else if (key.escape || (input === 'u' && key.ctrl)) {
+            onClose();
+        }
+    });
+    return (_jsx(Box, { flexDirection: "column", children: _jsxs(Box, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Command Palette (Ctrl+U to close)" }), _jsx(Text, { dimColor: true, children: "Select a command and press Enter" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: commands.map((cmd, index) => (_jsxs(Box, { marginY: 0, children: [_jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, bold: index === selectedIndex, children: [index === selectedIndex ? '> ' : '  ', cmd.name] }), _jsxs(Text, { dimColor: true, children: [" - ", cmd.description] })] }, cmd.action))) })] }) }));
+};

package/dist/ui/components/CustomTextInput.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+export const CustomTextInput = ({ value: externalValue, onChange, onSubmit, focus = true, placeholder = '' }) => {
+    const [internalValue, setInternalValue] = useState(externalValue);
+    const [cursorPos, setCursorPos] = useState(externalValue.length);
+    // Sync with external value changes (e.g., from file path insertion)
+    useEffect(() => {
+        setInternalValue(externalValue);
+        // Place cursor at end when value changes externally
+        setCursorPos(externalValue.length);
+    }, [externalValue]);
+    useInput((input, key) => {
+        if (!focus)
+            return;
+        // Submit on Enter
+        if (key.return) {
+            onSubmit(internalValue);
+            return;
+        }
+        // Backspace - delete character before cursor
+        if (key.backspace) {
+            if (cursorPos > 0) {
+                const newValue = internalValue.slice(0, cursorPos - 1) + internalValue.slice(cursorPos);
+                setInternalValue(newValue);
+                setCursorPos(cursorPos - 1);
+                onChange(newValue);
+            }
+            return;
+        }
+        // Delete - delete character after cursor
+        if (key.delete) {
+            if (cursorPos < internalValue.length) {
+                const newValue = internalValue.slice(0, cursorPos) + internalValue.slice(cursorPos + 1);
+                setInternalValue(newValue);
+                onChange(newValue);
+            }
+            return;
+        }
+        // Left arrow - move cursor left
+        if (key.leftArrow) {
+            setCursorPos(Math.max(0, cursorPos - 1));
+            return;
+        }
+        // Right arrow - move cursor right
+        if (key.rightArrow) {
+            setCursorPos(Math.min(internalValue.length, cursorPos + 1));
+            return;
+        }
+        // Home - move to start
+        if (key.home) {
+            setCursorPos(0);
+            return;
+        }
+        // End - move to end
+        if (key.end) {
+            setCursorPos(internalValue.length);
+            return;
+        }
+        // Regular character input (ignore ctrl/meta combinations)
+        if (input && !key.ctrl && !key.meta && input.length === 1) {
+            const newValue = internalValue.slice(0, cursorPos) + input + internalValue.slice(cursorPos);
+            setInternalValue(newValue);
+            setCursorPos(cursorPos + 1);
+            onChange(newValue);
+            return;
+        }
+    }, { isActive: focus });
+    // Render the input with cursor
+    const displayValue = internalValue;
+    const beforeCursor = displayValue.slice(0, cursorPos);
+    const cursorChar = displayValue[cursorPos] || ' '; // Always show space if nothing there
+    const afterCursor = displayValue.slice(cursorPos + 1);
+    return (_jsxs(Box, { children: [_jsx(Text, { children: beforeCursor }), _jsx(Text, { inverse: true, children: cursorChar }), _jsx(Text, { children: afterCursor })] }));
+};

package/dist/ui/components/FileAutocomplete.js

@@ -0,0 +1,16 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export const FileAutocomplete = ({ files, query, selectedIndex, onSelect }) => {
+    // Filter files based on query
+    const filteredFiles = files
+        .filter(file => {
+        const lowerFile = file.toLowerCase();
+        const lowerQuery = query.toLowerCase();
+        return lowerFile.includes(lowerQuery);
+    })
+        .slice(0, 10); // Limit to 10 results
+    if (filteredFiles.length === 0) {
+        return (_jsx(Box, { borderStyle: "round", borderColor: "yellow", flexDirection: "column", paddingX: 1, children: _jsxs(Text, { dimColor: true, children: ["No files found matching \"", query, "\""] }) }));
+    }
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "yellow", children: "\u2191\u2193 navigate, Enter inserts path, Esc cancels" }), filteredFiles.map((file, index) => (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, bold: index === selectedIndex, children: [index === selectedIndex ? '> ' : '  ', file] }) }, file)))] }));
+};

package/dist/ui/components/FileChip.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import * as path from 'path';
+export const FileChip = ({ filePath, onRemove }) => {
+    const basename = path.basename(filePath);
+    const dirname = path.dirname(filePath);
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, marginRight: 1, children: [_jsx(Text, { color: "cyan", bold: true, children: basename }), _jsxs(Text, { dimColor: true, children: [" ", dirname !== '.' ? `(${dirname})` : ''] }), _jsx(Text, { color: "red", bold: true, children: " [x]" })] }));
+};

package/dist/ui/components/FlameLogo.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+// Palette mapping: Character -> { color: Hex, symbol: Char }
+const PALETTE = {
+    // Deep Blue / Background blend
+    '1': { color: '#0f20a2', char: '░' },
+    // Outer Blue
+    '2': { color: '#0020ef', char: '▒' },
+    // Mid Blue
+    '3': { color: '#002dff', char: '▓' },
+    // Bright Blue
+    '4': { color: '#0088af', char: '█' },
+    // Cyan
+    '5': { color: '#00c7f7', char: '█' },
+    // Light Cyan
+    '6': { color: '#00ffff', char: '█' },
+    // White Core
+    '7': { color: '#ffffff', char: '█' },
+};
+const HD_FLAME_ART = [
+    "             333             ",
+    "           2333332           ",
+    "          233444332          ",
+    "        2334555554332        ",
+    "       234556666655432       ",
+    "      34567777777776543      ",
+    "     2456777777777776542     ",
+    "    235677766666667776532    ",
+    "    345677655555556776543    ",
+    "   23456765444444456765432   ",
+    "   23455654333333345655432   ",
+    "   12344543222222234544321   ",
+    "   11233432111111123433211   "
+];
+export const FlameLogo = () => {
+    return (_jsx(Box, { flexDirection: "column", marginRight: 2, children: HD_FLAME_ART.map((row, rowIndex) => (_jsx(Box, { children: row.split('').map((char, colIndex) => {
+                const pixel = PALETTE[char];
+                return (_jsx(Text, { color: pixel?.color || undefined, children: pixel ? pixel.char : ' ' }, `${rowIndex}-${colIndex}`));
+            }) }, rowIndex))) }));
+};

package/dist/ui/components/WordFlame.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+import BigText from 'ink-big-text';
+export const WordFlame = ({ text, big = false }) => {
+    if (big) {
+        return (_jsx(Text, { color: "#3EA0C3", children: _jsx(BigText, { text: text, font: "block", colors: ['#0192e5', '#0192e5'] }) }) // BigText needs specific handling or Text wrapper
+        );
+    }
+    return (_jsx(Text, { color: "#0192e5", children: text }));
+};

package/dist/ui/components/WordMoth.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+import BigText from 'ink-big-text';
+export const WordMoth = ({ text, big = false }) => {
+    if (big) {
+        return (_jsx(Text, { color: "#3EA0C3", children: _jsx(BigText, { text: text, font: "block", colors: ['#0192e5', '#0192e5'] }) }) // BigText needs specific handling or Text wrapper
+        );
+    }
+    return (_jsx(Text, { color: "#0192e5", children: text }));
+};