@kishlay42/moth-ai 1.0.1

package/dist/tools/definitions.js

@@ -0,0 +1,187 @@
+// --- 5. Planning (Keep Existing) ---
+export const TodoWriteTool = {
+    name: 'todo_write',
+    description: 'Add a new task to the plan or update an existing task status.',
+    parameters: {
+        type: 'object',
+        properties: {
+            action: { type: 'string', enum: ['add', 'update'], description: 'Action to perform.' },
+            text: { type: 'string', description: 'Text content of the task (required for add).' },
+            id: { type: 'string', description: 'ID of the task to update (required for update).' },
+            status: { type: 'string', enum: ['pending', 'in-progress', 'completed', 'failed'], description: 'New status.' }
+        },
+        required: ['action']
+    }
+};
+export const TodoReadTool = {
+    name: 'todo_read',
+    description: 'Read the current plan and task statuses.',
+    parameters: { type: 'object', properties: {} }
+};
+// --- 1. Filesystem Tools ---
+export const ReadFileTool = {
+    name: 'read_file',
+    description: 'Read the contents of a file.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file.' }
+        },
+        required: ['path']
+    }
+};
+export const ListDirTool = {
+    name: 'list_dir',
+    description: 'List contents of a directory.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Directory path.' }
+        },
+        required: ['path']
+    }
+};
+export const CreateFileTool = {
+    name: 'create_file',
+    description: 'Create a new file (fails if exists).',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path for the new file.' },
+            content: { type: 'string', description: 'Initial content (optional).' }
+        },
+        required: ['path']
+    }
+};
+export const WriteFileTool = {
+    name: 'write_file',
+    description: 'Overwrite an entire file.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file.' },
+            content: { type: 'string', description: 'New content.' }
+        },
+        required: ['path', 'content']
+    }
+};
+export const EditFileTool = {
+    name: 'edit_file',
+    description: 'Modify a file using a Unified Diff.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file.' },
+            diff: { type: 'string', description: 'Unified Diff string to apply.' }
+        },
+        required: ['path', 'diff']
+    }
+};
+export const CreateDirTool = {
+    name: 'create_dir',
+    description: 'Create a new directory.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Directory path.' }
+        },
+        required: ['path']
+    }
+};
+// --- 2. Search & Discovery ---
+export const SearchTextTool = {
+    name: 'search_text',
+    description: 'Search for text across project files.',
+    parameters: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Text or regex to search for.' },
+            path: { type: 'string', description: 'Specific path to limit search (optional).' }
+        },
+        required: ['query']
+    }
+};
+export const SearchFilesTool = {
+    name: 'search_files',
+    description: 'Find files by name or pattern.',
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Glob pattern or filename.' }
+        },
+        required: ['pattern']
+    }
+};
+// --- 3. Command Execution ---
+export const RunCommandTool = {
+    name: 'run_command',
+    description: 'Execute a shell command.',
+    parameters: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'Command to execute.' },
+            cwd: { type: 'string', description: 'Working directory (optional).' }
+        },
+        required: ['command']
+    }
+};
+// --- 4. Context Tools ---
+export const ScanContextTool = {
+    name: 'scan_context',
+    description: 'Scan project structure and understand file hierarchy.',
+    parameters: {
+        type: 'object',
+        properties: {
+            root: { type: 'string', description: 'Root directory to scan (optional).' }
+        }
+    }
+};
+export const SummarizeFileTool = {
+    name: 'summarize_file',
+    description: 'Get a summary of a file (first 100 lines).',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'File path.' }
+        },
+        required: ['path']
+    }
+};
+// --- Extras (Git/Test/Format) ---
+export const GitDiffTool = {
+    name: 'git_diff',
+    description: 'Show unstaged changes (git diff).',
+    parameters: { type: 'object', properties: {} }
+};
+export const GitCommitTool = {
+    name: 'git_commit',
+    description: 'Commit staged changes.',
+    parameters: {
+        type: 'object',
+        properties: {
+            message: { type: 'string', description: 'Commit message.' }
+        },
+        required: ['message']
+    }
+};
+export const TestRunTool = {
+    name: 'test_run',
+    description: 'Run project tests.',
+    parameters: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'Specific test command (optional).' }
+        }
+    }
+};
+export const FormatFileTool = {
+    name: 'format_file',
+    description: 'Format a file (using prettier if available).',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'File path.' }
+        },
+        required: ['path']
+    }
+};

package/dist/tools/factory.js

