@nanocollective/nanocoder/dist/hooks/useModeHandlers.js

A local-first CLI coding agent that brings the power of agentic coding tools like Claude Code and Gemini CLI to local models or controlled APIs like OpenRouter

import { jsx as _jsx } from "react/jsx-runtime";
import { createLLMClient } from '../client-factory.js';
import { ErrorMessage, SuccessMessage } from '../components/message-box.js';
import { reloadAppConfig } from '../config/index.js';
import { loadPreferences, updateLastUsed } from '../config/preferences.js';
import { getToolManager } from '../message-handler.js';
export function useModeHandlers({ client, currentModel, currentProvider, setClient, setCurrentModel, setCurrentProvider, setMessages, setActiveMode, setIsSettingsMode, addToChatQueue, getNextComponentKey, reinitializeMCPServers, }) {
    // Generic enter/exit helpers
    const enterMode = (mode) => setActiveMode(mode);
    const exitMode = () => setActiveMode(null);
    // Handle model selection
    const handleModelSelect = async (selectedModel) => {
        if (client && selectedModel !== currentModel) {
            client.setModel(selectedModel);
            setCurrentModel(selectedModel);
            // Clear message history when switching models
            setMessages([]);
            await client.clearContext();
            // Update preferences
            updateLastUsed(currentProvider, selectedModel);
            addToChatQueue(_jsx(SuccessMessage, { message: `Model changed to: ${selectedModel}. Chat history cleared.`, hideBox: true }, `model-changed-${getNextComponentKey()}`));
        }
        exitMode();
    };
    // Handle provider selection
    const handleProviderSelect = async (selectedProvider) => {
        if (selectedProvider !== currentProvider) {
            try {
                const { client: newClient, actualProvider } = await createLLMClient(selectedProvider);
                if (actualProvider !== selectedProvider) {
                    addToChatQueue(_jsx(ErrorMessage, { message: `${selectedProvider} is not available. Please ensure it's properly configured in agents.config.json.`, hideBox: true }, `provider-forced-${getNextComponentKey()}`));
                    return;
                }
                setClient(newClient);
                setCurrentProvider(actualProvider);
                const newModel = newClient.getCurrentModel();
                setCurrentModel(newModel);
                setMessages([]);
                await newClient.clearContext();
                updateLastUsed(actualProvider, newModel);
                addToChatQueue(_jsx(SuccessMessage, { message: `Provider changed to: ${actualProvider}, model: ${newModel}. Chat history cleared.`, hideBox: true }, `provider-changed-${getNextComponentKey()}`));
            }
            catch (error) {
                addToChatQueue(_jsx(ErrorMessage, { message: `Failed to change provider to ${selectedProvider}: ${String(error)}`, hideBox: true }, `provider-error-${getNextComponentKey()}`));
            }
        }
        exitMode();
    };
    // Handle config wizard complete - reinitializes client and MCP servers
    const handleConfigWizardComplete = async (configPath) => {
        exitMode();
        if (configPath) {
            addToChatQueue(_jsx(SuccessMessage, { message: `Configuration saved to: ${configPath}.`, hideBox: true }, `config-wizard-complete-${getNextComponentKey()}`));
            reloadAppConfig();
            try {
                const preferences = loadPreferences();
                const { client: newClient, actualProvider } = await createLLMClient(preferences.lastProvider);
                setClient(newClient);
                setCurrentProvider(actualProvider);
                const newModel = newClient.getCurrentModel();
                setCurrentModel(newModel);
                setMessages([]);
                await newClient.clearContext();
                const toolManager = getToolManager();
                if (toolManager) {
                    try {
                        await reinitializeMCPServers(toolManager);
                        addToChatQueue(_jsx(SuccessMessage, { message: "MCP servers reinitialized with new configuration.", hideBox: true }, `mcp-reinit-${getNextComponentKey()}`));
                    }
                    catch (mcpError) {
                        addToChatQueue(_jsx(ErrorMessage, { message: `Failed to reinitialize MCP servers: ${String(mcpError)}`, hideBox: true }, `mcp-reinit-error-${getNextComponentKey()}`));
                    }
                }
                addToChatQueue(_jsx(SuccessMessage, { message: `Ready! Using provider: ${actualProvider}, model: ${newModel}`, hideBox: true }, `config-init-${getNextComponentKey()}`));
            }
            catch (error) {
                addToChatQueue(_jsx(ErrorMessage, { message: `Failed to initialize with new configuration: ${String(error)}`, hideBox: true }, `config-init-error-${getNextComponentKey()}`));
            }
        }
    };
    // Handle MCP wizard complete - reinitializes MCP servers
    const handleMcpWizardComplete = async (configPath) => {
        exitMode();
        if (configPath) {
            addToChatQueue(_jsx(SuccessMessage, { message: `MCP configuration saved to: ${configPath}.`, hideBox: true }, `mcp-wizard-complete-${getNextComponentKey()}`));
            reloadAppConfig();
            const toolManager = getToolManager();
            if (toolManager) {
                try {
                    await reinitializeMCPServers(toolManager);
                    addToChatQueue(_jsx(SuccessMessage, { message: "MCP servers reinitialized with new configuration.", hideBox: true }, `mcp-reinit-${getNextComponentKey()}`));
                }
                catch (mcpError) {
                    addToChatQueue(_jsx(ErrorMessage, { message: `Failed to reinitialize MCP servers: ${String(mcpError)}`, hideBox: true }, `mcp-reinit-error-${getNextComponentKey()}`));
                }
            }
        }
    };
    return {
        enterMode,
        exitMode,
        // Convenience enter helpers
        enterModelSelectionMode: () => enterMode('model'),
        enterProviderSelectionMode: () => enterMode('provider'),
        enterModelDatabaseMode: () => enterMode('modelDatabase'),
        enterConfigWizardMode: () => enterMode('configWizard'),
        enterMcpWizardMode: () => enterMode('mcpWizard'),
        enterExplorerMode: () => enterMode('explorer'),
        enterIdeSelectionMode: () => enterMode('ideSelection'),
        enterSettingsMode: () => setIsSettingsMode(true),
        // Cancel/complete handlers
        handleModelSelect,
        handleModelSelectionCancel: exitMode,
        handleProviderSelect,
        handleProviderSelectionCancel: exitMode,
        handleModelDatabaseCancel: exitMode,
        handleConfigWizardComplete,
        handleConfigWizardCancel: exitMode,
        handleMcpWizardComplete,
        handleMcpWizardCancel: exitMode,
        handleSettingsCancel: () => setIsSettingsMode(false),
        handleExplorerCancel: exitMode,
        handleIdeSelectionCancel: exitMode,
    };
}
//# sourceMappingURL=useModeHandlers.js.map