toolpack-cli 0.1.0-SNAPSHOT

package/dist/screens/ChatScreen.js

@@ -0,0 +1,327 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useLayoutEffect, useRef } from 'react';
+import { Box, Text, useStdout, useInput, measureElement } from 'ink';
+import TextInput from 'ink-text-input';
+import { useTheme } from '../theme/ThemeContext.js';
+import { useConversation } from '../context/ConversationContext.js';
+import { useToolpack } from '../context/ToolpackContext.js';
+import { Markdown } from '../components/Markdown.js';
+import { isCommand, executeCommand } from '../commands/index.js';
+import * as dbManager from '../services/db.js';
+import { ToolLogPopup } from '../components/ToolLogPopup.js';
+import { ShimmerText } from '../components/ShimmerText.js';
+export function ChatScreen() {
+    const { theme } = useTheme();
+    const { stdout } = useStdout();
+    const { activeConversation, addMessage, clearHistory, pendingPrompt, setPendingPrompt, setScreen, } = useConversation();
+    const { toolpack, activeMode, activeModel, activeModelCapabilities, workflowProgress, toolHistory, clearToolHistory, clearWorkflowProgress, toolsUnsupportedWarning, setToolsUnsupportedWarning, clearToolsUnsupportedWarning, } = useToolpack();
+    const [input, setInput] = useState('');
+    const [streamingContent, setStreamingContent] = useState('');
+    const [isStreaming, setIsStreaming] = useState(false);
+    const [error, setError] = useState(null);
+    const [showToolLogPopup, setShowToolLogPopup] = useState(false);
+    const [wasInterrupted, setWasInterrupted] = useState(false);
+    const abortControllerRef = useRef(null);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const [isUserScrolled, setIsUserScrolled] = useState(false);
+    const prevMessageCountRef = useRef(0);
+    // Keep a ref to the latest messages so handleSubmit always has the freshest state
+    const messagesRef = useRef([]);
+    useEffect(() => {
+        messagesRef.current = activeConversation?.messages || [];
+    }, [activeConversation?.messages]);
+    // The outer Box has height={stdout.rows - 1}.
+    // Fixed rows consumed above the scroll area: header(1) + separator(1) + paddingY(2) = 4
+    // Fixed rows consumed below: input(3) + footer(1) = 4. Total fixed = 8.
+    // We do NOT use measureElement for visibleLines to avoid feedback loops.
+    // viewport paddingY={1} adds 2 more rows consumed. Total = 10.
+    const visibleLines = Math.max(1, stdout.rows - 11);
+    // Measure the actual content height from the DOM after every render.
+    // Use a ref to avoid triggering state updates (which would cause infinite loops).
+    const contentRef = useRef(null);
+    const viewportRef = useRef(null); // unused for measurement, just for ref
+    const totalLinesRef = useRef(0);
+    const [totalLines, setTotalLines] = useState(0);
+    // Measure content height synchronously before paint using useLayoutEffect.
+    // This prevents the blank screen flash that occurs when measurement happens after render.
+    useLayoutEffect(() => {
+        if (contentRef.current) {
+            const { height } = measureElement(contentRef.current);
+            if (height !== totalLinesRef.current) {
+                totalLinesRef.current = height;
+                setTotalLines(height);
+                // Immediately update scroll offset if auto-scrolling to prevent blank screen
+                if (!isUserScrolled) {
+                    const newOffset = height > visibleLines ? Math.max(0, height - visibleLines) : 0;
+                    setScrollOffset(newOffset);
+                }
+            }
+        }
+    }, [activeConversation?.messages, streamingContent, isStreaming, visibleLines, isUserScrolled]);
+    // Auto-scroll: when the user hasn't manually scrolled, keep the view at the bottom.
+    // This handles both streaming content growth and history load.
+    // Also clamp scrollOffset to prevent showing blank space beyond content
+    useEffect(() => {
+        const maxOffset = Math.max(0, totalLines - visibleLines);
+        if (!isUserScrolled) {
+            // Auto-scroll to bottom
+            setScrollOffset(maxOffset);
+        }
+        else {
+            // User scrolled manually - clamp to valid range to prevent blank screens
+            setScrollOffset(prev => {
+                const clamped = Math.min(prev, maxOffset);
+                // If clamped value is at max, consider user back at bottom
+                if (clamped >= maxOffset - 1) {
+                    setIsUserScrolled(false);
+                }
+                return clamped;
+            });
+        }
+    }, [totalLines, visibleLines, isUserScrolled]);
+    // Additional safeguard: always clamp scroll offset to prevent blank screens
+    useEffect(() => {
+        const maxOffset = Math.max(0, totalLines - visibleLines);
+        setScrollOffset(prev => {
+            // If scroll offset is beyond valid range, reset to bottom
+            if (prev > maxOffset) {
+                return maxOffset;
+            }
+            return prev;
+        });
+    }, [totalLines, visibleLines]);
+    // When a conversation is loaded from history (bulk message load),
+    // ensure we auto-scroll to the bottom.
+    useEffect(() => {
+        const msgCount = activeConversation?.messages.length ?? 0;
+        const prevCount = prevMessageCountRef.current;
+        prevMessageCountRef.current = msgCount;
+        // Bulk load detected: ensure auto-follow is on
+        if (msgCount - prevCount > 2) {
+            setIsUserScrolled(false);
+        }
+    }, [activeConversation?.messages.length]);
+    useEffect(() => {
+        const handleData = (data) => {
+            const str = data.toString();
+            const match = str.match(/\x1b\[<(64|65);\d+;\d+M/);
+            if (match && match[1]) {
+                const button = parseInt(match[1], 10);
+                if (button === 64) {
+                    setIsUserScrolled(true);
+                    setScrollOffset(prev => Math.max(0, prev - 3));
+                }
+                else if (button === 65) {
+                    const maxOffset = Math.max(0, totalLines - visibleLines);
+                    setScrollOffset(prev => {
+                        const next = Math.min(maxOffset, prev + 3);
+                        if (next >= maxOffset)
+                            setIsUserScrolled(false);
+                        else
+                            setIsUserScrolled(true);
+                        return next;
+                    });
+                }
+            }
+        };
+        process.stdin.on('data', handleData);
+        return () => {
+            process.stdin.off('data', handleData);
+        };
+    }, [totalLines, visibleLines]);
+    // Escape listener to go back home, and PageUp/PageDown/Arrows for scrolling
+    useInput((input, key) => {
+        if (input === 'q' && isStreaming && abortControllerRef.current) {
+            abortControllerRef.current.abort();
+            return;
+        }
+        if (key.escape && !isStreaming && !showToolLogPopup) {
+            clearHistory();
+        }
+        else if (key.pageDown) {
+            const maxOffset = Math.max(0, totalLines - visibleLines);
+            setScrollOffset(prev => {
+                const next = Math.min(maxOffset, prev + visibleLines - 1);
+                if (next >= maxOffset)
+                    setIsUserScrolled(false);
+                else
+                    setIsUserScrolled(true);
+                return next;
+            });
+        }
+        else if (key.pageUp) {
+            setIsUserScrolled(true);
+            setScrollOffset(prev => Math.max(0, prev - visibleLines + 1));
+        }
+        else if (key.upArrow) {
+            setIsUserScrolled(true);
+            setScrollOffset(prev => Math.max(0, prev - 3));
+        }
+        else if (key.downArrow) {
+            setIsUserScrolled(true);
+            const maxOffset = Math.max(0, totalLines - visibleLines);
+            setScrollOffset(prev => Math.min(maxOffset, prev + 3));
+        }
+    });
+    useEffect(() => {
+        if (pendingPrompt && toolpack && !isStreaming) {
+            const promptToSubmit = pendingPrompt;
+            setPendingPrompt(null); // Clear it immediately so it doesn't double-fire
+            handleSubmit(promptToSubmit);
+        }
+    }, [pendingPrompt, toolpack]);
+    const handleSubmit = async (value) => {
+        if (!value.trim() || isStreaming)
+            return;
+        // Strip newlines from submission just in case
+        const prompt = value.trim();
+        setInput('');
+        // Handle slash commands
+        if (isCommand(prompt)) {
+            const context = {
+                toolpack,
+                activeMode,
+                activeModel,
+                activeConversation,
+                addMessage,
+                clearHistory,
+                setScreen,
+            };
+            const result = await executeCommand(prompt, context);
+            if (result.action === 'navigate') {
+                return; // Navigation handled by command
+            }
+            if (result.action === 'popup') {
+                // Show popup with tool history from context
+                setShowToolLogPopup(true);
+                return;
+            }
+            if (result.message) {
+                // Display command output as system message
+                addMessage('system', result.message);
+            }
+            return;
+        }
+        // Regular chat message - requires toolpack
+        if (!toolpack)
+            return;
+        // Save user message immediately
+        addMessage('user', prompt);
+        setIsStreaming(true);
+        setError(null);
+        setStreamingContent('');
+        setWasInterrupted(false);
+        clearToolHistory(); // Clear tool history for new request
+        clearWorkflowProgress(); // Clear previous workflow status
+        clearToolsUnsupportedWarning(); // Clear any previous tool warning
+        // Create abort controller for interrupt capability
+        const abortController = new AbortController();
+        abortControllerRef.current = abortController;
+        let fullResponse = '';
+        try {
+            // Build message array from the database (synchronous, always fresh)
+            // This ensures we have the complete conversation history including the just-added user message
+            // System messages are CLI-only display messages and should not be sent to the AI
+            const dbMessages = activeConversation
+                ? dbManager.getMessages(activeConversation.id)
+                : [];
+            const historyMessages = dbMessages
+                .filter((m) => m.role !== 'system')
+                .map((m) => ({
+                role: m.role,
+                content: m.content,
+            }));
+            // Check if model supports tools - if not and mode uses tools, show warning after response
+            const modeUsesTools = activeMode?.allowedToolCategories &&
+                activeMode.allowedToolCategories.length > 0;
+            const modelSupportsTools = activeModelCapabilities?.toolCalling !== false;
+            const shouldWarnAboutTools = modeUsesTools && !modelSupportsTools;
+            const streamOptions = {
+                // historyMessages already includes the current user message (saved to DB above)
+                messages: historyMessages,
+                model: activeModel,
+            };
+            // If model doesn't support tools, explicitly set tool_choice to 'none' to skip sending tools
+            if (shouldWarnAboutTools) {
+                streamOptions.tool_choice = 'none';
+            }
+            const stream = toolpack.stream({
+                ...streamOptions,
+                signal: abortController.signal,
+            });
+            for await (const chunk of stream) {
+                if (abortController.signal.aborted) {
+                    break;
+                }
+                if (chunk.delta) {
+                    fullResponse += chunk.delta;
+                    setStreamingContent(fullResponse);
+                }
+            }
+            // Save final assistant message (tool history comes from context)
+            // IMPORTANT: Clear streaming content BEFORE adding message to prevent
+            // a brief state where both exist, causing measurement issues
+            setStreamingContent('');
+            if (abortController.signal.aborted) {
+                setWasInterrupted(true);
+                if (fullResponse.trim()) {
+                    addMessage('assistant', fullResponse + '\n\n*[Interrupted]*');
+                }
+            }
+            else {
+                addMessage('assistant', fullResponse);
+            }
+            // Force scroll to bottom after message is added
+            setIsUserScrolled(false);
+            // Show warning if model doesn't support tools but mode uses them
+            if (shouldWarnAboutTools) {
+                setToolsUnsupportedWarning(`Model "${activeModel}" does not support tool/function calls. Running in chat-only mode.`);
+            }
+        }
+        catch (err) {
+            // Don't show error for intentional abort
+            if (err.name === 'AbortError' || abortController.signal.aborted) {
+                setWasInterrupted(true);
+            }
+            else {
+                console.error('[ChatScreen] Streaming error:', err);
+                // Save partial response so it's not lost from conversation history
+                if (fullResponse.trim()) {
+                    addMessage('assistant', fullResponse +
+                        '\n\n• **Step failed:** ' +
+                        (err.message || String(err)) +
+                        '*Workflow aborted.*');
+                }
+                setError(err.message || String(err));
+            }
+        }
+        finally {
+            setIsStreaming(false);
+            abortControllerRef.current = null;
+        }
+    };
+    const handleInputChange = (val) => {
+        let sanitized = val.replace(/\x1b?\[<\d+;\d+;\d+[mM]/g, '');
+        sanitized = sanitized.replace(/\x1b/g, '');
+        setInput(sanitized);
+    };
+    return (_jsxs(Box, { width: stdout.columns, height: stdout.rows - 1, flexDirection: "column", children: [_jsx(Box, { flexDirection: "row", borderBottom: false, paddingY: 0, paddingX: 1, flexShrink: 0, children: _jsxs(Text, { color: theme.colors.secondary, children: ["Conversation:", ' ', _jsx(Text, { color: theme.colors.primary, bold: true, children: activeConversation?.title }), ' ', "| Mode: ", activeMode?.displayName || 'All', " | Model: ", activeModel] }) }), _jsx(Box, { width: "100%", height: 1, flexShrink: 0, paddingX: 1, children: _jsx(Text, { color: theme.colors.border, children: '─'.repeat(stdout.columns - 2) }) }), _jsx(Box, { flexGrow: 1, flexDirection: "column", paddingX: 1, paddingY: 1, overflowY: "hidden", ref: viewportRef, children: _jsx(Box, { marginTop: -scrollOffset, flexDirection: "column", flexShrink: 0, children: _jsxs(Box, { flexDirection: "column", flexShrink: 0, ref: contentRef, children: [activeConversation?.messages.map((msg, index) => {
+                                const isUser = msg.role === 'user';
+                                const isSystem = msg.role === 'system';
+                                return (_jsx(Box, { flexDirection: "column", marginBottom: 1, flexShrink: 0, width: "100%", borderStyle: isUser ? 'round' : isSystem ? 'single' : undefined, borderColor: isUser
+                                        ? theme.colors.highlight
+                                        : isSystem
+                                            ? theme.colors.border
+                                            : undefined, paddingX: isUser || isSystem ? 1 : 0, paddingY: isUser || isSystem ? 1 : 0, children: _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: 2, flexShrink: 0, children: isUser ? (_jsx(Text, { color: theme.colors.secondary, bold: true, children: '> ' })) : isSystem ? (_jsx(Text, { color: theme.colors.highlight, bold: true, children: '⚡' })) : (_jsx(Text, { color: theme.colors.primary, bold: true, children: '• ' })) }), _jsx(Box, { flexGrow: 1, flexDirection: "column", children: isUser ? (_jsx(Text, { children: msg.content })) : (_jsx(Markdown, { children: msg.content })) })] }) }, index));
+                            }), isStreaming && (_jsx(Box, { flexDirection: "column", marginBottom: 1, flexShrink: 0, children: _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: 2, flexShrink: 0, children: _jsx(Text, { color: theme.colors.primary, bold: true, children: '• ' }) }), _jsx(Box, { flexGrow: 1, flexDirection: "column", children: streamingContent ? (_jsx(Markdown, { children: streamingContent })) : !workflowProgress ? (_jsx(Text, { color: theme.colors.textSecondary, italic: true, children: "Thinking..." })) : null })] }) })), error && (_jsx(Box, { flexDirection: "column", marginBottom: 1, flexShrink: 0, children: _jsxs(Text, { color: "#ef4444", children: ["Error: ", error] }) }))] }) }) }), workflowProgress && (_jsx(Box, { paddingX: 1, marginTop: 1, flexShrink: 0, children: workflowProgress.status === 'executing' ? (_jsx(ShimmerText, { text: `Step ${workflowProgress.currentStep}/${workflowProgress.totalSteps}: ${workflowProgress.currentStepDescription}`, baseColor: theme.colors.textSecondary, brightColor: theme.colors.primary, speed: 100 })) : workflowProgress.status === 'completed' ? (_jsxs(Text, { color: theme.colors.textSecondary, dimColor: true, children: ["Workflow completed. (", workflowProgress.currentStep, "/", workflowProgress.totalSteps, " steps)"] })) : null })), !isStreaming && toolsUnsupportedWarning && (_jsx(Box, { paddingX: 1, marginTop: 1, flexShrink: 0, children: _jsxs(Text, { color: "#f59e0b", children: ["\u26A0 ", toolsUnsupportedWarning] }) })), _jsxs(Box, { paddingX: 1, marginTop: 1, marginBottom: 1, flexShrink: 0, flexDirection: "row", children: [_jsx(Text, { color: theme.colors.text, bold: true, children: '> ' }), isStreaming ? (_jsx(Text, { color: theme.colors.textSecondary, children: "Thinking..." })) : (_jsx(TextInput, { value: input, onChange: handleInputChange, onSubmit: handleSubmit, placeholder: activeConversation?.messages.length === 0
+                            ? 'Ask anything...'
+                            : 'Send a message...' }))] }), _jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(Text, { color: theme.colors.textSecondary, children: isStreaming ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "#ef4444", bold: true, children: "q" }), _jsx(Text, { children: " :Interrupt | " }), _jsx(Text, { color: "#fbbf24", bold: true, children: "\u2191/\u2193/PgUp/PgDn" }), _jsx(Text, { children: " :Scroll" })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: "#fbbf24", bold: true, children: "Esc" }), _jsx(Text, { children: " :Home | " }), _jsx(Text, { color: "#fbbf24", bold: true, children: "\u2191/\u2193/PgUp/PgDn" }), _jsx(Text, { children: " :Scroll | " }), _jsx(Text, { color: "#fbbf24", bold: true, children: "/help" }), _jsx(Text, { children: " :Commands" }), wasInterrupted && (_jsx(Text, { color: "#f59e0b", children: " | Last response interrupted" }))] })) }) }), showToolLogPopup && (_jsx(ToolLogPopup, { toolCalls: toolHistory.map(t => ({
+                    id: t.id,
+                    name: t.name,
+                    arguments: t.arguments,
+                    result: t.result,
+                    timestamp: t.timestamp,
+                    duration: t.duration,
+                    status: t.status === 'success' ? 'success' : 'error',
+                })), onClose: () => setShowToolLogPopup(false) }))] }));
+}