@@ -0,0 +1,196 @@
+import { ToolRegistry } from './registry.js';
+import * as Defs from './definitions.js'; // Import all as Defs
+import { Patcher } from '../editing/patcher.js';
+import { ProjectScanner } from '../context/scanner.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export function createToolRegistry(root, todoManager, checkPermission) {
+    const registry = new ToolRegistry();
+    const patcher = new Patcher(root);
+    const scanner = new ProjectScanner(root);
+    // --- Middleware ---
+    const withPermission = (name, executor) => {
+        return async (args) => {
+            if (checkPermission) {
+                const response = await checkPermission(name, args);
+                if (!response.allowed) {
+                    return response.feedback
+                        ? `User denied permission with feedback: ${response.feedback}`
+                        : "User denied permission.";
+                }
+            }
+            return executor(args);
+        };
+    };
+    // --- Implementations ---
+    // 5. Planning
+    registry.register(Defs.TodoWriteTool, async (args) => {
+        if (args.action === 'add')
+            todoManager.add(args.text);
+        if (args.action === 'update')
+            todoManager.updateStatus(args.id, args.status);
+        return "Todo updated.";
+    });
+    registry.register(Defs.TodoReadTool, async () => {
+        return JSON.stringify(todoManager.list(), null, 2);
+    });
+    // 1. Filesystem
+    registry.register(Defs.ReadFileTool, async (args) => {
+        const fullPath = path.join(root, args.path);
+        // Security: Prevent breaking out of root
+        if (!fullPath.startsWith(root))
+            return "Error: Access denied (outside root).";
+        try {
+            return await fs.readFile(fullPath, 'utf-8');
+        }
+        catch (e) {
+            return `Error reading file: ${e.message}`;
+        }
+    });
+    registry.register(Defs.ListDirTool, async (args) => {
+        const fullPath = path.join(root, args.path);
+        if (!fullPath.startsWith(root))
+            return "Error: Access denied.";
+        try {
+            const files = await fs.readdir(fullPath);
+            return files.join('\n');
+        }
+        catch (e) {
+            return `Error listing dir: ${e.message}`;
+        }
+    });
+    // GATED: Create File
+    registry.register(Defs.CreateFileTool, withPermission('create_file', async (args) => {
+        const fullPath = path.join(root, args.path);
+        if (!fullPath.startsWith(root))
+            return "Error: Access denied.";
+        try {
+            await fs.access(fullPath);
+            return "Error: File already exists. Use write_file to overwrite.";
+        }
+        catch {
+            // File doesn't exist, proceed
+            await fs.writeFile(fullPath, args.content || '');
+            return `File created at ${args.path}`;
+        }
+    }));
+    // GATED: Write File
+    registry.register(Defs.WriteFileTool, withPermission('write_file', async (args) => {
+        const fullPath = path.join(root, args.path);
+        if (!fullPath.startsWith(root))
+            return "Error: Access denied.";
+        await fs.writeFile(fullPath, args.content);
+        return `File written to ${args.path}`;
+    }));
+    // GATED: Edit File
+    registry.register(Defs.EditFileTool, withPermission('edit_file', async (args) => {
+        // Patcher handles safety/backups internally
+        const success = await patcher.applyPatch(args.path, args.diff);
+        return success ? "Patch applied successfully." : "Patch application failed (check context/backups).";
+    }));
+    // GATED: Create Dir
+    registry.register(Defs.CreateDirTool, withPermission('create_dir', async (args) => {
+        const fullPath = path.join(root, args.path);
+        if (!fullPath.startsWith(root))
+            return "Error: Access denied.";
+        await fs.mkdir(fullPath, { recursive: true });
+        return `Directory created: ${args.path}`;
+    }));
+    // 2. Search & Discovery
+    registry.register(Defs.SearchTextTool, async (args) => {
+        // Using grep for speed (assuming unix/git bash context or simple grep availability)
+        // Fallback: This is a hacky implementation, properly we should traverse.
+        // For now, let's use Scanner to get files and basic JS search if grep fails? 
+        // Actually, let's trust child_process 'grep' or 'findstr' based on OS, OR implement JS search.
+        // JS Search is safer and cross-platform.
+        try {
+            const files = await scanner.scan(); // Get all files
+            const regex = new RegExp(args.query);
+            const results = [];
+            for (const file of files.slice(0, 50)) { // Limit to 50 for perf
+                const content = await fs.readFile(path.join(root, file), 'utf-8');
+                if (regex.test(content))
+                    results.push(file);
+            }
+            return `Found in:\n${results.join('\n')}`;
+        }
+        catch (e) {
+            return `Search error: ${e.message}`;
+        }
+    });
+    registry.register(Defs.SearchFilesTool, async (args) => {
+        const files = await scanner.scan();
+        // Simple includes check
+        return files.filter(f => f.includes(args.pattern)).join('\n');
+    });
+    // 3. Command Execution - GATED
+    registry.register(Defs.RunCommandTool, withPermission('run_command', async (args) => {
+        try {
+            const { stdout, stderr } = await execAsync(args.command, { cwd: args.cwd || root });
+            return `STDOUT:\n${stdout}\nSTDERR:\n${stderr}`;
+        }
+        catch (e) {
+            return `Command failed: ${e.message}\nSTDOUT:\n${e.stdout}\nSTDERR:\n${e.stderr}`;
+        }
+    }));
+    // 4. Context
+    registry.register(Defs.ScanContextTool, async () => {
+        const files = await scanner.scan();
+        return `Project Files (${files.length}):\n${files.join('\n')}`;
+    });
+    registry.register(Defs.SummarizeFileTool, async (args) => {
+        const fullPath = path.join(root, args.path);
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            const lines = content.split('\n').slice(0, 100);
+            return `Summary (first 100 lines):\n${lines.join('\n')}`;
+        }
+        catch (e) {
+            return `Error: ${e.message}`;
+        }
+    });
+    // 5. Extras
+    registry.register(Defs.GitDiffTool, async () => {
+        try {
+            const { stdout } = await execAsync('git diff', { cwd: root });
+            return stdout || "No changes.";
+        }
+        catch (e) {
+            return `Git error: ${e.message}`;
+        }
+    });
+    registry.register(Defs.GitCommitTool, withPermission('git_commit', async (args) => {
+        try {
+            // Add all? Or just commit? Let's assume user staged manually or we add all.
+            // Safety: Let's just commit what is staged.
+            const { stdout } = await execAsync(`git commit -m "${args.message}"`, { cwd: root });
+            return stdout;
+        }
+        catch (e) {
+            return `Commit error: ${e.message}`;
+        }
+    }));
+    registry.register(Defs.TestRunTool, withPermission('test_run', async (args) => {
+        const cmd = args.command || 'npm test';
+        try {
+            const { stdout, stderr } = await execAsync(cmd, { cwd: root });
+            return `Test Results:\n${stdout}\n${stderr}`;
+        }
+        catch (e) {
+            return `Tests failed: ${e.message}`;
+        }
+    }));
+    registry.register(Defs.FormatFileTool, withPermission('format_file', async (args) => {
+        try {
+            await execAsync(`npx prettier --write "${args.path}"`, { cwd: root });
+            return `Formatted ${args.path}`;
+        }
+        catch (e) {
+            return `Format error: ${e.message}`;
+        }
+    }));
+    return registry;
+}

