local-deep-research 0.1.26__py3-none-any.whl → 0.2.2__py3-none-any.whl

local_deep_research/web/static/js/components/settings_sync.js

@@ -0,0 +1,106 @@
+// Function to save settings using the settings page endpoint
+function saveMenuSettings(settingKey, settingValue) {
+    // Create payload with the single setting being changed
+    const payload = {};
+    payload[settingKey] = settingValue;
+
+    console.log('Saving setting:', settingKey, '=', settingValue);
+
+    // Get CSRF token
+    const csrfToken = document.querySelector('meta[name="csrf-token"]').getAttribute('content');
+
+    // Use fetch to send to the same endpoint as the settings page
+    fetch('/research/settings/save_all_settings', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-CSRFToken': csrfToken
+        },
+        body: JSON.stringify(payload)
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.status === 'success') {
+            // Show success notification if UI module is available
+            if (window.ui && window.ui.showMessage) {
+                window.ui.showMessage('Setting saved successfully', 'success');
+            } else {
+                console.log('Setting saved successfully:', data);
+            }
+        } else {
+            // Show error notification
+            if (window.ui && window.ui.showMessage) {
+                window.ui.showMessage('Failed to save setting: ' + (data.message || 'Unknown error'), 'error');
+            } else {
+                console.error('Failed to save setting:', data);
+            }
+        }
+    })
+    .catch(error => {
+        console.error('Error saving setting:', error);
+        if (window.ui && window.ui.showMessage) {
+            window.ui.showMessage('Error saving setting', 'error');
+        }
+    });
+}
+
+/**
+ * Connects the menu settings to use the same save method as the settings page.
+ */
+function connectMenuSettings() {
+    console.log('Initializing menu settings handler');
+
+    // Handle model dropdown changes
+    const modelInput = document.getElementById('model');
+    const modelHidden = document.getElementById('model_hidden');
+
+    if (modelHidden) {
+        modelHidden.addEventListener('change', function(e) {
+            console.log('Model changed to:', this.value);
+            saveMenuSettings('llm.model', this.value);
+        });
+    }
+
+    // Handle provider dropdown changes
+    const providerSelect = document.getElementById('model_provider');
+    if (providerSelect) {
+        providerSelect.addEventListener('change', function(e) {
+            console.log('Provider changed to:', this.value);
+            saveMenuSettings('llm.provider', this.value);
+        });
+    }
+
+    // Handle search engine dropdown changes
+    const searchEngineHidden = document.getElementById('search_engine_hidden');
+    if (searchEngineHidden) {
+        searchEngineHidden.addEventListener('change', function(e) {
+            console.log('Search engine changed to:', this.value);
+            saveMenuSettings('search.tool', this.value);
+        });
+    }
+
+    // Handle iterations and questions per iteration
+    const iterationsInput = document.getElementById('iterations');
+    if (iterationsInput) {
+        iterationsInput.addEventListener('change', function(e) {
+            console.log('Iterations changed to:', this.value);
+            saveMenuSettings('search.iterations', this.value);
+        });
+    }
+
+    const questionsInput = document.getElementById('questions_per_iteration');
+    if (questionsInput) {
+        questionsInput.addEventListener('change', function(e) {
+            console.log('Questions per iteration changed to:', this.value);
+            saveMenuSettings('search.questions_per_iteration', this.value);
+        });
+    }
+
+    console.log('Menu settings handlers initialized');
+}
+
+// Call this function after the page and other scripts are loaded
+document.addEventListener('DOMContentLoaded', function() {
+    // Wait a bit to ensure other scripts have loaded
+    setTimeout(connectMenuSettings, 1000);
+});

local_deep_research/web/static/js/main.js

