@nanocollective/nanocoder 1.17.3 → 1.19.0

package/dist/app.js

@@ -1,42 +1,105 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { Box, Text, useApp } from 'ink';
-import WelcomeMessage from './components/welcome-message.js';
-import React from 'react';
-import { getThemeColors } from './config/themes.js';
-import { ThemeContext } from './hooks/useTheme.js';
-import UserInput from './components/user-input.js';
-import Status from './components/status.js';
+import { ModelDatabaseDisplay } from './commands/model-database.js';
+import BashExecutionIndicator from './components/bash-execution-indicator.js';
+import CancellingIndicator from './components/cancelling-indicator.js';
 import ChatQueue from './components/chat-queue.js';
+import CheckpointSelector from './components/checkpoint-selector.js';
+import ErrorMessage from './components/error-message.js';
 import ModelSelector from './components/model-selector.js';
 import ProviderSelector from './components/provider-selector.js';
+import SecurityDisclaimer from './components/security-disclaimer.js';
+import Status from './components/status.js';
+import SuccessMessage from './components/success-message.js';
 import ThemeSelector from './components/theme-selector.js';
-import ThinkingIndicator from './components/thinking-indicator.js';
-import CancellingIndicator from './components/cancelling-indicator.js';
 import ToolConfirmation from './components/tool-confirmation.js';
 import ToolExecutionIndicator from './components/tool-execution-indicator.js';
-import BashExecutionIndicator from './components/bash-execution-indicator.js';
-import { setGlobalMessageQueue } from './utils/message-queue.js';
-import Spinner from 'ink-spinner';
-import SecurityDisclaimer from './components/security-disclaimer.js';
-import { RecommendationsDisplay } from './commands/recommendations.js';
-import { ConfigWizard } from './wizard/config-wizard.js';
+import UserInput from './components/user-input.js';
 import { VSCodeExtensionPrompt, shouldPromptExtensionInstall, } from './components/vscode-extension-prompt.js';
+import WarningMessage from './components/warning-message.js';
+import WelcomeMessage from './components/welcome-message.js';
+import { getThemeColors } from './config/themes.js';
+import { setCurrentMode as setCurrentModeContext } from './context/mode-context.js';
+import { ThemeContext } from './hooks/useTheme.js';
+import { CheckpointManager } from './services/checkpoint-manager.js';
+import { generateCorrelationId, withNewCorrelationContext, } from './utils/logging/index.js';
+import { addToMessageQueue, setGlobalMessageQueue } from './utils/message-queue.js';
+import { ConfigWizard } from './wizard/config-wizard.js';
+import { Box, Text, useApp } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect, useMemo } from 'react';
+import { createClearMessagesHandler, handleMessageSubmission, } from './app/utils/appUtils.js';
+import { useAppInitialization } from './hooks/useAppInitialization.js';
 // Import extracted hooks and utilities
 import { useAppState } from './hooks/useAppState.js';
 import { useChatHandler } from './hooks/useChatHandler.js';
-import { useToolHandler } from './hooks/useToolHandler.js';
-import { useModeHandlers } from './hooks/useModeHandlers.js';
-import { useAppInitialization } from './hooks/useAppInitialization.js';
 import { useDirectoryTrust } from './hooks/useDirectoryTrust.js';
+import { useModeHandlers } from './hooks/useModeHandlers.js';
+import { useToolHandler } from './hooks/useToolHandler.js';
 import { useVSCodeServer } from './hooks/useVSCodeServer.js';
-import { createClearMessagesHandler, handleMessageSubmission, } from './app/utils/appUtils.js';
 // Provide shared UI state to components
 import { UIStateProvider } from './hooks/useUIState.js';
