snow-ai 0.4.8 → 0.4.10

package/dist/ui/pages/SystemPromptConfigScreen.js

@@ -5,8 +5,10 @@ import { Alert } from '@inkjs/ui';
 import TextInput from 'ink-text-input';
 import { getSystemPromptConfig, saveSystemPromptConfig, } from '../../utils/apiConfig.js';
 import { useI18n } from '../../i18n/index.js';
+import { useTheme } from '../contexts/ThemeContext.js';
 export default function SystemPromptConfigScreen({ onBack }) {
     const { t } = useI18n();
+    const { theme } = useTheme();
     const [config, setConfig] = useState(() => {
         return (getSystemPromptConfig() || {
             active: '',
@@ -231,26 +233,26 @@ export default function SystemPromptConfigScreen({ onBack }) {
     if (view === 'list') {
         const activePrompt = config.prompts.find(p => p.id === config.active);
         return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Box, { marginBottom: 1, borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1 },
+            React.createElement(Box, { marginBottom: 1, borderStyle: "round", borderColor: theme.colors.menuInfo, paddingX: 2, paddingY: 1 },
                 React.createElement(Box, { flexDirection: "column" },
                     React.createElement(Gradient, { name: "rainbow" }, t.systemPromptConfig.title),
-                    React.createElement(Text, { color: "gray", dimColor: true }, t.systemPromptConfig.subtitle))),
+                    React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, t.systemPromptConfig.subtitle))),
             error && (React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Alert, { variant: "error" }, error))),
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, { bold: true },
                     t.systemPromptConfig.activePrompt,
                     ' ',
-                    React.createElement(Text, { color: "green" }, activePrompt?.name || t.systemPromptConfig.none))),
+                    React.createElement(Text, { color: theme.colors.success }, activePrompt?.name || t.systemPromptConfig.none))),
             config.prompts.length === 0 ? (React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { color: "yellow" }, t.systemPromptConfig.noPromptsConfigured))) : (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
-                React.createElement(Text, { bold: true, color: "cyan" }, t.systemPromptConfig.availablePrompts),
+                React.createElement(Text, { color: theme.colors.warning }, t.systemPromptConfig.noPromptsConfigured))) : (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: theme.colors.menuInfo }, t.systemPromptConfig.availablePrompts),
                 config.prompts.map((prompt, index) => (React.createElement(Box, { key: prompt.id, marginLeft: 2 },
                     React.createElement(Text, { color: index === selectedIndex
-                            ? 'green'
+                            ? theme.colors.menuSelected
                             : prompt.id === config.active
-                                ? 'cyan'
-                                : 'white' },
+                                ? theme.colors.menuInfo
+                                : theme.colors.menuNormal },
                         index === selectedIndex ? '❯ ' : '  ',
                         prompt.id === config.active ? '✓ ' : '  ',
                         prompt.name,
@@ -260,8 +262,8 @@ export default function SystemPromptConfigScreen({ onBack }) {
                             prompt.content.substring(0, 50),
                             prompt.content.length > 50 ? '...' : '')))))))),
             React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { bold: true, color: "cyan" }, t.systemPromptConfig.actions)),
-            React.createElement(Box, { flexDirection: "column", marginBottom: 1, marginLeft: 2 }, actions.map(action => (React.createElement(Text, { key: action, color: currentAction === action ? 'green' : 'gray', bold: currentAction === action },
+                React.createElement(Text, { bold: true, color: theme.colors.menuInfo }, t.systemPromptConfig.actions)),
+            React.createElement(Box, { flexDirection: "column", marginBottom: 1, marginLeft: 2 }, actions.map(action => (React.createElement(Text, { key: action, color: currentAction === action ? theme.colors.menuSelected : theme.colors.menuSecondary, bold: currentAction === action },
                 currentAction === action ? '❯ ' : '  ',
                 action === 'activate' && t.systemPromptConfig.activate,
                 action === 'deactivate' && t.systemPromptConfig.deactivate,
@@ -270,12 +272,12 @@ export default function SystemPromptConfigScreen({ onBack }) {
                 action === 'add' && t.systemPromptConfig.addNew,
                 action === 'back' && t.systemPromptConfig.escBack)))),
             React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: "gray", dimColor: true }, t.systemPromptConfig.navigationHint))));