package/dist/tools/registry.js

@@ -0,0 +1,21 @@
+export class ToolRegistry {
+    tools = new Map();
+    register(definition, executor) {
+        this.tools.set(definition.name, { definition, executor });
+    }
+    getDefinitions() {
+        return Array.from(this.tools.values()).map(t => t.definition);
+    }
+    async execute(name, args) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            throw new Error(`Tool '${name}' not found.`);
+        }
+        try {
+            return await tool.executor(args);
+        }
+        catch (error) {
+            return `Error executing tool '${name}': ${error.message}`;
+        }
+    }
+}

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/App.js

@@ -0,0 +1,182 @@
+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 { TodoManager } from '../planning/todoManager.js';
+import { AgentOrchestrator } from '../agent/orchestrator.js';
+import { createToolRegistry } from '../tools/factory.js';
+import { findProjectRoot } from '../utils/paths.js';
+import TextInput from 'ink-text-input';
+import { WordMoth } from './components/WordMoth.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...');
+    // 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]);
+    // 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) => {
+        if (showWelcome)
+            setShowWelcome(false);
+        setIsProcessing(true);
+        // Create new user message
+        const userMsg = { role: 'user', content: userPrompt };
+        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);
+            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);
+        }
+    };
+    useInput((input, key) => {
+        // ESC Pause
+        if (key.escape) {
+            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 ---
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [(command === 'run' && showWelcome && messages.length === 0) && (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingBottom: 1, paddingTop: 0, borderStyle: "round", borderColor: "#0192e5", alignItems: "flex-start", children: [_jsx(WordMoth, { text: "MOTH", big: true }), _jsxs(Box, { flexDirection: "column", alignItems: "flex-start", marginTop: -1, children: [_jsx(Text, { dimColor: true, children: "v1.0.0" }), _jsxs(Text, { color: "#3EA0C3", bold: true, children: ["Welcome back, ", username || os.userInfo().username, "."] }), _jsxs(Text, { color: "green", children: ["Active AI: ", activeProfile?.name || 'None'] }), _jsxs(Text, { dimColor: true, children: ["Path: ", process.cwd()] }), _jsx(Text, { dimColor: true, children: "Run \"moth --help\" to view all 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" })), _jsxs(Box, { borderStyle: "round", borderColor: isProcessing ? "gray" : "blue", paddingX: 1, children: [_jsx(Text, { color: isProcessing ? "gray" : "cyan", children: '> ' }), _jsx(TextInput, { value: inputVal, onChange: setInputVal, onSubmit: (val) => {
+                                    if (val.trim() && !isProcessing) {
+                                        runAgent(val);
+                                        setInputVal('');
+                                    }
+                                }, focus: !isProcessing && !pendingPermission })] }), _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 }) }))] }));
+};