package/dist/screens/HomeScreen.d.ts

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

package/dist/screens/HomeScreen.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, useStdout, useInput, Text } from 'ink';
+import { useTheme } from '../theme/ThemeContext.js';
+import { useToolpack } from '../context/ToolpackContext.js';
+import { useConversation } from '../context/ConversationContext.js';
+import { Logo } from '../components/Logo.js';
+import { AppInfo } from '../components/AppInfo.js';
+import { HomeInput } from '../components/HomeInput.js';
+import { ModeSelect } from '../components/common/ModeSelect.js';
+import { ModelSelect } from '../components/common/ModelSelect.js';
+import { HistorySelect } from '../components/common/HistorySelect.js';
+export function HomeScreen() {
+    const { theme } = useTheme();
+    const { stdout } = useStdout();
+    const { setMode, setModel, models } = useToolpack();
+    const { loadConversation, setScreen } = useConversation();
+    // 0 = TextInput, 1 = Mode, 2 = Model, 3 = History
+    const [focusedIndex, setFocusedIndex] = useState(0);
+    const [showModeSelect, setShowModeSelect] = useState(false);
+    const [showModelSelect, setShowModelSelect] = useState(false);
+    const [showHistorySelect, setShowHistorySelect] = useState(false);
+    const anyModalOpen = showModeSelect || showModelSelect || showHistorySelect;
+    // Catch Tab keys globally at this screen level
+    useInput((input, key) => {
+        if (anyModalOpen)
+            return; // Prevent tab cycling if modal is open
+        if (key.tab) {
+            if (key.shift) {
+                setFocusedIndex(prev => (prev > 0 ? prev - 1 : 3));
+            }
+            else {
+                setFocusedIndex(prev => (prev < 3 ? prev + 1 : 0));
+            }
+        }
+        if (key.ctrl && input === 's') {
+            setScreen('settings');
+        }
+    });
+    return (_jsxs(Box, { width: stdout.columns, height: stdout.rows - 1, flexDirection: "column", position: "relative", children: [_jsxs(Box, { width: "100%", alignItems: "center", flexDirection: "column", paddingTop: 6, flexShrink: 0, children: [_jsx(Logo, {}), _jsx(AppInfo, {})] }), _jsx(Box, { flexGrow: 1, width: "100%", justifyContent: "center", alignItems: "center", flexDirection: "column", children: _jsx(Box, { width: "80%", children: _jsx(HomeInput, { focusedIndex: focusedIndex, showModeSelect: showModeSelect, setShowModeSelect: setShowModeSelect, showModelSelect: showModelSelect, setShowModelSelect: setShowModelSelect, showHistorySelect: showHistorySelect, setShowHistorySelect: setShowHistorySelect }) }) }), _jsx(Box, { width: "100%", flexDirection: "column", alignItems: "center", paddingBottom: 1, flexShrink: 0, children: _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.colors.textSecondary, children: [_jsx(Text, { color: "#eab308", bold: true, children: "\u2022 Note" }), ' ', "If you are using local models, make sure to have them downloaded and available."] }) }) }), showModeSelect && (_jsx(ModeSelect, { onSelect: val => {
+                    setMode(val);
+                    setShowModeSelect(false);
+                    setFocusedIndex(0); // Return focus to input
+                }, onClose: () => {
+                    setShowModeSelect(false);
+                    setFocusedIndex(0); // Return focus to input
+                } })), showModelSelect && (_jsx(ModelSelect, { onSelect: () => {
+                    setShowModelSelect(false);
+                    setFocusedIndex(0); // Return focus to input
+                }, onClose: () => {
+                    setShowModelSelect(false);
+                    setFocusedIndex(0); // Return focus to input
+                } })), showHistorySelect && (_jsx(HistorySelect, { onSelect: (id, _label) => {
+                    const { mode, model } = loadConversation(id);
+                    // Restore the mode and model from the conversation
+                    if (mode)
+                        setMode(mode);
+                    if (model) {
+                        const full = models.find(m => m.value === model);
+                        setModel({ value: model, provider: full?.provider });
+                    }
+                    setShowHistorySelect(false);
+                    setFocusedIndex(0); // Return focus to input
+                }, onClose: () => {
+                    setShowHistorySelect(false);
+                    setFocusedIndex(0); // Return focus to input
+                } }))] }));
+}