+                React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, t.systemPromptConfig.navigationHint))));
     }
     // Render add/edit view
     if (view === 'add' || view === 'edit') {
         return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Box, { marginBottom: 1, borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1 },
+            React.createElement(Box, { marginBottom: 1, borderStyle: "round", borderColor: theme.colors.menuInfo, paddingX: 2, paddingY: 1 },
                 React.createElement(Gradient, { name: "rainbow" }, view === 'add'
                     ? t.systemPromptConfig.addNewTitle
                     : t.systemPromptConfig.editTitle)),
@@ -284,27 +286,27 @@ export default function SystemPromptConfigScreen({ onBack }) {
             React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
                 React.createElement(Box, { marginBottom: 1 },
                     React.createElement(Box, { flexDirection: "column" },
-                        React.createElement(Text, { color: editingField === 'name' ? 'green' : 'white' },
+                        React.createElement(Text, { color: editingField === 'name' ? theme.colors.menuSelected : theme.colors.menuNormal },
                             editingField === 'name' ? '❯ ' : '  ',
                             t.systemPromptConfig.nameLabel),
                         editingField === 'name' && isEditing && (React.createElement(Box, { marginLeft: 3 },
                             React.createElement(TextInput, { value: editName, onChange: setEditName, placeholder: t.systemPromptConfig.enterPromptName }))),
                         (!isEditing || editingField !== 'name') && (React.createElement(Box, { marginLeft: 3 },
-                            React.createElement(Text, { color: "gray" }, editName || t.systemPromptConfig.notSet))))),
+                            React.createElement(Text, { color: theme.colors.menuSecondary }, editName || t.systemPromptConfig.notSet))))),
                 React.createElement(Box, { marginBottom: 1 },
                     React.createElement(Box, { flexDirection: "column" },
-                        React.createElement(Text, { color: editingField === 'content' ? 'green' : 'white' },
+                        React.createElement(Text, { color: editingField === 'content' ? theme.colors.menuSelected : theme.colors.menuNormal },
                             editingField === 'content' ? '❯ ' : '  ',
                             t.systemPromptConfig.contentLabel),
                         editingField === 'content' && isEditing && (React.createElement(Box, { marginLeft: 3 },
                             React.createElement(TextInput, { value: editContent, onChange: setEditContent, placeholder: t.systemPromptConfig.enterPromptContent }))),
                         (!isEditing || editingField !== 'content') && (React.createElement(Box, { marginLeft: 3 },
-                            React.createElement(Text, { color: "gray" }, editContent
+                            React.createElement(Text, { color: theme.colors.menuSecondary }, editContent
                                 ? editContent.substring(0, 100) +
                                     (editContent.length > 100 ? '...' : '')
                                 : t.systemPromptConfig.notSet)))))),
             React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: "gray", dimColor: true }, t.systemPromptConfig.editingHint))));
+                React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, t.systemPromptConfig.editingHint))));
     }
     // Render delete confirmation
     if (view === 'confirmDelete') {
@@ -315,10 +317,10 @@ export default function SystemPromptConfigScreen({ onBack }) {
                 React.createElement(Text, null,
                     t.systemPromptConfig.deleteConfirmMessage,
                     " \"",
-                    React.createElement(Text, { bold: true, color: "yellow" }, promptToDelete?.name),
+                    React.createElement(Text, { bold: true, color: theme.colors.warning }, promptToDelete?.name),
                     "\"?")),
             React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: "gray", dimColor: true }, t.systemPromptConfig.confirmHint))));
+                React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, t.systemPromptConfig.confirmHint))));
     }
     return null;
 }

package/dist/ui/pages/ThemeSettingsScreen.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    onBack: () => void;
+    inlineMode?: boolean;
+};
+export default function ThemeSettingsScreen({ onBack, inlineMode, }: Props): React.JSX.Element;
+export {};

package/dist/ui/pages/ThemeSettingsScreen.js

