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

local_deep_research/web/static/js/components/detail.js

@@ -0,0 +1,348 @@
+/**
+ * Detail Component
+ * Manages the display of detailed information for a specific research topic
+ */
+(function() {
+    // DOM Elements
+    let detailContainer = null;
+    let sourcesList = null;
+    let tabsContainer = null;
+    
+    // Component state
+    let currentResearchId = null;
+    let currentTopicId = null;
+    let detailData = null;
+    
+    /**
+     * Initialize the detail component
+     */
+    function initializeDetail() {
+        // Get IDs from URL
+        const ids = getIdsFromUrl();
+        currentResearchId = ids.researchId;
+        currentTopicId = ids.topicId;
+        
+        if (!currentResearchId || !currentTopicId) {
+            console.error('No research or topic ID found');
+            if (window.ui && window.ui.showError) {
+                window.ui.showError('Invalid research or topic. Please return to the results page.');
+            }
+            return;
+        }
+        
+        // Get DOM elements
+        detailContainer = document.getElementById('research-log');
+        
+        if (!detailContainer) {
+            console.error('Required DOM elements not found for detail component');
+            return;
+        }
+        
+        // Set up event listeners
+        setupEventListeners();
+        
+        // Load topic detail
+        loadTopicDetail();
+        
+        console.log('Detail component initialized for research:', currentResearchId, 'topic:', currentTopicId);
+    }
+    
+    /**
+     * Extract research and topic IDs from URL
+     * @returns {Object} Object with researchId and topicId
+     */
+    function getIdsFromUrl() {
+        const pathParts = window.location.pathname.split('/');
+        const detailIndex = pathParts.indexOf('detail');
+        
+        if (detailIndex > 0 && detailIndex + 2 < pathParts.length) {
+            return {
+                researchId: pathParts[detailIndex + 1],
+                topicId: pathParts[detailIndex + 2]
+            };
+        }
+        
+        return { researchId: null, topicId: null };
+    }
+    
+    /**
+     * Set up event listeners
+     */
+    function setupEventListeners() {
+        // Back button
+        const backButton = document.getElementById('back-to-history-from-details');
+        if (backButton) {
+            backButton.addEventListener('click', function() {
+                window.location.href = '/research/history';
+            });
+        }
+        
+        // Progress elements
+        const progressBar = document.getElementById('detail-progress-fill');
+        const progressPercentage = document.getElementById('detail-progress-percentage');
+        
+        // Tab click events
+        if (tabsContainer) {
+            tabsContainer.addEventListener('click', function(e) {
+                if (e.target && e.target.matches('.tab-item')) {
+                    const tabId = e.target.dataset.tab;
+                    switchTab(tabId);
+                }
+            });
+        }
+        
+        // Source highlight and citation copy
+        if (sourcesList) {
+            sourcesList.addEventListener('click', function(e) {
+                // Handle citation copy
+                if (e.target && e.target.matches('.copy-citation-btn')) {
+                    const sourceId = e.target.closest('.source-item').dataset.id;
+                    handleCopyCitation(sourceId);
+                }
+                
+                // Handle source highlighting
+                if (e.target && e.target.closest('.source-item')) {
+                    const sourceItem = e.target.closest('.source-item');
+                    if (!e.target.matches('.copy-citation-btn')) {
+                        toggleSourceHighlight(sourceItem);
+                    }
+                }
+            });
+        }
+    }
+    
+    /**
+     * Load topic detail from API
+     */
+    async function loadTopicDetail() {
+        // Show loading state
+        window.ui.showSpinner(detailContainer, 'Loading topic details...');
+        
+        try {
+            // Get topic detail
+            detailData = await window.api.getTopicDetail(currentResearchId, currentTopicId);
+            
+            if (!detailData) {
+                throw new Error('No topic details found');
+            }
+            
+            // Render detail
+            renderDetail(detailData);
+        } catch (error) {
+            console.error('Error loading topic detail:', error);
+            window.ui.hideSpinner(detailContainer);
+            window.ui.showError('Error loading topic detail: ' + error.message);
+        }
+    }
+    
+    /**
+     * Render topic detail
+     * @param {Object} data - The topic detail data
+     */
+    function renderDetail(data) {
+        // Hide spinner
+        window.ui.hideSpinner(detailContainer);
+        
+        // Set page title
+        document.title = `${data.title || 'Topic Detail'} - Local Deep Research`;
+        
+        // Update page header
+        const pageTitle = document.querySelector('h1.page-title');
+        if (pageTitle && data.title) {
+            pageTitle.textContent = data.title;
+        }
+        
+        // Render content
+        if (data.content) {
+            // Render markdown
+            const renderedHtml = window.ui.renderMarkdown(data.content);
+            detailContainer.innerHTML = renderedHtml;
+            
+            // Add syntax highlighting
+            highlightCodeBlocks();
+        } else {
+            detailContainer.innerHTML = '<p class="text-error">No content available for this topic.</p>';
+        }
+        
+        // Render sources
+        if (sourcesList && data.sources && data.sources.length > 0) {
+            renderSources(data.sources);
+        }
+        
+        // Set sources count
+        const sourcesCountEl = document.getElementById('sources-count');
+        if (sourcesCountEl && data.sources) {
+            sourcesCountEl.textContent = `${data.sources.length} source${data.sources.length !== 1 ? 's' : ''}`;
+        }
+        
+        // Show first tab
+        if (tabsContainer) {
+            const firstTab = tabsContainer.querySelector('.tab-item');
+            if (firstTab) {
+                switchTab(firstTab.dataset.tab);
+            }
+        }
+    }
+    
+    /**
+     * Render sources list
+     * @param {Array} sources - Array of source objects
+     */
+    function renderSources(sources) {
+        sourcesList.innerHTML = '';
+        
+        sources.forEach((source, index) => {
+            const sourceEl = document.createElement('div');
+            sourceEl.className = 'source-item';
+            sourceEl.dataset.id = index;
+            
+            const title = source.title || source.url || `Source ${index + 1}`;
+            const url = source.url || '';
+            const author = source.author || '';
+            const date = source.date || '';
+            
+            sourceEl.innerHTML = `
+                <div class="source-header">
+                    <h4 class="source-title">${title}</h4>
+                    <button class="copy-citation-btn" title="Copy citation">
+                        <i class="fas fa-clipboard"></i>
+                    </button>
+                </div>
+                ${url ? `<div class="source-url"><a href="${url}" target="_blank">${url}</a></div>` : ''}
+                <div class="source-metadata">
+                    ${author ? `<span><i class="fas fa-user"></i> ${author}</span>` : ''}
+                    ${date ? `<span><i class="far fa-calendar"></i> ${date}</span>` : ''}
+                </div>
+                ${source.relevance ? `<div class="source-relevance">Relevance: ${source.relevance}</div>` : ''}
+            `;
+            
+            sourcesList.appendChild(sourceEl);
+        });
+    }
+    
+    /**
+     * Switch between tabs
+     * @param {string} tabId - The tab ID to switch to
+     */
+    function switchTab(tabId) {
+        // Update active tab
+        const tabs = document.querySelectorAll('.tab-item');
+        tabs.forEach(tab => {
+            tab.classList.toggle('active', tab.dataset.tab === tabId);
+        });
+        
+        // Update visible content
+        const tabContents = document.querySelectorAll('.tab-content');
+        tabContents.forEach(content => {
+            content.style.display = content.dataset.tab === tabId ? 'block' : 'none';
+        });
+    }
+    
+    /**
+     * Toggle source highlight
+     * @param {HTMLElement} sourceEl - The source element to highlight
+     */
+    function toggleSourceHighlight(sourceEl) {
+        // Remove highlight from all sources
+        const allSources = document.querySelectorAll('.source-item');
+        allSources.forEach(s => s.classList.remove('highlighted'));
+        
+        // Add highlight to clicked source
+        sourceEl.classList.add('highlighted');
+        
+        // Get source index
+        const sourceIndex = parseInt(sourceEl.dataset.id);
+        
+        // Highlight content with this source
+        highlightContentFromSource(sourceIndex);
+    }
+    
+    /**
+     * Highlight content sections from a specific source
+     * @param {number} sourceIndex - The source index to highlight
+     */
+    function highlightContentFromSource(sourceIndex) {
+        // Remove all existing highlights
+        const allCitations = document.querySelectorAll('.citation-highlight');
+        allCitations.forEach(el => {
+            el.classList.remove('citation-highlight');
+        });
+        
+        // Add highlight to citations from this source
+        const citations = document.querySelectorAll(`.citation[data-source="${sourceIndex}"]`);
+        citations.forEach(citation => {
+            citation.classList.add('citation-highlight');
+            
+            // Scroll to first citation
+            if (citations.length > 0) {
+                citations[0].scrollIntoView({ behavior: 'smooth', block: 'center' });
+            }
+        });
+    }
+    
+    /**
+     * Handle copying citation
+     * @param {number} sourceIndex - The source index to copy
+     */
+    async function handleCopyCitation(sourceIndex) {
+        if (!detailData || !detailData.sources || !detailData.sources[sourceIndex]) {
+            return;
+        }
+        
+        const source = detailData.sources[sourceIndex];
+        
+        // Format citation
+        let citation = '';
+        
+        if (source.author) {
+            citation += source.author;
+            if (source.date) {
+                citation += ` (${source.date})`;
+            }
+            citation += '. ';
+        }
+        
+        if (source.title) {
+            citation += `"${source.title}". `;
+        }
+        
+        if (source.url) {
+            citation += `Retrieved from ${source.url}`;
+        }
+        
+        // Copy to clipboard
+        try {
+            await navigator.clipboard.writeText(citation);
+            
+            // Show tooltip
+            const btn = document.querySelector(`.source-item[data-id="${sourceIndex}"] .copy-citation-btn`);
+            if (btn) {
+                const originalHTML = btn.innerHTML;
+                btn.innerHTML = '<i class="fas fa-check"></i>';
+                
+                setTimeout(() => {
+                    btn.innerHTML = originalHTML;
+                }, 2000);
+            }
+        } catch (error) {
+            console.error('Failed to copy citation:', error);
+        }
+    }
+    
+    /**
+     * Apply syntax highlighting to code blocks
+     */
+    function highlightCodeBlocks() {
+        // Check if Prism is available
+        if (typeof Prism !== 'undefined') {
+            Prism.highlightAllUnder(detailContainer);
+        }
+    }
+    
+    // Initialize on DOM content loaded
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', initializeDetail);
+    } else {
+        initializeDetail();
+    }
+})(); 