package/dist/screens/SettingsScreen.d.ts

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

package/dist/screens/SettingsScreen.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } 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 open from 'open';
+import * as path from 'path';
+import * as os from 'os';
+export function SettingsScreen() {
+    const { theme } = useTheme();
+    const { stdout } = useStdout();
+    const { setScreen } = useConversation();
+    const { configSource, activeConfigPath } = useToolpack();
+    const [statusMsg, setStatusMsg] = useState(null);
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            setScreen('home');
+        }
+        else if (input === 'o' && activeConfigPath) {
+            open(activeConfigPath).catch(err => {
+                setStatusMsg(`Failed to open config: ${err.message}`);
+            });
+            setStatusMsg(`Opening ${activeConfigPath}...`);
+            setTimeout(() => setStatusMsg(null), 3000);
+        }
+    });
+    return (_jsx(Box, { width: stdout.columns, height: stdout.rows - 1, flexDirection: "column", paddingX: 2, paddingY: 1, children: _jsxs(Box, { borderStyle: "single", borderColor: theme.colors.border, paddingX: 2, paddingY: 1, flexDirection: "column", width: "100%", children: [_jsx(Text, { color: theme.colors.primary, bold: true, children: "\u2699 Configuration Settings" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: theme.colors.text, children: [_jsx(Text, { bold: true, children: "Active Configuration Source:" }), ' ', configSource === 'local'
+                                    ? 'Workspace Local'
+                                    : configSource === 'global'
+                                        ? 'Global Default'
+                                        : configSource === 'base'
+                                            ? 'SDK Base'
+                                            : 'Built-in Defaults'] }), activeConfigPath ? (_jsxs(Text, { color: theme.colors.textSecondary, children: [_jsx(Text, { bold: true, children: "Path:" }), " ", activeConfigPath] })) : (_jsx(Text, { color: theme.colors.textSecondary, children: "No configuration file found. Using defaults." }))] }), _jsxs(Box, { marginTop: 2, flexDirection: "column", children: [_jsx(Text, { color: theme.colors.textSecondary, children: _jsx(Text, { bold: true, children: "Hierarchy Info:" }) }), _jsxs(Text, { color: theme.colors.textSecondary, children: ["1. Workspace Local:", ' ', _jsx(Text, { color: theme.colors.text, children: path.join(process.cwd(), '.toolpack/config/toolpack.config.json') })] }), _jsxs(Text, { color: theme.colors.textSecondary, children: ["2. Global Default:", ' ', _jsx(Text, { color: theme.colors.text, children: path.join(os.homedir(), '.toolpack/config/toolpack.config.json') })] }), _jsxs(Text, { color: theme.colors.textSecondary, children: ["3. SDK Base:", ' ', _jsx(Text, { color: theme.colors.text, children: path.join(process.cwd(), 'toolpack.config.json') })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.colors.textSecondary, children: "Local settings override global, which override base settings." }) })] }), statusMsg && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.colors.success, children: statusMsg }) })), _jsx(Box, { marginTop: 2, children: _jsx(Text, { color: theme.colors.secondary, children: "[o] Open active config file \u2022 [q] or [esc] Back to home" }) })] }) }));
+}