-export default function App({ vscodeMode = false, vscodePort }) {
+import { createPinoLogger } from './utils/logging/pino-logger.js';
+export function shouldRenderWelcome(nonInteractiveMode) {
+    return !nonInteractiveMode;
+}
+/**
+ * Helper function to determine if non-interactive mode processing is complete
+ */
+export function isNonInteractiveModeComplete(appState, startTime, maxExecutionTimeMs) {
+    const isComplete = !appState.isToolExecuting &&
+        !appState.isBashExecuting &&
+        !appState.isToolConfirmationMode;
+    const _hasMessages = appState.messages.length > 0;
+    const hasTimedOut = Date.now() - startTime > maxExecutionTimeMs;
+    // Check for error messages in the messages array
+    const hasErrorMessages = appState.messages.some((message) => message.role === 'error' ||
+        (typeof message.content === 'string' &&
+            message.content.toLowerCase().includes('error')));
+    // Check for tool approval required messages
+    const hasToolApprovalRequired = appState.messages.some((message) => typeof message.content === 'string' &&
+        message.content.includes('Tool approval required'));
+    if (hasTimedOut) {
+        return { shouldExit: true, reason: 'timeout' };
+    }
+    if (hasToolApprovalRequired) {
+        return { shouldExit: true, reason: 'tool-approval' };
+    }
+    if (hasErrorMessages) {
+        return { shouldExit: true, reason: 'error' };
+    }
+    // Exit when conversation is complete and either:
+    // - We have messages in history (for chat/bash commands), OR
+    // - Conversation is marked complete (for display-only commands like /mcp)
+    if (isComplete && appState.isConversationComplete) {
+        return { shouldExit: true, reason: 'complete' };
+    }
+    return { shouldExit: false, reason: null };
+}
+export default function App({ vscodeMode = false, vscodePort, nonInteractivePrompt, nonInteractiveMode = false, loggingConfig = {}, }) {
+    // Memoize the logger to prevent recreation on every render
+    const logger = useMemo(() => createPinoLogger(undefined, loggingConfig), [loggingConfig]);
+    // Log application startup with key configuration
+    React.useEffect(() => {
+        logger.info('Nanocoder application starting', {
+            vscodeMode,
+            vscodePort,
+            nodeEnv: process.env.NODE_ENV || 'development',
+            platform: process.platform,
+            pid: process.pid,
+        });
+    }, [logger, vscodeMode, vscodePort]);
     // Use extracted hooks
     const appState = useAppState();
     const { exit } = useApp();
     const { isTrusted, handleConfirmTrust, isTrustLoading, isTrustedError } = useDirectoryTrust();
+    // Sync global mode context whenever development mode changes
+    React.useEffect(() => {
+        setCurrentModeContext(appState.developmentMode);
+        logger.info('Development mode changed', {
+            newMode: appState.developmentMode,
+            previousMode: undefined, // Could track previous state if needed
+        });
+    }, [appState.developmentMode, logger]);
     // VS Code extension installation prompt state
     const [showExtensionPrompt, setShowExtensionPrompt] = React.useState(() => vscodeMode && shouldPromptExtensionInstall());
     const [extensionPromptComplete, setExtensionPromptComplete] = React.useState(false);
@@ -45,6 +108,15 @@ export default function App({ vscodeMode = false, vscodePort }) {
     };
     // VS Code server integration - handles prompts from VS Code extension
     const handleVSCodePrompt = React.useCallback((prompt, context) => {
+        const correlationId = generateCorrelationId();
+        logger.info('VS Code prompt received', {
+            promptLength: prompt.length,
+            hasContext: !!context,
+            filePath: context?.filePath,
+            hasSelection: !!context?.selection,
+            cursorPosition: context?.cursorPosition,
+            correlationId,
+        });
         // Build enhanced prompt with context if available
         let enhancedPrompt = prompt;
         if (context?.filePath) {
@@ -52,8 +124,11 @@ export default function App({ vscodeMode = false, vscodePort }) {
         }
         // This will be connected to chat handler after initialization
         // For now, store it for processing
-        console.log('VS Code prompt received:', enhancedPrompt);
-    }, []);
+        logger.debug('VS Code enhanced prompt prepared', {
+            enhancedPromptLength: enhancedPrompt.length,
+            correlationId,
+        });
+    }, [logger]);
     // Setup VS Code server (returns connection status and methods)
     // The server handles prompts via callback and exposes methods for sending messages
     const _vsCodeServer = useVSCodeServer({
@@ -72,21 +147,58 @@ export default function App({ vscodeMode = false, vscodePort }) {
     // Initialize global message queue on component mount
     React.useEffect(() => {
         setGlobalMessageQueue(appState.addToChatQueue);
-    }, [appState.addToChatQueue]);
+        logger.debug('Global message queue initialized', {
+            chatQueueFunction: 'addToChatQueue',
+        });
+    }, [appState.addToChatQueue, logger]);
+    // Log important application state changes
+    React.useEffect(() => {
+        if (appState.client) {
+            logger.info('AI client initialized', {
+                provider: appState.currentProvider,
+                model: appState.currentModel,
+                hasToolManager: !!appState.toolManager,
+            });
+        }
+    }, [
+        appState.client,
+        appState.currentProvider,
+        appState.currentModel,
+        appState.toolManager,
+        logger,
+    ]);
+    React.useEffect(() => {
+        if (appState.mcpInitialized) {
+            logger.info('MCP servers initialized', {
+                serverCount: appState.mcpServersStatus?.length || 0,
+                status: 'connected',
+            });
+        }
+    }, [appState.mcpInitialized, appState.mcpServersStatus, logger]);
+    React.useEffect(() => {
+        if (appState.updateInfo) {
+            logger.info('Update information available', {
+                hasUpdate: appState.updateInfo.hasUpdate,
+                currentVersion: appState.updateInfo.currentVersion,
+                latestVersion: appState.updateInfo.latestVersion,
+            });
+        }
+    }, [appState.updateInfo, logger]);
     // Setup chat handler
     const chatHandler = useChatHandler({
         client: appState.client,
         toolManager: appState.toolManager,
         messages: appState.messages,
         setMessages: appState.updateMessages,
+        currentProvider: appState.currentProvider,
         currentModel: appState.currentModel,
-        setIsThinking: appState.setIsThinking,
         setIsCancelling: appState.setIsCancelling,
         addToChatQueue: appState.addToChatQueue,
         componentKeyCounter: appState.componentKeyCounter,
         abortController: appState.abortController,
         setAbortController: appState.setAbortController,
         developmentMode: appState.developmentMode,
+        nonInteractiveMode,
         onStartToolConfirmationFlow: (toolCalls, updatedMessages, assistantMsg, systemMessage) => {
             appState.setPendingToolCalls(toolCalls);
             appState.setCurrentToolIndex(0);
@@ -98,6 +210,10 @@ export default function App({ vscodeMode = false, vscodePort }) {
             });
             appState.setIsToolConfirmationMode(true);
         },
+        onConversationComplete: () => {
+            // Signal that the conversation has completed
+            appState.setIsConversationComplete(true);
+        },
     });
     // Setup tool handler
     const toolHandler = useToolHandler({
@@ -120,6 +236,43 @@ export default function App({ vscodeMode = false, vscodePort }) {
         currentProvider: appState.currentProvider,
         setDevelopmentMode: appState.setDevelopmentMode,
     });
+    // Log when application is fully ready and interface is active
+    useEffect(() => {
+        // Only log when we have a fully initialized application ready for user interaction
+        if (appState.mcpInitialized &&
+            appState.client &&
+            !appState.isToolExecuting &&
+            !appState.isToolConfirmationMode &&
+            !appState.isConfigWizardMode &&
+            appState.pendingToolCalls.length === 0) {
+            const correlationId = generateCorrelationId();
+            withNewCorrelationContext(() => {
+                logger.info('Application interface ready for user interaction', {
+                    correlationId,
+                    interfaceState: {
+                        developmentMode: appState.developmentMode,
+                        hasPendingToolCalls: appState.pendingToolCalls.length > 0,
+                        clientInitialized: !!appState.client,
+                        mcpServersConnected: appState.mcpInitialized,
+                        inputDisabled: chatHandler.isStreaming ||
+                            appState.isToolExecuting ||
+                            appState.isBashExecuting,
+                    },
+                });
+            }, correlationId);
+        }
+    }, [
+        appState.mcpInitialized,
+        appState.client,
+        appState.isToolExecuting,
+        appState.isToolConfirmationMode,
+        appState.isConfigWizardMode,
+        appState.pendingToolCalls.length,
+        logger,
+        appState.developmentMode,
+        chatHandler.isStreaming,
+        appState.isBashExecuting,
+    ]);
     // Setup initialization
     const appInitialization = useAppInitialization({
         setClient: appState.setClient,
@@ -132,6 +285,10 @@ export default function App({ vscodeMode = false, vscodePort }) {
         setStartChat: appState.setStartChat,
         setMcpInitialized: appState.setMcpInitialized,
         setUpdateInfo: appState.setUpdateInfo,
+        setMcpServersStatus: appState.setMcpServersStatus,
+        setLspServersStatus: appState.setLspServersStatus,
+        setPreferencesLoaded: appState.setPreferencesLoaded,
+        setCustomCommandsCount: appState.setCustomCommandsCount,
         addToChatQueue: appState.addToChatQueue,
         componentKeyCounter: appState.componentKeyCounter,
         customCommandCache: appState.customCommandCache,
@@ -151,7 +308,7 @@ export default function App({ vscodeMode = false, vscodePort }) {
         setIsModelSelectionMode: appState.setIsModelSelectionMode,
         setIsProviderSelectionMode: appState.setIsProviderSelectionMode,
         setIsThemeSelectionMode: appState.setIsThemeSelectionMode,
-        setIsRecommendationsMode: appState.setIsRecommendationsMode,
+        setIsModelDatabaseMode: appState.setIsModelDatabaseMode,
         setIsConfigWizardMode: appState.setIsConfigWizardMode,
         addToChatQueue: appState.addToChatQueue,
         componentKeyCounter: appState.componentKeyCounter,
@@ -161,10 +318,17 @@ export default function App({ vscodeMode = false, vscodePort }) {
     const clearMessages = React.useMemo(() => createClearMessagesHandler(appState.updateMessages, appState.client), [appState.updateMessages, appState.client]);
     const handleCancel = React.useCallback(() => {
         if (appState.abortController) {
+            logger.info('Cancelling current operation', {
+                operation: 'user_cancellation',
+                hasAbortController: !!appState.abortController,
+            });
             appState.setIsCancelling(true);
             appState.abortController.abort();
         }
-    }, [appState]);
+        else {
+            logger.debug('Cancel requested but no active operation to cancel');
+        }
+    }, [appState, logger]);
     const handleToggleDevelopmentMode = React.useCallback(() => {
         appState.setDevelopmentMode(currentMode => {
             const modes = [
@@ -174,13 +338,64 @@ export default function App({ vscodeMode = false, vscodePort }) {
             ];
             const currentIndex = modes.indexOf(currentMode);
             const nextIndex = (currentIndex + 1) % modes.length;
-            return modes[nextIndex];
+            const nextMode = modes[nextIndex];
+            logger.info('Development mode toggled', {
+                previousMode: currentMode,
+                nextMode,
+                modeIndex: nextIndex,
+                totalModes: modes.length,
+            });
+            // Sync global mode context for tool needsApproval logic
+            setCurrentModeContext(nextMode);
+            return nextMode;
         });
-    }, [appState]);
+    }, [appState, logger]);
     const handleShowStatus = React.useCallback(() => {
-        appState.addToChatQueue(_jsx(Status, { provider: appState.currentProvider, model: appState.currentModel, theme: appState.currentTheme, updateInfo: appState.updateInfo }, `status-${appState.componentKeyCounter}`));
+        logger.debug('Status display requested', {
+            currentProvider: appState.currentProvider,
+            currentModel: appState.currentModel,
+            currentTheme: appState.currentTheme,
+            componentKeyCounter: appState.componentKeyCounter,
+        });
+        appState.addToChatQueue(_jsx(Status, { provider: appState.currentProvider, model: appState.currentModel, theme: appState.currentTheme, updateInfo: appState.updateInfo, mcpServersStatus: appState.mcpServersStatus, lspServersStatus: appState.lspServersStatus, preferencesLoaded: appState.preferencesLoaded, customCommandsCount: appState.customCommandsCount }, `status-${appState.componentKeyCounter}`));
+    }, [appState, logger]);
+    // Checkpoint selection handlers
+    const handleCheckpointSelect = React.useCallback(async (checkpointName, createBackup) => {
+        try {
+            const manager = new CheckpointManager();
+            if (createBackup) {
+                try {
+                    await manager.saveCheckpoint(`backup-${new Date().toISOString().replace(/[:.]/g, '-')}`, appState.messages, appState.currentProvider, appState.currentModel);
+                }
+                catch (error) {
+                    addToMessageQueue(_jsx(WarningMessage, { message: `Warning: Failed to create backup: ${error instanceof Error ? error.message : 'Unknown error'}`, hideBox: true }, `backup-warning-${Date.now()}`));
+                }
+            }
+            const checkpointData = await manager.loadCheckpoint(checkpointName, {
+                validateIntegrity: true,
+            });
+            await manager.restoreFiles(checkpointData);
+            addToMessageQueue(_jsx(SuccessMessage, { message: `✓ Checkpoint '${checkpointName}' restored successfully`, hideBox: true }, `restore-success-${Date.now()}`));
+        }
+        catch (error) {
+            addToMessageQueue(_jsx(ErrorMessage, { message: `Failed to restore checkpoint: ${error instanceof Error ? error.message : 'Unknown error'}`, hideBox: true }, `restore-error-${Date.now()}`));
+        }
+        finally {
+            appState.setIsCheckpointLoadMode(false);
+            appState.setCheckpointLoadData(null);
+        }
+    }, [appState]);
+    const handleCheckpointCancel = React.useCallback(() => {
+        appState.setIsCheckpointLoadMode(false);
+        appState.setCheckpointLoadData(null);
+    }, [appState]);
+    const enterCheckpointLoadMode = React.useCallback((checkpoints, currentMessageCount) => {
+        appState.setCheckpointLoadData({ checkpoints, currentMessageCount });
+        appState.setIsCheckpointLoadMode(true);
     }, [appState]);
     const handleMessageSubmit = React.useCallback(async (message) => {
+        // Reset conversation completion flag when starting a new message
+        appState.setIsConversationComplete(false);
         await handleMessageSubmission(message, {
             customCommandCache: appState.customCommandCache,
             customCommandLoader: appState.customCommandLoader,
@@ -189,11 +404,13 @@ export default function App({ vscodeMode = false, vscodePort }) {
             onEnterModelSelectionMode: modeHandlers.enterModelSelectionMode,
             onEnterProviderSelectionMode: modeHandlers.enterProviderSelectionMode,
             onEnterThemeSelectionMode: modeHandlers.enterThemeSelectionMode,
-            onEnterRecommendationsMode: modeHandlers.enterRecommendationsMode,
+            onEnterModelDatabaseMode: modeHandlers.enterModelDatabaseMode,
             onEnterConfigWizardMode: modeHandlers.enterConfigWizardMode,
+            onEnterCheckpointLoadMode: enterCheckpointLoadMode,
             onShowStatus: handleShowStatus,
             onHandleChatMessage: chatHandler.handleChatMessage,
             onAddToChatQueue: appState.addToChatQueue,
+            onCommandComplete: () => appState.setIsConversationComplete(true),
             componentKeyCounter: appState.componentKeyCounter,
             setMessages: appState.updateMessages,
             messages: appState.messages,
@@ -206,66 +423,165 @@ export default function App({ vscodeMode = false, vscodePort }) {
             getMessageTokens: appState.getMessageTokens,
         });
     }, [
-        appState.customCommandCache,
-        appState.customCommandLoader,
-        appState.customCommandExecutor,
+        appState,
         clearMessages,
         modeHandlers.enterModelSelectionMode,
         modeHandlers.enterProviderSelectionMode,
         modeHandlers.enterThemeSelectionMode,
-        modeHandlers.enterRecommendationsMode,
+        modeHandlers.enterModelDatabaseMode,
         modeHandlers.enterConfigWizardMode,
+        enterCheckpointLoadMode,
         handleShowStatus,
         chatHandler.handleChatMessage,
-        appState.addToChatQueue,
-        appState.componentKeyCounter,
-        appState.updateMessages,
-        appState.messages,
-        appState.setIsBashExecuting,
-        appState.setCurrentBashCommand,
-        appState.currentProvider,
-        appState.currentModel,
-        appState.currentTheme,
-        appState.updateInfo,
-        appState.getMessageTokens,
     ]);
+    // Handle non-interactive mode - automatically submit prompt and exit when done
+    const [nonInteractiveSubmitted, setNonInteractiveSubmitted] = React.useState(false);
+    React.useEffect(() => {
+        if (nonInteractivePrompt &&
+            appState.mcpInitialized &&
+            appState.client &&
+            !nonInteractiveSubmitted) {
+            setNonInteractiveSubmitted(true);
+            // Set auto-accept mode for non-interactive execution
+            appState.setDevelopmentMode('auto-accept');
+            // Submit the prompt
+            void handleMessageSubmit(nonInteractivePrompt);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        nonInteractivePrompt,
+        appState.mcpInitialized,
+        appState.client,
+        nonInteractiveSubmitted,
+        handleMessageSubmit,
+        appState.setDevelopmentMode,
+    ]);
+    // Exit in non-interactive mode when all processing is complete
+    const OUTPUT_FLUSH_DELAY_MS = 1000;
+    const MAX_EXECUTION_TIME_MS = 300000; // 5 minutes
+    const [startTime] = React.useState(Date.now());
+    React.useEffect(() => {
+        if (nonInteractivePrompt && nonInteractiveSubmitted) {
+            const { shouldExit, reason } = isNonInteractiveModeComplete(appState, startTime, MAX_EXECUTION_TIME_MS);
+            if (shouldExit) {
+                if (reason === 'timeout') {
+                    console.error('Non-interactive mode timed out');
+                }
+                else if (reason === 'error') {
+                    console.error('Non-interactive mode encountered errors');
+                }
+                else if (reason === 'tool-approval') {
+                    // Exit with error code when tool approval is required
+                    // Error message already printed by useChatHandler
+                }
+                // Wait a bit to ensure all output is flushed
+                const timer = setTimeout(() => {
+                    process.exit(reason === 'error' || reason === 'tool-approval' ? 1 : 0);
+                }, OUTPUT_FLUSH_DELAY_MS);
+                return () => clearTimeout(timer);
+            }
+        }
+    }, [nonInteractivePrompt, nonInteractiveSubmitted, appState, startTime]);
+    const shouldShowWelcome = shouldRenderWelcome(nonInteractiveMode);
+    const pendingToolCallCount = appState.pendingToolCalls.length;
+    const nonInteractiveLoadingMessage = React.useMemo(() => {
+        if (!nonInteractivePrompt) {
+            return null;
+        }
+        // Don't show loading message when conversation is complete (about to exit)
+        if (appState.isConversationComplete) {
+            return null;
+        }
+        if (!appState.mcpInitialized || !appState.client) {
+            return 'Waiting for MCP servers...';
+        }
+        if (appState.isToolExecuting ||
+            appState.isToolConfirmationMode ||
+            pendingToolCallCount > 0) {
+            return 'Waiting for tooling...';
+        }
+        if (appState.isBashExecuting) {
+            return 'Waiting for bash execution...';
+        }
+        return 'Waiting for chat to complete...';
+    }, [
+        nonInteractivePrompt,
+        appState.isConversationComplete,
+        appState.mcpInitialized,
+        appState.client,
+        appState.isToolExecuting,
+        appState.isToolConfirmationMode,
+        pendingToolCallCount,
+        appState.isBashExecuting,
+    ]);
+    const loadingLabel = nonInteractivePrompt
+        ? (nonInteractiveLoadingMessage ?? 'Loading...')
+        : 'Loading...';
     // Memoize static components to prevent unnecessary re-renders
-    const staticComponents = React.useMemo(() => [
-        _jsx(WelcomeMessage, {}, "welcome"),
-        _jsx(Status, { provider: appState.currentProvider, model: appState.currentModel, theme: appState.currentTheme, updateInfo: appState.updateInfo }, "status"),
-    ], [
+    const staticComponents = React.useMemo(() => {
+        const components = [];
+        if (shouldShowWelcome) {
+            components.push(_jsx(WelcomeMessage, {}, "welcome"));
+        }
+        components.push(_jsx(Status, { provider: appState.currentProvider, model: appState.currentModel, theme: appState.currentTheme, updateInfo: appState.updateInfo, mcpServersStatus: appState.mcpServersStatus, lspServersStatus: appState.lspServersStatus, preferencesLoaded: appState.preferencesLoaded, customCommandsCount: appState.customCommandsCount }, "status"));
+        return components;
+    }, [
+        shouldShowWelcome,
         appState.currentProvider,
         appState.currentModel,
         appState.currentTheme,
         appState.updateInfo,
+        appState.mcpServersStatus,
+        appState.lspServersStatus,
+        appState.preferencesLoaded,
+        appState.customCommandsCount,
     ]);
     // Handle loading state for directory trust check
     if (isTrustLoading) {
-        return (_jsx(Box, { flexDirection: "column", padding: 1, children: _jsxs(Text, { color: themeContextValue.colors.secondary, children: [_jsx(Spinner, { type: "dots2" }), " Checking directory trust..."] }) }));
+        logger.debug('Directory trust check in progress');
+        return (_jsx(Box, { flexDirection: "column", padding: 1, children: _jsxs(Text, { color: themeContextValue.colors.secondary, children: [_jsx(Spinner, { type: "dots" }), " Checking directory trust..."] }) }));
     }
     // Handle error state for directory trust
     if (isTrustedError) {
+        logger.error('Directory trust check failed', {
+            error: isTrustedError,
+            suggestion: 'restart_application_or_check_permissions',
+        });
         return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: themeContextValue.colors.error, children: ["\u26A0\uFE0F Error checking directory trust: ", isTrustedError] }), _jsx(Text, { color: themeContextValue.colors.secondary, children: "Please restart the application or check your permissions." })] }));
     }
     // Show security disclaimer if directory is not trusted
     if (!isTrusted) {
+        logger.info('Directory not trusted, showing security disclaimer');
         return (_jsx(SecurityDisclaimer, { onConfirm: handleConfirmTrust, onExit: handleExit }));
     }
+    // Directory is trusted - application can proceed
+    logger.debug('Directory trusted, proceeding with application initialization');
     // Show VS Code extension installation prompt if needed
     if (showExtensionPrompt && !extensionPromptComplete) {
+        logger.info('Showing VS Code extension installation prompt', {
+            vscodeMode,
+            extensionPromptComplete,
+        });
         return (_jsx(ThemeContext.Provider, { value: themeContextValue, children: _jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(WelcomeMessage, {}), _jsx(VSCodeExtensionPrompt, { onComplete: () => {
+                            logger.info('VS Code extension prompt completed');
                             setShowExtensionPrompt(false);
                             setExtensionPromptComplete(true);
                         }, onSkip: () => {
+                            logger.info('VS Code extension prompt skipped');
                             setShowExtensionPrompt(false);
                             setExtensionPromptComplete(true);
                         } })] }) }));
     }