local_deep_research/web/static/js/components/fallback/formatting.js

@@ -0,0 +1,122 @@
+/**
+ * Formatting Fallback Utilities
+ * Basic implementations of formatting utilities that can be used if the main formatting module is not available
+ */
+(function() {
+    // Only initialize if window.formatting is not already defined
+    if (window.formatting) {
+        console.log('Main formatting utilities already available, skipping fallback');
+        return;
+    }
+
+    console.log('Initializing fallback formatting utilities');
+
+    /**
+     * Format a date
+     * @param {string} dateStr - ISO date string
+     * @returns {string} Formatted date
+     */
+    function formatDate(dateStr) {
+        if (!dateStr) return 'N/A';
+        
+        try {
+            const date = new Date(dateStr);
+            return date.toLocaleString(undefined, {
+                year: 'numeric',
+                month: 'short',
+                day: 'numeric',
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit'
+            });
+        } catch (e) {
+            console.error('Error formatting date:', e);
+            return dateStr;
+        }
+    }
+
+    /**
+     * Format a status string
+     * @param {string} status - Status code
+     * @returns {string} Formatted status
+     */
+    function formatStatus(status) {
+        if (!status) return 'Unknown';
+        
+        const statusMap = {
+            'in_progress': 'In Progress',
+            'completed': 'Completed',
+            'failed': 'Failed',
+            'suspended': 'Suspended',
+            'pending': 'Pending',
+            'error': 'Error'
+        };
+        
+        return statusMap[status] || status;
+    }
+
+    /**
+     * Format a mode string
+     * @param {string} mode - Mode code
+     * @returns {string} Formatted mode
+     */
+    function formatMode(mode) {
+        if (!mode) return 'Unknown';
+        
+        const modeMap = {
+            'quick': 'Quick Summary',
+            'detailed': 'Detailed Report',
+            'standard': 'Standard Research',
+            'advanced': 'Advanced Research'
+        };
+        
+        return modeMap[mode] || mode;
+    }
+
+    /**
+     * Format duration in seconds to readable text
+     * @param {number} seconds - Duration in seconds
+     * @returns {string} Formatted duration
+     */
+    function formatDuration(seconds) {
+        if (!seconds && seconds !== 0) return 'N/A';
+        
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        
+        if (minutes === 0) {
+            return `${remainingSeconds}s`;
+        } else {
+            return `${minutes}m ${remainingSeconds}s`;
+        }
+    }
+
+    /**
+     * Format file size in bytes to human readable format
+     * @param {number} bytes - Size in bytes
+     * @returns {string} Formatted size
+     */
+    function formatFileSize(bytes) {
+        if (!bytes && bytes !== 0) return 'N/A';
+        
+        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        let size = bytes;
+        let unitIndex = 0;
+        
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        
+        return `${size.toFixed(1)} ${units[unitIndex]}`;
+    }
+
+    // Export utilities to window.formatting
+    window.formatting = {
+        formatDate,
+        formatStatus,
+        formatMode,
+        formatDuration,
+        formatFileSize
+    };
+})(); 