package/dist/services/db.d.ts

@@ -0,0 +1,31 @@
+import Database from 'better-sqlite3';
+export interface Conversation {
+    id: string;
+    title: string;
+    mode?: string;
+    model?: string;
+    createdAt: number;
+}
+export interface ToolCallEntry {
+    id: string;
+    name: string;
+    arguments: Record<string, any>;
+    result?: string;
+    error?: string;
+    timestamp: number;
+    duration?: number;
+    status: 'pending' | 'success' | 'error';
+}
+export interface Message {
+    id: string;
+    conversationId: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    createdAt: number;
+    toolCalls?: ToolCallEntry[];
+}
+export declare function initDb(): Database.Database;
+export declare function createConversation(initialPrompt: string, mode?: string, model?: string): Conversation;
+export declare function getConversations(): Conversation[];
+export declare function getMessages(conversationId: string): Message[];
+export declare function saveMessage(conversationId: string, role: string, content: string, toolCalls?: ToolCallEntry[]): Message;

package/dist/services/db.js

@@ -0,0 +1,108 @@
+import Database from 'better-sqlite3';
+import { v4 as uuidv4 } from 'uuid';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+const DB_DIR = path.join(os.homedir(), '.toolpack', 'cli', 'db');
+const DB_PATH = path.join(DB_DIR, 'history.db');
+let db = null;
+export function initDb() {
+    if (db)
+        return db;
+    if (!fs.existsSync(DB_DIR)) {
+        fs.mkdirSync(DB_DIR, { recursive: true });
+    }
+    db = new Database(DB_PATH);
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS conversations (
+            id TEXT PRIMARY KEY,
+            title TEXT NOT NULL,
+            created_at INTEGER NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS messages (
+            id TEXT PRIMARY KEY,
+            conversation_id TEXT NOT NULL,
+            role TEXT NOT NULL,
+            content TEXT NOT NULL,
+            created_at INTEGER NOT NULL,
+            tool_calls TEXT,
+            FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+        );
+    `);
+    // Migration: Add tool_calls column if it doesn't exist
+    try {
+        db.exec('ALTER TABLE messages ADD COLUMN tool_calls TEXT');
+    }
+    catch (e) {
+        // Column already exists, ignore
+    }
+    // Migration: Add mode and model columns to conversations
+    try {
+        db.exec('ALTER TABLE conversations ADD COLUMN mode TEXT');
+    }
+    catch (e) {
+        // Column already exists, ignore
+    }
+    try {
+        db.exec('ALTER TABLE conversations ADD COLUMN model TEXT');
+    }
+    catch (e) {
+        // Column already exists, ignore
+    }
+    // Enable WAL mode for better performance
+    db.pragma('journal_mode = WAL');
+    return db;
+}
+export function createConversation(initialPrompt, mode, model) {
+    const database = initDb();
+    const id = uuidv4();
+    // Use first 15 chars for the title
+    let title = initialPrompt.trim();
+    if (title.length > 15) {
+        title = title.substring(0, 15) + '...';
+    }
+    const conversation = {
+        id,
+        title,
+        mode,
+        model,
+        createdAt: Date.now(),
+    };
+    const stmt = database.prepare('INSERT INTO conversations (id, title, mode, model, created_at) VALUES (?, ?, ?, ?, ?)');
+    stmt.run(conversation.id, conversation.title, conversation.mode || null, conversation.model || null, conversation.createdAt);
+    return conversation;
+}
+export function getConversations() {
+    const database = initDb();
+    const stmt = database.prepare('SELECT id, title, mode, model, created_at as createdAt FROM conversations ORDER BY created_at DESC');
+    return stmt.all();
+}
+export function getMessages(conversationId) {
+    const database = initDb();
+    const stmt = database.prepare('SELECT id, conversation_id as conversationId, role, content, created_at as createdAt, tool_calls as toolCallsJson FROM messages WHERE conversation_id = ? ORDER BY created_at ASC');
+    const rows = stmt.all(conversationId);
+    return rows.map(row => ({
+        id: row.id,
+        conversationId: row.conversationId,
+        role: row.role,
+        content: row.content,
+        createdAt: row.createdAt,
+        toolCalls: row.toolCallsJson ? JSON.parse(row.toolCallsJson) : undefined,
+    }));
+}
+export function saveMessage(conversationId, role, content, toolCalls) {
+    const database = initDb();
+    const message = {
+        id: uuidv4(),
+        conversationId,
+        role: role,
+        content,
+        createdAt: Date.now(),
+        toolCalls,
+    };
+    const toolCallsJson = toolCalls ? JSON.stringify(toolCalls) : null;
+    const stmt = database.prepare('INSERT INTO messages (id, conversation_id, role, content, created_at, tool_calls) VALUES (?, ?, ?, ?, ?, ?)');
+    stmt.run(message.id, message.conversationId, message.role, message.content, message.createdAt, toolCallsJson);
+    return message;
+}

package/dist/theme/ThemeContext.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { Theme } from './theme.js';
+interface ThemeContextType {
+    theme: Theme;
+    setTheme: (name: string) => void;
+}
+export declare function ThemeProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useTheme(): ThemeContextType;
+export {};

package/dist/theme/ThemeContext.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect } from 'react';
+import { themes } from './theme.js';
+const ThemeContext = createContext(undefined);
+export function ThemeProvider({ children }) {
+    const [activeTheme, setActiveTheme] = useState(themes['modern']);
+    // Update the native terminal background globally to match the theme
+    useEffect(() => {
+        if (activeTheme?.colors?.bg) {
+            // OSC 11 sets the terminal background color
+            process.stdout.write(`\x1b]11;${activeTheme.colors.bg}\x07`);
+        }
+        return () => {
+            // OSC 111 resets the terminal background color
+            process.stdout.write('\x1b]111\x07');
+        };
+    }, [activeTheme]);
+    const setTheme = (name) => {
+        if (themes[name]) {
+            setActiveTheme(themes[name]);
+        }
+    };
+    return (_jsx(ThemeContext.Provider, { value: { theme: activeTheme, setTheme }, children: children }));
+}
+export function useTheme() {
+    const context = useContext(ThemeContext);
+    if (!context) {
+        throw new Error('useTheme must be used within a ThemeProvider');
+    }
+    return context;
+}

package/dist/theme/theme.d.ts

@@ -0,0 +1,17 @@
+export interface Theme {
+    name: string;
+    colors: {
+        bg: string;
+        border: string;
+        primary: string;
+        secondary: string;
+        text: string;
+        textSecondary: string;
+        textMuted: string;
+        highlight: string;
+        success: string;
+        error: string;
+        inputBg: string;
+    };
+}
+export declare const themes: Record<string, Theme>;