@@ -0,0 +1,106 @@
+import React, { useMemo, useCallback, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { Alert } from '@inkjs/ui';
+import Menu from '../components/Menu.js';
+import DiffViewer from '../components/DiffViewer.js';
+import { useTheme } from '../contexts/ThemeContext.js';
+import { useI18n } from '../../i18n/index.js';
+const sampleOldCode = `function greet(name) {
+  console.log("Hello " + name);
+  return "Welcome!";
+}`;
+const sampleNewCode = `function greet(name: string): string {
+  console.log(\`Hello \${name}\`);
+  return \`Welcome, \${name}!\`;
+}`;
+export default function ThemeSettingsScreen({ onBack, inlineMode = false, }) {
+    const { themeType, setThemeType } = useTheme();
+    const { t } = useI18n();
+    // Use themeType from context which is already loaded from config
+    const [selectedTheme, setSelectedTheme] = useState(themeType);
+    const [infoText, setInfoText] = useState('');
+    const themeOptions = useMemo(() => [
+        {
+            label: selectedTheme === 'dark' ? `✓ ${t.themeSettings.darkTheme}` : t.themeSettings.darkTheme,
+            value: 'dark',
+            infoText: t.themeSettings.darkThemeInfo,
+        },
+        {
+            label: selectedTheme === 'light' ? `✓ ${t.themeSettings.lightTheme}` : t.themeSettings.lightTheme,
+            value: 'light',
+            infoText: t.themeSettings.lightThemeInfo,
+        },
+        {
+            label: selectedTheme === 'github-dark' ? `✓ ${t.themeSettings.githubDark}` : t.themeSettings.githubDark,
+            value: 'github-dark',
+            infoText: t.themeSettings.githubDarkInfo,
+        },
+        {
+            label: selectedTheme === 'rainbow' ? `✓ ${t.themeSettings.rainbow}` : t.themeSettings.rainbow,
+            value: 'rainbow',
+            infoText: t.themeSettings.rainbowInfo,
+        },
+        {
+            label: selectedTheme === 'solarized-dark' ? `✓ ${t.themeSettings.solarizedDark}` : t.themeSettings.solarizedDark,
+            value: 'solarized-dark',
+            infoText: t.themeSettings.solarizedDarkInfo,
+        },
+        {
+            label: selectedTheme === 'nord' ? `✓ ${t.themeSettings.nord}` : t.themeSettings.nord,
+            value: 'nord',
+            infoText: t.themeSettings.nordInfo,
+        },
+        {
+            label: t.themeSettings.back,
+            value: 'back',
+            color: 'gray',
+            infoText: t.themeSettings.backInfo,
+        },
+    ], [selectedTheme, t]);
+    const handleSelect = useCallback((value) => {
+        if (value === 'back') {
+            // Restore original theme if cancelled
+            setThemeType(selectedTheme);
+            onBack();
+        }
+        else {
+            // Confirm and apply the theme (Enter pressed)
+            const newTheme = value;
+            setSelectedTheme(newTheme);
+            setThemeType(newTheme);
+        }
+    }, [onBack, setThemeType, selectedTheme]);
+    const handleSelectionChange = useCallback((newInfoText, value) => {
+        setInfoText(newInfoText);
+        // Preview theme on selection change (navigation)
+        if (value === 'back') {
+            // Restore to selected theme when hovering on "Back"
+            setThemeType(selectedTheme);
+        }
+        else {
+            // Preview the theme
+            setThemeType(value);
+        }
+    }, [setThemeType, selectedTheme]);
+    useInput((_input, key) => {
+        if (key.escape) {
+            // Restore original theme on ESC
+            setThemeType(selectedTheme);
+            onBack();
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        !inlineMode && (React.createElement(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, t.themeSettings.title))),
+        React.createElement(Box, { flexDirection: "column", paddingX: 1 },
+            React.createElement(Text, { color: "gray", dimColor: true },
+                t.themeSettings.current,
+                " ",
+                themeOptions.find(opt => opt.value === selectedTheme)?.label.replace('✓ ', '') || selectedTheme)),
+        React.createElement(Menu, { options: themeOptions, onSelect: handleSelect, onSelectionChange: handleSelectionChange }),
+        React.createElement(Box, { flexDirection: "column", paddingX: 1 },
+            React.createElement(Text, { color: "gray", dimColor: true }, t.themeSettings.preview),
+            React.createElement(DiffViewer, { oldContent: sampleOldCode, newContent: sampleNewCode, filename: "example.ts" })),
+        infoText && (React.createElement(Box, { paddingX: 1 },
+            React.createElement(Alert, { variant: "info" }, infoText)))));
+}

package/dist/ui/pages/WelcomeScreen.js

@@ -14,6 +14,7 @@ import CodeBaseConfigScreen from './CodeBaseConfigScreen.js';
 import SystemPromptConfigScreen from './SystemPromptConfigScreen.js';
 import CustomHeadersScreen from './CustomHeadersScreen.js';
 import LanguageSettingsScreen from './LanguageSettingsScreen.js';
+import ThemeSettingsScreen from './ThemeSettingsScreen.js';
 import { useI18n } from '../../i18n/index.js';
 export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
     const { t } = useI18n();
@@ -75,6 +76,11 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
             value: 'language',
             infoText: t.welcome.languageSettingsInfo,
         },