local_deep_research/web/static/js/components/fallback/ui.js

@@ -0,0 +1,215 @@
+/**
+ * UI Fallback Utilities
+ * Basic implementations of UI utilities that can be used if the main UI module is not available
+ */
+(function() {
+    // Only initialize if window.ui is not already defined
+    if (window.ui) {
+        console.log('Main UI utilities already available, skipping fallback');
+        return;
+    }
+
+    console.log('Initializing fallback UI utilities');
+
+    /**
+     * Show a loading spinner
+     * @param {HTMLElement} container - Container element for spinner
+     * @param {string} message - Optional loading message
+     */
+    function showSpinner(container, message) {
+        if (!container) container = document.body;
+        const spinnerHtml = `
+            <div class="loading-spinner centered">
+                <div class="spinner"></div>
+                ${message ? `<div class="spinner-message">${message}</div>` : ''}
+            </div>
+        `;
+        container.innerHTML = spinnerHtml;
+    }
+
+    /**
+     * Hide loading spinner
+     * @param {HTMLElement} container - Container with spinner
+     */
+    function hideSpinner(container) {
+        if (!container) container = document.body;
+        const spinner = container.querySelector('.loading-spinner');
+        if (spinner) {
+            spinner.remove();
+        }
+    }
+
+    /**
+     * Show an error message
+     * @param {string} message - Error message to display
+     */
+    function showError(message) {
+        console.error(message);
+        
+        // Create a notification element
+        const notification = document.createElement('div');
+        notification.className = 'notification error';
+        notification.innerHTML = `
+            <i class="fas fa-exclamation-circle"></i>
+            <span>${message}</span>
+            <button class="close-notification"><i class="fas fa-times"></i></button>
+        `;
+        
+        // Add to the page if a notification container exists, otherwise use alert
+        const container = document.querySelector('.notifications-container');
+        if (container) {
+            container.appendChild(notification);
+            
+            // Remove after a delay
+            setTimeout(() => {
+                notification.classList.add('removing');
+                setTimeout(() => notification.remove(), 500);
+            }, 5000);
+            
+            // Set up close button
+            const closeBtn = notification.querySelector('.close-notification');
+            if (closeBtn) {
+                closeBtn.addEventListener('click', () => {
+                    notification.classList.add('removing');
+                    setTimeout(() => notification.remove(), 500);
+                });
+            }
+        } else {
+            // Fallback to alert
+            alert(message);
+        }
+    }
+
+    /**
+     * Show a success/info message
+     * @param {string} message - Message to display
+     */
+    function showMessage(message) {
+        console.log(message);
+        
+        // Create a notification element
+        const notification = document.createElement('div');
+        notification.className = 'notification success';
+        notification.innerHTML = `
+            <i class="fas fa-check-circle"></i>
+            <span>${message}</span>
+            <button class="close-notification"><i class="fas fa-times"></i></button>
+        `;
+        
+        // Add to the page if a notification container exists, otherwise use alert
+        const container = document.querySelector('.notifications-container');
+        if (container) {
+            container.appendChild(notification);
+            
+            // Remove after a delay
+            setTimeout(() => {
+                notification.classList.add('removing');
+                setTimeout(() => notification.remove(), 500);
+            }, 5000);
+            
+            // Set up close button
+            const closeBtn = notification.querySelector('.close-notification');
+            if (closeBtn) {
+                closeBtn.addEventListener('click', () => {
+                    notification.classList.add('removing');
+                    setTimeout(() => notification.remove(), 500);
+                });
+            }
+        } else {
+            // Fallback to alert
+            alert(message);
+        }
+    }
+
+    /**
+     * Simple markdown renderer
+     * @param {string} markdown - Markdown content
+     * @returns {string} HTML content
+     */
+    function renderMarkdown(markdown) {
+        if (!markdown) return '';
+        
+        // This is a very basic markdown renderer for fallback purposes
+        let html = markdown;
+        
+        // Convert headers
+        html = html.replace(/^# (.*$)/gm, '<h1>$1</h1>');
+        html = html.replace(/^## (.*$)/gm, '<h2>$1</h2>');
+        html = html.replace(/^### (.*$)/gm, '<h3>$1</h3>');
+        html = html.replace(/^#### (.*$)/gm, '<h4>$1</h4>');
+        html = html.replace(/^##### (.*$)/gm, '<h5>$1</h5>');
+        
+        // Convert code blocks
+        html = html.replace(/```([\s\S]*?)```/g, '<pre><code>$1</code></pre>');
+        
+        // Convert inline code
+        html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
+        
+        // Convert bold
+        html = html.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
+        
+        // Convert italic
+        html = html.replace(/\*(.*?)\*/g, '<em>$1</em>');
+        
+        // Convert links
+        html = html.replace(/\[(.*?)\]\((.*?)\)/g, '<a href="$2">$1</a>');
+        
+        // Convert paragraphs - this is simplistic
+        html = html.replace(/\n\s*\n/g, '</p><p>');
+        html = '<p>' + html + '</p>';
+        
+        // Fix potentially broken paragraph tags
+        html = html.replace(/<\/p><p><\/p><p>/g, '</p><p>');
+        html = html.replace(/<\/p><p><(h[1-5])/g, '</p><$1');
+        html = html.replace(/<\/(h[1-5])><p>/g, '</$1>');
+        
+        return html;
+    }
+
+    /**
+     * Update favicon to indicate status
+     * @param {string} status - Status to indicate (active, complete, error)
+     */
+    function updateFavicon(status) {
+        try {
+            const faviconLink = document.querySelector('link[rel="icon"]') || 
+                document.querySelector('link[rel="shortcut icon"]');
+            
+            if (!faviconLink) {
+                console.warn('Favicon link not found');
+                return;
+            }
+            
+            let iconPath;
+            switch (status) {
+                case 'active':
+                    iconPath = '/research/static/img/favicon-active.ico';
+                    break;
+                case 'complete':
+                    iconPath = '/research/static/img/favicon-complete.ico';
+                    break;
+                case 'error':
+                    iconPath = '/research/static/img/favicon-error.ico';
+                    break;
+                default:
+                    iconPath = '/research/static/img/favicon.ico';
+            }
+            
+            // Add cache busting parameter to force reload
+            faviconLink.href = iconPath + '?v=' + new Date().getTime();
+            console.log('Updated favicon to:', status);
+        } catch (error) {
+            console.error('Failed to update favicon:', error);
+        }
+    }
+
+    // Export utilities to window.ui
+    window.ui = {
+        showSpinner,
+        hideSpinner,
+        showError,
+        showMessage,
+        renderMarkdown,
+        updateFavicon
+    };
+})();