@@ -0,0 +1,226 @@
+/**
+ * Main JavaScript Entry Point
+ * Loads appropriate components based on the current page
+ */
+(function() {
+    // Map of page identifiers to component scripts
+    const pageComponents = {
+        'page-home': ['research.js'],
+        'page-progress': ['progress.js'],
+        'page-results': ['results.js'],
+        'page-detail': ['detail.js'],
+        'page-history': ['history.js'],
+        'page-settings': ['settings.js']
+    };
+    
+    // Core services to always load
+    const coreServices = [
+        'formatting.js',
+        'ui.js',
+        'api.js',
+        'socket.js'
+        // 'audio.js' - Removed from here, loaded separately
+    ];
+    
+    // Optional services to load when needed
+    const optionalServices = {
+        'page-results': ['pdf.js'],
+        'page-detail': ['pdf.js']
+    };
+    
+    /**
+     * Initialize the application
+     */
+    function initializeApp() {
+        // Detect current page
+        const currentPage = detectCurrentPage();
+        
+        if (!currentPage) {
+            console.error('Cannot detect current page type');
+            return;
+        }
+        
+        console.log('Current page detected:', currentPage);
+        
+        // IMPORTANT: Load audio.js first, before ANY other scripts
+        loadAudioServiceFirst(() => {
+            // Continue loading other scripts after audio service is loaded
+            console.log('Audio service script loaded, continuing with other scripts');
+            
+            // Load UI and formatting utils
+            loadScripts('utils', coreServices.filter(s => s.includes('formatting') || s.includes('ui')));
+            
+            // Then load the rest
+            loadScripts('services', coreServices.filter(s => s.includes('api') || s.includes('socket')));
+            
+            // Load optional services for this page
+            if (optionalServices[currentPage]) {
+                loadScripts('services', optionalServices[currentPage]);
+            }
+            
+            // Load components for this page AFTER all services
+            if (pageComponents[currentPage]) {
+                loadScripts('components', pageComponents[currentPage]);
+            }
+            
+            // Initialize tooltips and other global UI elements
+            initializeGlobalUI();
+        });
+    }
+    
+    /**
+     * Load audio service first and separately to ensure it's fully loaded before other scripts
+     * @param {Function} callback - Function to call after audio service is loaded
+     */
+    function loadAudioServiceFirst(callback) {
+        console.log('Loading audio service script first...');
+        const audioScript = document.createElement('script');
+        audioScript.src = `/research/static/js/services/audio.js?t=${new Date().getTime()}`; // Add timestamp to avoid cache
+        audioScript.async = false;
+        
+        // Set up callback for when script loads
+        audioScript.onload = function() {
+            console.log('Audio service script loaded successfully');
+            
+            // Check if audio service is available in window object
+            setTimeout(() => {
+                if (window.audio) {
+                    console.log('Audio service initialized in window object');
+                } else {
+                    console.warn('Audio service not available in window object after script load');
+                }
+                
+                // Continue regardless
+                callback();
+            }, 100); // Small delay to ensure script executes
+        };
+        
+        // Error handling
+        audioScript.onerror = function() {
+            console.error('Failed to load audio service script');
+            // Continue with other scripts even if audio fails
+            callback();
+        };
+        
+        // Add to document
+        document.body.appendChild(audioScript);
+    }
+    
+    /**
+     * Detect the current page based on body class
+     * @returns {string|null} The page identifier or null if not found
+     */
+    function detectCurrentPage() {
+        const bodyClasses = document.body.classList;
+        
+        for (const pageId in pageComponents) {
+            if (bodyClasses.contains(pageId)) {
+                return pageId;
+            }
+        }
+        
+        // Check URL patterns as fallback
+        const path = window.location.pathname;
+        
+        if (path === '/' || path === '/index' || path === '/home' || path === '/research/') {
+            return 'page-home';
+        } else if (path.includes('/research/progress')) {
+            return 'page-progress';
+        } else if (path.includes('/research/results')) {
+            return 'page-results';
+        } else if (path.includes('/research/detail')) {
+            return 'page-detail';
+        } else if (path.includes('/research/history')) {
+            return 'page-history';
+        } else if (path.includes('/research/settings')) {
+            return 'page-settings';
+        }
+        
+        return null;
+    }
+    
+    /**
+     * Load scripts dynamically
+     * @param {string} folder - The folder containing the scripts
+     * @param {Array} scripts - Array of script filenames to load
+     */
+    function loadScripts(folder, scripts) {
+        if (!scripts || !scripts.length) return;
+        
+        scripts.forEach(script => {
+            const scriptElement = document.createElement('script');
+            scriptElement.src = `/research/static/js/${folder}/${script}`;
+            scriptElement.async = false; // Load in sequence
+            document.body.appendChild(scriptElement);
+        });
+    }
+    
+    /**
+     * Initialize global UI elements
+     */
+    function initializeGlobalUI() {
+        // Initialize notifications if browser supports it
+        if ("Notification" in window && Notification.permission === "default") {
+            // Only ask for permission when user interacts with the page
+            document.addEventListener('click', requestNotificationPermission, { once: true });
+        }
+        
+        // Initialize theme toggle
+        const themeToggle = document.getElementById('theme-toggle');
+        if (themeToggle) {
+            // Check for saved theme preference or use system preference
+            const savedTheme = localStorage.getItem('theme');
+            const systemDarkMode = window.matchMedia('(prefers-color-scheme: dark)').matches;
+            const isDarkMode = savedTheme === 'dark' || (savedTheme === null && systemDarkMode);
+            
+            // Set initial theme
+            document.documentElement.setAttribute('data-theme', isDarkMode ? 'dark' : 'light');
+            themeToggle.innerHTML = isDarkMode ? 
+                '<i class="fas fa-sun"></i>' : 
+                '<i class="fas fa-moon"></i>';
+            
+            // Listen for theme toggle click
+            themeToggle.addEventListener('click', function() {
+                const currentTheme = document.documentElement.getAttribute('data-theme');
+                const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
+                
+                document.documentElement.setAttribute('data-theme', newTheme);
+                localStorage.setItem('theme', newTheme);
+                
+                themeToggle.innerHTML = newTheme === 'dark' ? 
+                    '<i class="fas fa-sun"></i>' : 
+                    '<i class="fas fa-moon"></i>';
+            });
+        }
+        
+        // Initialize mobile menu toggle
+        const mobileMenuToggle = document.getElementById('mobile-menu-toggle');
+        const navMenu = document.getElementById('main-nav');
+        
+        if (mobileMenuToggle && navMenu) {
+            mobileMenuToggle.addEventListener('click', function() {
+                navMenu.classList.toggle('open');
+                mobileMenuToggle.setAttribute(
+                    'aria-expanded', 
+                    navMenu.classList.contains('open') ? 'true' : 'false'
+                );
+            });
+        }
+    }
+    
+    /**
+     * Request notification permission
+     */
+    function requestNotificationPermission() {
+        if ("Notification" in window && Notification.permission === "default") {
+            Notification.requestPermission();
+        }
+    }
+    
+    // Initialize when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', initializeApp);
+    } else {
+        initializeApp();
+    }
+})(); 