+        {
+            label: t.welcome.themeSettings,
+            value: 'theme',
+            infoText: t.welcome.themeSettingsInfo,
+        },
         {
             label: t.welcome.exit,
             value: 'exit',
@@ -112,6 +118,9 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
         else if (value === 'language') {
             setInlineView('language-settings');
         }
+        else if (value === 'theme') {
+            setInlineView('theme-settings');
+        }
         else {
             // Pass through to parent for other actions (chat, exit, etc.)
             onMenuSelect?.(value);
@@ -185,5 +194,6 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
         inlineView === 'customheaders' && (React.createElement(Box, { paddingX: 1 },
             React.createElement(CustomHeadersScreen, { onBack: handleBackToMenu }))),
         inlineView === 'language-settings' && (React.createElement(Box, { paddingX: 1 },
-            React.createElement(LanguageSettingsScreen, { onBack: handleBackToMenu, inlineMode: true })))));
+            React.createElement(LanguageSettingsScreen, { onBack: handleBackToMenu, inlineMode: true }))),
+        inlineView === 'theme-settings' && (React.createElement(ThemeSettingsScreen, { onBack: handleBackToMenu, inlineMode: true }))));
 }

package/dist/ui/themes/index.d.ts

@@ -0,0 +1,23 @@
+export type ThemeType = 'dark' | 'light' | 'github-dark' | 'rainbow' | 'solarized-dark' | 'nord';
+export interface Theme {
+    name: string;
+    type: ThemeType;
+    colors: {
+        background: string;
+        text: string;
+        border: string;
+        diffAdded: string;
+        diffRemoved: string;
+        diffModified: string;
+        lineNumber: string;
+        lineNumberBorder: string;
+        menuSelected: string;
+        menuNormal: string;
+        menuInfo: string;
+        menuSecondary: string;
+        error: string;
+        warning: string;
+        success: string;
+    };
+}
+export declare const themes: Record<ThemeType, Theme>;

package/dist/ui/themes/index.js

@@ -0,0 +1,140 @@
+export const themes = {
+    dark: {
+        name: 'Dark',
+        type: 'dark',
+        colors: {
+            background: '#1e1e1e',
+            text: '#d4d4d4',
+            border: '#3e3e3e',
+            diffAdded: '#0d4d3d',
+            diffRemoved: '#5a1f1f',
+            diffModified: '#dcdcaa',
+            lineNumber: '#858585',
+            lineNumberBorder: '#3e3e3e',
+            // Menu colors
+            menuSelected: 'green',
+            menuNormal: 'white',
+            menuInfo: 'cyan',
+            menuSecondary: 'gray',
+            // Status colors
+            error: 'red',
+            warning: 'yellow',
+            success: 'green',
+        },
+    },
+    light: {
+        name: 'Light',
+        type: 'light',
+        colors: {
+            background: '#ffffff',
+            text: '#ffffff',
+            border: '#e0e0e0',
+            diffAdded: '#006400',
+            diffRemoved: '#8B0000',
+            diffModified: '#0000ff',
+            lineNumber: '#6e6e6e',
+            lineNumberBorder: '#e0e0e0',
+            // Menu colors - darker for better visibility
+            menuSelected: '#006400',
+            menuNormal: '#000000',
+            menuInfo: '#0066cc',
+            menuSecondary: '#666666',
+            // Status colors - darker for better visibility on white background
+            error: '#cc0000',
+            warning: '#cc6600',
+            success: '#006400',
+        },
+    },
+    'github-dark': {
+        name: 'GitHub Dark',
+        type: 'github-dark',
+        colors: {
+            background: '#0d1117',
+            text: '#c9d1d9',
+            border: '#30363d',
+            diffAdded: '#1a4d2e',
+            diffRemoved: '#6e1a1a',
+            diffModified: '#9e6a03',
+            lineNumber: '#6e7681',
+            lineNumberBorder: '#21262d',
+            // Menu colors
+            menuSelected: '#58a6ff',
+            menuNormal: '#c9d1d9',
+            menuInfo: '#58a6ff',
+            menuSecondary: '#8b949e',
+            // Status colors
+            error: '#f85149',
+            warning: '#d29922',
+            success: '#3fb950',
+        },
+    },
+    rainbow: {
+        name: 'Rainbow',
+        type: 'rainbow',
+        colors: {
+            background: '#1a1a2e',
+            text: '#ffffff',
+            border: '#ff6b9d',
+            diffAdded: '#16697a',
+            diffRemoved: '#82204a',
+            diffModified: '#5f4b8b',
+            lineNumber: '#ffa07a',
+            lineNumberBorder: '#ff6b9d',
+            // Menu colors - vibrant rainbow colors
+            menuSelected: '#ff006e',
+            menuNormal: '#00f5ff',
+            menuInfo: '#ffbe0b',
+            menuSecondary: '#8338ec',
+            // Status colors - bright and colorful
+            error: '#ff006e',
+            warning: '#ffbe0b',
+            success: '#06ffa5',
+        },
+    },
+    'solarized-dark': {
+        name: 'Solarized Dark',
+        type: 'solarized-dark',
+        colors: {
+            background: '#002b36',
+            text: '#839496',
+            border: '#073642',
+            diffAdded: '#0a3d2c',
+            diffRemoved: '#5c1f1f',
+            diffModified: '#5d4f1a',
+            lineNumber: '#586e75',
+            lineNumberBorder: '#073642',
+            // Menu colors
+            menuSelected: '#2aa198',
+            menuNormal: '#93a1a1',
+            menuInfo: '#268bd2',
+            menuSecondary: '#657b83',
+            // Status colors
+            error: '#dc322f',
+            warning: '#b58900',
+            success: '#859900',
+        },
+    },
+    nord: {
+        name: 'Nord',
+        type: 'nord',
+        colors: {
+            background: '#2e3440',
+            text: '#d8dee9',
+            border: '#3b4252',
+            diffAdded: '#1d3a2f',
+            diffRemoved: '#5c2a2a',
+            diffModified: '#5a4d2f',
+            lineNumber: '#4c566a',
+            lineNumberBorder: '#3b4252',
+            // Menu colors
+            menuSelected: '#88c0d0',
+            menuNormal: '#d8dee9',
+            menuInfo: '#81a1c1',
+            menuSecondary: '#616e88',
+            // Status colors
+            error: '#bf616a',
+            warning: '#ebcb8b',
+            success: '#a3be8c',
+        },
+    },
+};