-    return (_jsx(ThemeContext.Provider, { value: themeContextValue, children: _jsx(UIStateProvider, { children: _jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { flexGrow: 1, flexDirection: "column", minHeight: 0, children: appState.startChat && (_jsx(ChatQueue, { staticComponents: staticComponents, queuedComponents: appState.chatComponents })) }), appState.startChat && (_jsxs(Box, { flexDirection: "column", marginLeft: -1, children: [appState.isCancelling ? (_jsx(CancellingIndicator, {})) : appState.isThinking && !chatHandler.isStreaming ? (_jsx(ThinkingIndicator, {})) : null, chatHandler.isStreaming && chatHandler.streamingContent && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: themeContextValue.colors.primary, bold: true, children: [appState.currentModel, ":"] }) }), _jsx(Text, { children: chatHandler.streamingContent })] })), appState.isModelSelectionMode ? (_jsx(ModelSelector, { client: appState.client, currentModel: appState.currentModel, onModelSelect: model => void modeHandlers.handleModelSelect(model), onCancel: modeHandlers.handleModelSelectionCancel })) : appState.isProviderSelectionMode ? (_jsx(ProviderSelector, { currentProvider: appState.currentProvider, onProviderSelect: provider => void modeHandlers.handleProviderSelect(provider), onCancel: modeHandlers.handleProviderSelectionCancel })) : appState.isThemeSelectionMode ? (_jsx(ThemeSelector, { onThemeSelect: modeHandlers.handleThemeSelect, onCancel: modeHandlers.handleThemeSelectionCancel })) : appState.isRecommendationsMode ? (_jsx(RecommendationsDisplay, { onCancel: modeHandlers.handleRecommendationsCancel })) : appState.isConfigWizardMode ? (_jsx(ConfigWizard, { projectDir: process.cwd(), onComplete: configPath => void modeHandlers.handleConfigWizardComplete(configPath), onCancel: modeHandlers.handleConfigWizardCancel })) : appState.isToolConfirmationMode &&
+    return (_jsx(ThemeContext.Provider, { value: themeContextValue, children: _jsx(UIStateProvider, { children: _jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { flexGrow: 1, flexDirection: "column", minHeight: 0, children: appState.startChat && (_jsx(ChatQueue, { staticComponents: staticComponents, queuedComponents: appState.chatComponents })) }), appState.startChat && (_jsxs(Box, { flexDirection: "column", marginLeft: -1, children: [appState.isCancelling && _jsx(CancellingIndicator, {}), chatHandler.isStreaming && chatHandler.streamingContent && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: themeContextValue.colors.primary, bold: true, children: [appState.currentModel, ":"] }) }), _jsx(Text, { children: chatHandler.streamingContent })] })), appState.isModelSelectionMode ? (_jsx(ModelSelector, { client: appState.client, currentModel: appState.currentModel, onModelSelect: model => void modeHandlers.handleModelSelect(model), onCancel: modeHandlers.handleModelSelectionCancel })) : appState.isProviderSelectionMode ? (_jsx(ProviderSelector, { currentProvider: appState.currentProvider, onProviderSelect: provider => void modeHandlers.handleProviderSelect(provider), onCancel: modeHandlers.handleProviderSelectionCancel })) : appState.isThemeSelectionMode ? (_jsx(ThemeSelector, { onThemeSelect: modeHandlers.handleThemeSelect, onCancel: modeHandlers.handleThemeSelectionCancel })) : appState.isModelDatabaseMode ? (_jsx(ModelDatabaseDisplay, { onCancel: modeHandlers.handleModelDatabaseCancel })) : appState.isConfigWizardMode ? (_jsx(ConfigWizard, { projectDir: process.cwd(), onComplete: configPath => void modeHandlers.handleConfigWizardComplete(configPath), onCancel: modeHandlers.handleConfigWizardCancel })) : appState.isCheckpointLoadMode &&
+                                appState.checkpointLoadData ? (_jsx(CheckpointSelector, { checkpoints: appState.checkpointLoadData.checkpoints, currentMessageCount: appState.checkpointLoadData.currentMessageCount, onSelect: (name, backup) => void handleCheckpointSelect(name, backup), onCancel: handleCheckpointCancel })) : appState.isToolConfirmationMode &&
                                 appState.pendingToolCalls[appState.currentToolIndex] ? (_jsx(ToolConfirmation, { toolCall: appState.pendingToolCalls[appState.currentToolIndex], onConfirm: toolHandler.handleToolConfirmation, onCancel: toolHandler.handleToolConfirmationCancel })) : appState.isToolExecuting &&
                                 appState.pendingToolCalls[appState.currentToolIndex] ? (_jsx(ToolExecutionIndicator, { toolName: appState.pendingToolCalls[appState.currentToolIndex]
-                                    .function.name, currentIndex: appState.currentToolIndex, totalTools: appState.pendingToolCalls.length })) : appState.isBashExecuting ? (_jsx(BashExecutionIndicator, { command: appState.currentBashCommand })) : appState.mcpInitialized && appState.client ? (_jsx(UserInput, { customCommands: Array.from(appState.customCommandCache.keys()), onSubmit: msg => void handleMessageSubmit(msg), disabled: appState.isThinking ||
+                                    .function.name, currentIndex: appState.currentToolIndex, totalTools: appState.pendingToolCalls.length })) : appState.isBashExecuting ? (_jsx(BashExecutionIndicator, { command: appState.currentBashCommand })) : appState.mcpInitialized &&
+                                appState.client &&
+                                !nonInteractivePrompt ? (_jsx(UserInput, { customCommands: Array.from(appState.customCommandCache.keys()), onSubmit: msg => void handleMessageSubmit(msg), disabled: chatHandler.isStreaming ||
                                     appState.isToolExecuting ||
-                                    appState.isBashExecuting, onCancel: handleCancel, onToggleMode: handleToggleDevelopmentMode, developmentMode: appState.developmentMode })) : appState.mcpInitialized && !appState.client ? (_jsx(_Fragment, {})) : (_jsxs(Text, { color: themeContextValue.colors.secondary, children: [_jsx(Spinner, { type: "dots2" }), " Loading..."] }))] }))] }) }) }));
+                                    appState.isBashExecuting, onCancel: handleCancel, onToggleMode: handleToggleDevelopmentMode, developmentMode: appState.developmentMode })) : appState.mcpInitialized && !appState.client ? (_jsx(_Fragment, {})) : nonInteractivePrompt && !nonInteractiveLoadingMessage ? (
+                            // Show completion message when non-interactive mode is done
+                            _jsx(Text, { color: themeContextValue.colors.secondary, children: "Completed. Exiting." })) : (_jsxs(Text, { color: themeContextValue.colors.secondary, children: [_jsx(Spinner, { type: "dots" }), " ", loadingLabel] }))] }))] }) }) }));
 }
 //# sourceMappingURL=app.js.map