local_deep_research/web/static/js/services/api.js

@@ -0,0 +1,253 @@
+/**
+ * API Service
+ * Handles all communication with the server API endpoints
+ */
+
+// Base URL for API - use existing one if already declared
+if (typeof API_BASE_URL === 'undefined') {
+    const API_BASE_URL = '/research/api';
+}
+
+/**
+ * Get CSRF token from meta tag
+ * @returns {string} The CSRF token
+ */
+function getCsrfToken() {
+    const metaTag = document.querySelector('meta[name="csrf-token"]');
+    return metaTag ? metaTag.getAttribute('content') : '';
+}
+
+/**
+ * Get the full URL for an API endpoint
+ * @param {string} path - The API path (without leading slash)
+ * @returns {string} The full API URL
+ */
+function getApiUrl(path) {
+    return `${API_BASE_URL}/${path}`;
+}
+
+/**
+ * Generic fetch with error handling
+ * @param {string} url - The URL to fetch
+ * @param {Object} options - Fetch options
+ * @returns {Promise<any>} The parsed response data
+ */
+async function fetchWithErrorHandling(url, options = {}) {
+    try {
+        const csrfToken = getCsrfToken();
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(csrfToken ? { 'X-CSRFToken': csrfToken } : {}),
+                ...(options.headers || {})
+            }
+        });
+
+        // Handle non-200 responses
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(errorData.message || `API Error: ${response.status} ${response.statusText}`);
+        }
+
+        // Parse the response
+        return await response.json();
+    } catch (error) {
+        console.error('API Error:', error);
+        throw error;
+    }
+}
+
+/**
+ * Helper method to perform POST requests with JSON data
+ * @param {string} path - API path
+ * @param {Object} data - JSON data to send
+ * @returns {Promise<any>} Response data
+ */
+async function postJSON(path, data) {
+    return fetchWithErrorHandling(path, {
+        method: 'POST',
+        body: JSON.stringify(data)
+    });
+}
+
+/**
+ * Start a new research
+ * @param {string} query - The research query
+ * @param {string} mode - The research mode (quick/detailed)
+ * @returns {Promise<Object>} The research response with ID
+ */
+async function startResearch(query, mode) {
+    return postJSON('/research/api/start_research', { query, mode });
+}
+
+/**
+ * Get a research status by ID
+ * @param {number} researchId - The research ID
+ * @returns {Promise<Object>} The research status
+ */
+async function getResearchStatus(researchId) {
+    return fetchWithErrorHandling(`/research/api/status/${researchId}`);
+}
+
+/**
+ * Get research details
+ * @param {number} researchId - The research ID
+ * @returns {Promise<Object>} The research details
+ */
+async function getResearchDetails(researchId) {
+    return fetchWithErrorHandling(`/research/api/details/${researchId}`);
+}
+
+/**
+ * Get research logs
+ * @param {number} researchId - The research ID
+ * @returns {Promise<Object>} The research logs
+ */
+async function getResearchLogs(researchId) {
+    return fetchWithErrorHandling(`/research/api/logs/${researchId}`);
+}
+
+/**
+ * Get research history
+ * @returns {Promise<Array>} The research history
+ */
+async function getResearchHistory() {
+    return fetchWithErrorHandling('/research/api/history');
+}
+
+/**
+ * Get research report
+ * @param {number} researchId - The research ID
+ * @returns {Promise<Object>} The research report
+ */
+async function getReport(researchId) {
+    return fetchWithErrorHandling(`/research/api/report/${researchId}`);
+}
+
+/**
+ * Terminate a research
+ * @param {number} researchId - The research ID
+ * @returns {Promise<Object>} The termination response
+ */
+async function terminateResearch(researchId) {
+    return postJSON(`/research/api/terminate/${researchId}`, {});
+}
+
+/**
+ * Delete a research
+ * @param {number} researchId - The research ID
+ * @returns {Promise<Object>} The deletion response
+ */
+async function deleteResearch(researchId) {
+    const csrfToken = getCsrfToken();
+    return fetchWithErrorHandling(`/research/api/delete/${researchId}`, {
+        method: 'DELETE',
+        headers: {
+            'X-CSRFToken': csrfToken
+        }
+    });
+}
+
+/**
+ * Clear all research history
+ * @returns {Promise<Object>} The response
+ */
+async function clearResearchHistory() {
+    return postJSON('/research/api/clear_history', {});
+}
+
+/**
+ * Open a file location in the system file explorer
+ * @param {string} path - Path to open
+ * @returns {Promise<Object>} The response
+ */
+async function openFileLocation(path) {
+    return postJSON('/research/open_file_location', { path });
+}
+
+/**
+ * Save raw configuration
+ * @param {string} rawConfig - Raw configuration text
+ * @returns {Promise<Object>} The response
+ */
+async function saveRawConfig(rawConfig) {
+    return postJSON('/research/api/save_raw_config', { raw_config: rawConfig });
+}
+
+/**
+ * Save main configuration
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} The response
+ */
+async function saveMainConfig(config) {
+    return postJSON('/research/api/save_main_config', config);
+}
+
+/**
+ * Save search engines configuration
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} The response
+ */
+async function saveSearchEnginesConfig(config) {
+    return postJSON('/research/api/save_search_engines_config', config);
+}
+
+/**
+ * Save collections configuration
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} The response
+ */
+async function saveCollectionsConfig(config) {
+    return postJSON('/research/api/save_collections_config', config);
+}
+
+/**
+ * Save API keys configuration
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} The response
+ */
+async function saveApiKeysConfig(config) {
+    return postJSON('/research/api/save_api_keys_config', config);
+}
+
+/**
+ * Save LLM configuration
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} The response
+ */
+async function saveLlmConfig(config) {
+    return postJSON('/research/api/save_llm_config', config);
+}
+
+/**
+ * Get markdown export for research
+ * @param {number} researchId - The research ID
+ * @returns {Promise<Object>} The markdown content
+ */
+async function getMarkdownExport(researchId) {
+    return fetchWithErrorHandling(`/research/api/markdown/${researchId}`);
+}
+
+// Export the API functions
+window.api = {
+    startResearch,
+    getResearchStatus,
+    getResearchDetails,
+    getResearchLogs,
+    getResearchHistory,
+    getReport,
+    getMarkdownExport,
+    terminateResearch,
+    deleteResearch,
+    clearResearchHistory,
+    openFileLocation,
+    saveRawConfig,
+    saveMainConfig,
+    saveSearchEnginesConfig,
+    saveCollectionsConfig,
+    saveApiKeysConfig,
+    saveLlmConfig,
+    postJSON,
+    getApiUrl
+};

local_deep_research/web/static/js/services/audio.js

@@ -0,0 +1,31 @@
+/**
+ * Audio Service Stub
+ * This is a placeholder for future sound notification implementation
+ */
+
+// Set global audio object as a no-op service
+window.audio = {
+    initialize: function() {
+        console.log('Audio service disabled - will be implemented in the future');
+        return false;
+    },
+    playSuccess: function() {
+        console.log('Success sound playback disabled');
+        return false;
+    },
+    playError: function() {
+        console.log('Error sound playback disabled');
+        return false;
+    },
+    play: function() {
+        console.log('Sound playback disabled');
+        return false;
+    },
+    test: function() {
+        console.log('Sound testing disabled');
+        return false;
+    }
+};
+
+// Log that audio is disabled
+console.log('Audio service is currently disabled - notifications will be implemented later');