package/dist/utils/configManager.js

@@ -283,13 +283,21 @@ export function initializeProfiles() {
     migrateLegacyConfig();
     // Ensure the active profile exists and is loaded to config.json
     const activeProfile = getActiveProfileName();
-    const profileConfig = loadProfile(activeProfile);
+    let profileConfig = loadProfile(activeProfile);
     if (profileConfig) {
         // Sync the active profile to config.json
         saveConfig(profileConfig);
     }
     else {
-        // If active profile doesn't exist, switch to default
-        switchProfile('default');
+        // If active profile doesn't exist, create it first
+        // This is especially important for first-time installations
+        const defaultConfig = loadConfig();
+        saveProfile(activeProfile, defaultConfig);
+        setActiveProfileName(activeProfile);
+        // Now load and sync the newly created profile
+        profileConfig = loadProfile(activeProfile);
+        if (profileConfig) {
+            saveConfig(profileConfig);
+        }
     }
 }

package/dist/utils/logger.d.ts

@@ -26,6 +26,12 @@ export declare class Logger {
     debug(message: string, meta?: any): void;
     log(level: LogLevel, message: string, meta?: any): void;
 }
-declare const defaultLogger: Logger;
-export default defaultLogger;
-export { defaultLogger as logger };
+declare const logger: {
+    error(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    info(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+    log(level: LogLevel, message: string, meta?: any): void;
+};
+export default logger;
+export { logger };

package/dist/utils/logger.js

@@ -92,6 +92,31 @@ export class Logger {
         this.writeLog(level, message, meta);
     }
 }
-const defaultLogger = new Logger();
-export default defaultLogger;
-export { defaultLogger as logger };
+// Lazy initialization to avoid blocking startup
+let _defaultLogger = null;
+function getDefaultLogger() {
+    if (!_defaultLogger) {
+        _defaultLogger = new Logger();
+    }
+    return _defaultLogger;
+}
+// Create a proxy object that lazily initializes the logger
+const logger = {
+    error(message, meta) {
+        getDefaultLogger().error(message, meta);
+    },
+    warn(message, meta) {
+        getDefaultLogger().warn(message, meta);
+    },
+    info(message, meta) {
+        getDefaultLogger().info(message, meta);
+    },
+    debug(message, meta) {
+        getDefaultLogger().debug(message, meta);
+    },
+    log(level, message, meta) {
+        getDefaultLogger().log(level, message, meta);
+    },
+};
+export default logger;
+export { logger };

package/dist/utils/mcpToolsManager.d.ts

@@ -19,7 +19,7 @@ export interface MCPServiceTools {
     error?: string;
 }
 /**
- * Get the TODO service instance
+ * Get the TODO service instance (lazy initialization)
  */
 export declare function getTodoService(): TodoService;
 /**

package/dist/utils/mcpToolsManager.js

@@ -19,15 +19,18 @@ import os from 'os';
 import path from 'path';
 let toolsCache = null;
 const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
-// Initialize TODO service with sessionManager accessor
-const todoService = new TodoService(path.join(os.homedir(), '.snow'), () => {
-    const session = sessionManager.getCurrentSession();
-    return session ? session.id : null;
-});
+// Lazy initialization of TODO service to avoid circular dependencies
+let todoService = null;
 /**
- * Get the TODO service instance
+ * Get the TODO service instance (lazy initialization)
  */
 export function getTodoService() {
+    if (!todoService) {
+        todoService = new TodoService(path.join(os.homedir(), '.snow'), () => {
+            const session = sessionManager.getCurrentSession();
+            return session ? session.id : null;
+        });
+    }
     return todoService;
 }
 /**
@@ -123,8 +126,9 @@ async function refreshToolsCache() {
         });
     }
     // Add built-in TODO tools (always available)
-    await todoService.initialize();
-    const todoTools = todoService.getTools();
+    const todoSvc = getTodoService(); // This will never return null after lazy init
+    await todoSvc.initialize();
+    const todoTools = todoSvc.getTools();
     const todoServiceTools = todoTools.map(tool => ({
         name: tool.name.replace('todo-', ''),
         description: tool.description || '',
@@ -689,7 +693,7 @@ export async function executeMCPTool(toolName, args, abortSignal, onTokenUpdate)
     }
     if (serviceName === 'todo') {
         // Handle built-in TODO tools (no connection needed)
-        return await todoService.executeTool(actualToolName, args);
+        return await getTodoService().executeTool(actualToolName, args);
     }
     else if (serviceName === 'notebook') {
         // Handle built-in Notebook tools (no connection needed)

package/dist/utils/themeConfig.d.ts

@@ -0,0 +1,21 @@
+import type { ThemeType } from '../ui/themes/index.js';
+interface ThemeConfig {
+    theme: ThemeType;
+}
+/**
+ * Load theme configuration from file system
+ */
+export declare function loadThemeConfig(): ThemeConfig;
+/**
+ * Save theme configuration to file system
+ */
+export declare function saveThemeConfig(config: ThemeConfig): void;
+/**
+ * Get current theme setting
+ */
+export declare function getCurrentTheme(): ThemeType;
+/**
+ * Set theme and persist to file system
+ */
+export declare function setCurrentTheme(theme: ThemeType): void;
+export {};

package/dist/utils/themeConfig.js

@@ -0,0 +1,61 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+const CONFIG_DIR = join(homedir(), '.snow');
+const THEME_CONFIG_FILE = join(CONFIG_DIR, 'theme.json');
+const DEFAULT_CONFIG = {
+    theme: 'dark',
+};
+function ensureConfigDirectory() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+/**
+ * Load theme configuration from file system
+ */
+export function loadThemeConfig() {
+    ensureConfigDirectory();
+    if (!existsSync(THEME_CONFIG_FILE)) {
+        saveThemeConfig(DEFAULT_CONFIG);
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const configData = readFileSync(THEME_CONFIG_FILE, 'utf-8');
+        const config = JSON.parse(configData);
+        return {
+            ...DEFAULT_CONFIG,
+            ...config,
+        };
+    }
+    catch (error) {
+        // If config file is corrupted, return default config
+        return DEFAULT_CONFIG;
+    }
+}
+/**
+ * Save theme configuration to file system
+ */
+export function saveThemeConfig(config) {
+    ensureConfigDirectory();
+    try {
+        const configData = JSON.stringify(config, null, 2);
+        writeFileSync(THEME_CONFIG_FILE, configData, 'utf-8');
+    }
+    catch (error) {
+        console.error('Failed to save theme config:', error);
+    }
+}
+/**
+ * Get current theme setting
+ */
+export function getCurrentTheme() {
+    const config = loadThemeConfig();
+    return config.theme;
+}
+/**
+ * Set theme and persist to file system
+ */
+export function setCurrentTheme(theme) {
+    saveThemeConfig({ theme });
+}