Update templates/index.html

templates/index.html

@@ -345,6 +345,9 @@
                 row.parentNode.insertBefore(insightsRow, row.nextSibling);
             }
             
+            // Store the row reference as a data attribute on the container for later access
+            insightsContainer.dataset.parentRow = row.rowIndex;
+            
             // Send request to extract insights
             fetch('/post_insights', {
                 method: 'POST',
@@ -371,25 +374,47 @@
                     const insightsActions = document.createElement('div');
                     insightsActions.className = 'insights-actions';
                     
+                    // Store the insights for this specific container
+                    const containerInsights = [...data.result.insights];
+                    insightsContainer.dataset.allInsights = JSON.stringify(containerInsights);
+                    
                     const selectAllBtn = document.createElement('button');
-                    selectAllBtn.className = 'insights-button';
+                    selectAllBtn.className = 'insights-button select-all-btn';
                     selectAllBtn.textContent = 'Select All';
-                    selectAllBtn.onclick = function() {
-                        const tags = insightsContainer.querySelectorAll('.insight-tag');
+                    // Use a closure to ensure the button has access to the correct container and row
+                    selectAllBtn.addEventListener('click', function() {
+                        const container = this.closest('.insights-container');
+                        const parentRow = row;
+                        const allInsights = JSON.parse(container.dataset.allInsights || '[]');
+                        
+                        const tags = container.querySelectorAll('.insight-tag');
                         tags.forEach(tag => tag.classList.add('selected'));
-                        row.dataset.selectedInsights = JSON.stringify(data.result.insights);
-                        row.dataset.unselectedInsights = JSON.stringify([]);
-                    };
+                        
+                        parentRow.dataset.selectedInsights = JSON.stringify(allInsights);
+                        parentRow.dataset.unselectedInsights = JSON.stringify([]);
+                        
+                        // Trigger check for enabling/disabling enhance button
+                        checkSelectedInsights();
+                    });
                     
                     const clearAllBtn = document.createElement('button');
-                    clearAllBtn.className = 'insights-button';
+                    clearAllBtn.className = 'insights-button clear-all-btn';
                     clearAllBtn.textContent = 'Clear All';
-                    clearAllBtn.onclick = function() {
-                        const tags = insightsContainer.querySelectorAll('.insight-tag');
+                    // Use a closure to ensure the button has access to the correct container and row
+                    clearAllBtn.addEventListener('click', function() {
+                        const container = this.closest('.insights-container');
+                        const parentRow = row;
+                        const allInsights = JSON.parse(container.dataset.allInsights || '[]');
+                        
+                        const tags = container.querySelectorAll('.insight-tag');
                         tags.forEach(tag => tag.classList.remove('selected'));
-                        row.dataset.selectedInsights = JSON.stringify([]);
-                        row.dataset.unselectedInsights = JSON.stringify(data.result.insights);
-                    };
+                        
+                        parentRow.dataset.selectedInsights = JSON.stringify([]);
+                        parentRow.dataset.unselectedInsights = JSON.stringify(allInsights);
+                        
+                        // Trigger check for enabling/disabling enhance button
+                        checkSelectedInsights();
+                    });
                     
                     insightsActions.appendChild(selectAllBtn);
                     insightsActions.appendChild(clearAllBtn);
@@ -415,12 +440,15 @@
                         const tagElement = document.createElement('div');
                         tagElement.className = 'insight-tag';
                         tagElement.textContent = insight;
-                        tagElement.onclick = function() {
-                            tagElement.classList.toggle('selected');
+                        tagElement.addEventListener('click', function() {
+                            this.classList.toggle('selected');
                             
                             // Update selected insights
                             updateSelectedInsights(row, insightsContainer);
-                        };
+                            
+                            // Trigger check for enabling/disabling enhance button
+                            checkSelectedInsights();
+                        });
                         
                         // Add to selected by default
                         tagElement.classList.add('selected');
@@ -433,6 +461,9 @@
                     row.dataset.selectedInsights = JSON.stringify(selectedInsights);
                     row.dataset.unselectedInsights = JSON.stringify(unselectedInsights);
                     
+                    // Trigger check for enabling/disabling enhance button immediately
+                    checkSelectedInsights();
+                    
                 } else {
                     insightsContainer.innerHTML = '<div class="error">No insights found</div>';
                 }
@@ -1202,6 +1233,584 @@
             
             return accordionSection;
         }
+
+        // Extract insights from all analyzed documents
+        function extractAllInsights() {
+            const patentBackground = document.getElementById('userInput').value.trim();
+            if (!patentBackground) {
+                alert('Please provide a patent background in the input field');
+                return;
+            }
+            
+            // Show loading overlay
+            const loadingOverlay = document.getElementById('globalLoadingOverlay');
+            if (loadingOverlay) {
+                loadingOverlay.style.display = 'flex';
+                loadingOverlay.querySelector('.progress-text').textContent = 'Extracting insights from all documents...';
+            }
+            
+            // Get all query items
+            const queryItems = document.querySelectorAll('.query-item');
+            let totalDocuments = 0;
+            let completedDocuments = 0;
+            
+            // Count total analyzed documents that need insights extraction
+            const analyzedRows = [];
+            queryItems.forEach(queryItem => {
+                const rows = queryItem.querySelectorAll('tbody tr:not(.insights-row)');
+                rows.forEach(row => {
+                    // Only include rows that have been analyzed (have score and justification cells)
+                    if (row.cells.length > 4 && row.cells[4].textContent.trim() !== 'Error' && 
+                        row.cells[4].textContent.trim() !== 'N/A' && row.cells[4].textContent.trim() !== '') {
+                        analyzedRows.push(row);
+                        totalDocuments++;
+                    }
+                });
+            });
+            
+            if (totalDocuments === 0) {
+                if (loadingOverlay) loadingOverlay.style.display = 'none';
+                alert('No analyzed documents found. Please analyze documents first.');
+                return;
+            }
+            
+            // Function to update progress
+            function updateProgress() {
+                completedDocuments++;
+                if (loadingOverlay) {
+                    const progressElement = loadingOverlay.querySelector('.progress-text');
+                    if (progressElement) {
+                        progressElement.textContent = `Extracting insights: ${completedDocuments}/${totalDocuments}`;
+                    }
+                }
+                
+                if (completedDocuments >= totalDocuments) {
+                    if (loadingOverlay) loadingOverlay.style.display = 'none';
+                    checkSelectedInsights(); // Update enhance button state based on selected insights
+                }
+            }
+            
+            // Process each analyzed document sequentially to avoid overwhelming the server
+            function processNextDocument(index) {
+                if (index >= analyzedRows.length) {
+                    return; // All documents processed
+                }
+                
+                const row = analyzedRows[index];
+                const urlLink = row.querySelector('.url-link');
+                const documentType = row.cells[0].textContent.toLowerCase();
+                
+                if (!urlLink || !urlLink.href) {
+                    updateProgress();
+                    processNextDocument(index + 1);
+                    return;
+                }
+                
+                // Check if there's already an insights row for this document
+                let insightsRow = row.nextElementSibling;
+                if (insightsRow && insightsRow.className === 'insights-row') {
+                    // Insights row already exists, get the container
+                    insightsContainer = insightsRow.querySelector('.insights-container');
+                    insightsContainer.innerHTML = '<div class="loading-spinner"></div><div>Extracting insights...</div>';
+                } else {
+                    // Create insights row that spans across all columns
+                    insightsRow = document.createElement('tr');
+                    insightsRow.className = 'insights-row';
+                    
+                    const insightsTd = document.createElement('td');
+                    insightsTd.colSpan = row.cells.length;
+                    
+                    insightsContainer = document.createElement('div');
+                    insightsContainer.className = 'insights-container';
+                    insightsContainer.innerHTML = '<div class="loading-spinner"></div><div>Extracting insights...</div>';
+                    
+                    insightsTd.appendChild(insightsContainer);
+                    insightsRow.appendChild(insightsTd);
+                    
+                    // Insert after the current row
+                    row.parentNode.insertBefore(insightsRow, row.nextSibling);
+                }
+                
+                // Store the row reference as a data attribute on the container for later access
+                insightsContainer.dataset.parentRow = row.rowIndex;
+                
+                // Send request to extract insights
+                fetch('/post_insights', {
+                    method: 'POST',
+                    body: JSON.stringify({ 
+                        'patent_background': patentBackground, 
+                        'pdf_url': urlLink.href,
+                        'data_type': documentType
+                    }),
+                    headers: { 'Content-Type': 'application/json' }
+                })
+                .then(response => response.json())
+                .then(data => {
+                    if (data.error) {
+                        insightsContainer.innerHTML = `<div class="error">Error: ${data.error}</div>`;
+                    } else if (data.result && data.result.insights) {
+                        // Create header with title and actions
+                        const insightsHeader = document.createElement('div');
+                        insightsHeader.className = 'insights-header';
+                        
+                        const insightsTitle = document.createElement('div');
+                        insightsTitle.className = 'insights-title';
+                        insightsTitle.textContent = 'Document Insights';
+                        
+                        const insightsActions = document.createElement('div');
+                        insightsActions.className = 'insights-actions';
+                        
+                        // Store the insights for this specific container
+                        const containerInsights = [...data.result.insights];
+                        insightsContainer.dataset.allInsights = JSON.stringify(containerInsights);
+                        
+                        const selectAllBtn = document.createElement('button');
+                        selectAllBtn.className = 'insights-button select-all-btn';
+                        selectAllBtn.textContent = 'Select All';
+                        selectAllBtn.addEventListener('click', function() {
+                            const container = this.closest('.insights-container');
+                            const parentRow = row;
+                            const allInsights = JSON.parse(container.dataset.allInsights || '[]');
+                            
+                            const tags = container.querySelectorAll('.insight-tag');
+                            tags.forEach(tag => tag.classList.add('selected'));
+                            
+                            parentRow.dataset.selectedInsights = JSON.stringify(allInsights);
+                            parentRow.dataset.unselectedInsights = JSON.stringify([]);
+                            
+                            checkSelectedInsights();
+                        });
+                        
+                        const clearAllBtn = document.createElement('button');
+                        clearAllBtn.className = 'insights-button clear-all-btn';
+                        clearAllBtn.textContent = 'Clear All';
+                        clearAllBtn.addEventListener('click', function() {
+                            const container = this.closest('.insights-container');
+                            const parentRow = row;
+                            const allInsights = JSON.parse(container.dataset.allInsights || '[]');
+                            
+                            const tags = container.querySelectorAll('.insight-tag');
+                            tags.forEach(tag => tag.classList.remove('selected'));
+                            
+                            parentRow.dataset.selectedInsights = JSON.stringify([]);
+                            parentRow.dataset.unselectedInsights = JSON.stringify(allInsights);
+                            
+                            checkSelectedInsights();
+                        });
+                        
+                        insightsActions.appendChild(selectAllBtn);
+                        insightsActions.appendChild(clearAllBtn);
+                        
+                        insightsHeader.appendChild(insightsTitle);
+                        insightsHeader.appendChild(insightsActions);
+                        
+                        // Create insight tags
+                        const insightsList = document.createElement('div');
+                        insightsList.className = 'insights-list';
+                        
+                        // Clear the container and add the new elements
+                        insightsContainer.innerHTML = '';
+                        insightsContainer.appendChild(insightsHeader);
+                        insightsContainer.appendChild(insightsList);
+                        
+                        // Initialize selected insights
+                        const selectedInsights = [];
+                        const unselectedInsights = [];
+                        
+                        // Add insight tags
+                        data.result.insights.forEach(insight => {
+                            const tagElement = document.createElement('div');
+                            tagElement.className = 'insight-tag';
+                            tagElement.textContent = insight;
+                            tagElement.addEventListener('click', function() {
+                                this.classList.toggle('selected');
+                                updateSelectedInsights(row, insightsContainer);
+                                checkSelectedInsights();
+                            });
+                            
+                            // Add to selected by default
+                            tagElement.classList.add('selected');
+                            selectedInsights.push(insight);
+                            
+                            insightsList.appendChild(tagElement);
+                        });
+                        
+                        // Store initial selections
+                        row.dataset.selectedInsights = JSON.stringify(selectedInsights);
+                        row.dataset.unselectedInsights = JSON.stringify(unselectedInsights);
+                        
+                    } else {
+                        insightsContainer.innerHTML = '<div class="error">No insights found</div>';
+                    }
+                    
+                    // Process next document
+                    updateProgress();
+                    processNextDocument(index + 1);
+                })
+                .catch(error => {
+                    console.error('Error:', error);
+                    insightsContainer.innerHTML = `<div class="error">Error extracting insights: ${error.message}</div>`;
+                    
+                    // Continue with next document even if this one failed
+                    updateProgress();
+                    processNextDocument(index + 1);
+                });
+            }
+            
+            // Start processing documents
+            processNextDocument(0);
+        }
+        
+        // Check if any documents have been analyzed to enable/disable Extract All Insights button
+        function checkAnalyzedDocuments() {
+            const queryItems = document.querySelectorAll('.query-item');
+            let hasAnalyzedDocuments = false;
+            
+            queryItems.forEach(queryItem => {
+                const rows = queryItem.querySelectorAll('tbody tr:not(.insights-row)');
+                rows.forEach(row => {
+                    // Check if the row has score and justification cells (has been analyzed)
+                    if (row.cells.length > 4 && row.cells[4].textContent.trim() !== 'Error' && 
+                        row.cells[4].textContent.trim() !== '') {
+                        hasAnalyzedDocuments = true;
+                    }
+                });
+            });
+            
+            const extractAllButton = document.getElementById('extractAllInsightsButton');
+            if (hasAnalyzedDocuments) {
+                extractAllButton.classList.remove('disabled');
+                extractAllButton.disabled = false;
+            } else {
+                extractAllButton.classList.add('disabled');
+                extractAllButton.disabled = true;
+            }
+        }
+
+        // Group insights by score and display in a consolidated table
+        function groupInsightsByScore() {
+            // Get all query items
+            const queryItems = document.querySelectorAll('.query-item');
+            let hasInsights = false;
+            
+            // Create structure to hold insights grouped by score
+            const insightsByScore = {
+                5: { insights: [], sources: [] },
+                4: { insights: [], sources: [] },
+                3: { insights: [], sources: [] },
+                2: { insights: [], sources: [] },
+                1: { insights: [], sources: [] },
+                0: { insights: [], sources: [] }
+            };
+            
+            // Collect all insights from all documents and group by score
+            queryItems.forEach(queryItem => {
+                const rows = queryItem.querySelectorAll('tbody tr:not(.insights-row)');
+                rows.forEach(row => {
+                    // Skip if no score or insights
+                    if (row.cells.length <= 4 || !row.dataset.selectedInsights) {
+                        return;
+                    }
+                    
+                    // Get the score
+                    const scoreText = row.cells[4].textContent.trim();
+                    if (scoreText === 'Error' || scoreText === 'N/A' || isNaN(parseFloat(scoreText))) {
+                        return;
+                    }
+                    
+                    const score = Math.round(parseFloat(scoreText));
+                    const urlLink = row.querySelector('.url-link');
+                    
+                    if (!urlLink) return;
+                    
+                    // Get insights from this document
+                    try {
+                        const selectedInsights = JSON.parse(row.dataset.selectedInsights || '[]');
+                        const unselectedInsights = JSON.parse(row.dataset.unselectedInsights || '[]');
+                        const allInsights = [...selectedInsights, ...unselectedInsights];
+                        
+                        // Add insights to the appropriate score group
+                        if (score >= 0 && score <= 5 && allInsights.length > 0) {
+                            hasInsights = true;
+                            
+                            // For all insights in this document
+                            allInsights.forEach(insight => {
+                                // Check if this insight is already in the group
+                                const existingIndex = insightsByScore[score].insights.findIndex(i => i === insight);
+                                
+                                if (existingIndex === -1) {
+                                    // New insight
+                                    insightsByScore[score].insights.push(insight);
+                                    insightsByScore[score].sources.push({
+                                        url: urlLink.href,
+                                        title: row.cells[1].textContent.trim().substring(0, 30) + '...',
+                                        selected: selectedInsights.includes(insight)
+                                    });
+                                }
+                            });
+                        }
+                    } catch (e) {
+                        console.error('Error parsing insights:', e);
+                    }
+                });
+            });
+            
+            if (!hasInsights) {
+                alert('No insights found. Please analyze documents and extract insights first.');
+                return;
+            }
+            
+            // Create or get the grouped insights container
+            let container = document.getElementById('groupedInsightsContainer');
+            if (!container) {
+                container = document.createElement('div');
+                container.id = 'groupedInsightsContainer';
+                container.className = 'grouped-insights-container';
+                
+                // Insert after the problem input card
+                const card = document.querySelector('.card');
+                card.parentNode.insertBefore(container, card.nextSibling);
+            }
+            
+            // Create header
+            const header = document.createElement('div');
+            header.className = 'grouped-insights-header';
+            header.innerHTML = `
+                <div>Insights Grouped by Score</div>
+                <div class="grouped-insights-close" onclick="closeGroupedInsights()">&times;</div>
+            `;
+            
+            // Create content area
+            const content = document.createElement('div');
+            content.className = 'grouped-insights-content';
+            
+            // Create score groups
+            for (let score = 5; score >= 0; score--) {
+                const insights = insightsByScore[score].insights;
+                const sources = insightsByScore[score].sources;
+                
+                if (insights.length === 0) continue;
+                
+                const scoreGroup = document.createElement('div');
+                scoreGroup.className = 'score-group';
+                scoreGroup.dataset.score = score;
+                
+                // Create score header
+                const scoreHeader = document.createElement('div');
+                scoreHeader.className = 'score-group-header';
+                
+                let scoreColor = '';
+                if (score >= 0 && score <= 5) {
+                    const redComponent = Math.floor((score / 5) * 255);
+                    const greenComponent = Math.floor(((5 - score) / 5) * 255);
+                    scoreColor = `background-color: rgb(${redComponent}, ${greenComponent}, 0); color: white;`;
+                }
+                
+                scoreHeader.innerHTML = `
+                    <div>
+                        <span style="display: inline-block; width: 25px; height: 25px; text-align: center; border-radius: 50%; ${scoreColor} font-weight: bold;">${score}</span>
+                        <span style="margin-left: 8px;">Score ${score} Insights (${insights.length})</span>
+                    </div>
+                    <div class="score-group-actions">
+                        <button class="insights-button select-score-all-btn" onclick="selectAllInScore(${score})">Select All</button>
+                        <button class="insights-button clear-score-all-btn" onclick="clearAllInScore(${score})">Clear All</button>
+                    </div>
+                `;
+                
+                // Create insights list
+                const insightsList = document.createElement('div');
+                insightsList.className = 'score-insights-list';
+                
+                // Add each insight
+                insights.forEach((insight, index) => {
+                    const source = sources[index];
+                    const tagElement = document.createElement('div');
+                    tagElement.className = `grouped-insight-tag${source.selected ? ' selected' : ''}`;
+                    tagElement.dataset.score = score;
+                    tagElement.dataset.index = index;
+                    tagElement.dataset.source = source.url;
+                    
+                    // Create insight text with source link
+                    tagElement.innerHTML = `
+                        ${insight}
+                        <a href="${source.url}" target="_blank" class="insight-source" title="${source.title}">${score}</a>
+                    `;
+                    
+                    // Add click event to toggle selection
+                    tagElement.addEventListener('click', function(e) {
+                        // Prevent clicking on the source link from toggling selection
+                        if (e.target.classList.contains('insight-source')) return;
+                        
+                        this.classList.toggle('selected');
+                        updateGroupedInsightSelections();
+                    });
+                    
+                    insightsList.appendChild(tagElement);
+                });
+                
+                // Add header and list to score group
+                scoreGroup.appendChild(scoreHeader);
+                scoreGroup.appendChild(insightsList);
+                
+                // Add score group to content
+                content.appendChild(scoreGroup);
+            }
+            
+            // Clear the container and add new content
+            container.innerHTML = '';
+            container.appendChild(header);
+            container.appendChild(content);
+            
+            // Show the container
+            container.style.display = 'block';
+            
+            // Collapse all accordions
+            const accordions = document.querySelectorAll('.accordion-section');
+            accordions.forEach(accordion => {
+                const header = accordion.querySelector('.accordion-header');
+                const body = accordion.querySelector('.accordion-body');
+                if (header && body && !header.classList.contains('collapsed')) {
+                    header.classList.add('collapsed');
+                    body.classList.add('collapsed');
+                    
+                    // Update the toggle icon
+                    const toggleIcon = header.querySelector('.toggle-icon');
+                    if (toggleIcon) toggleIcon.textContent = '▶';
+                }
+            });
+            
+            // Scroll to the insights container
+            container.scrollIntoView({ behavior: 'smooth' });
+        }
+        
+        // Close the grouped insights view
+        function closeGroupedInsights() {
+            const container = document.getElementById('groupedInsightsContainer');
+            if (container) {
+                container.style.display = 'none';
+            }
+        }
+        
+        // Select all insights for a specific score
+        function selectAllInScore(score) {
+            const container = document.getElementById('groupedInsightsContainer');
+            const tags = container.querySelectorAll(`.grouped-insight-tag[data-score="${score}"]`);
+            
+            tags.forEach(tag => {
+                tag.classList.add('selected');
+            });
+            
+            updateGroupedInsightSelections();
+        }
+        
+        // Clear all insights for a specific score
+        function clearAllInScore(score) {
+            const container = document.getElementById('groupedInsightsContainer');
+            const tags = container.querySelectorAll(`.grouped-insight-tag[data-score="${score}"]`);
+            
+            tags.forEach(tag => {
+                tag.classList.remove('selected');
+            });
+            
+            updateGroupedInsightSelections();
+        }
+        
+        // Update the selection state of insights in their original document rows
+        function updateGroupedInsightSelections() {
+            // Get all selected insights from the grouped view
+            const container = document.getElementById('groupedInsightsContainer');
+            const selectedTags = container.querySelectorAll('.grouped-insight-tag.selected');
+            
+            // Create a mapping of URL to selected insights
+            const selectionsBySource = {};
+            
+            // Process each selected tag
+            selectedTags.forEach(tag => {
+                const insight = tag.textContent.trim().replace(/\d+$/, '').trim(); // Remove the score number at the end
+                const sourceUrl = tag.dataset.source;
+                
+                if (!selectionsBySource[sourceUrl]) {
+                    selectionsBySource[sourceUrl] = [];
+                }
+                
+                selectionsBySource[sourceUrl].push(insight);
+            });
+            
+            // Now update the original document rows
+            const queryItems = document.querySelectorAll('.query-item');
+            queryItems.forEach(queryItem => {
+                const rows = queryItem.querySelectorAll('tbody tr:not(.insights-row)');
+                rows.forEach(row => {
+                    const urlLink = row.querySelector('.url-link');
+                    if (!urlLink) return;
+                    
+                    const sourceUrl = urlLink.href;
+                    
+                    // If we have selections for this source
+                    if (selectionsBySource[sourceUrl]) {
+                        // Get all insights for this row
+                        try {
+                            // Combine selected and unselected to get all insights
+                            const currentSelected = JSON.parse(row.dataset.selectedInsights || '[]');
+                            const currentUnselected = JSON.parse(row.dataset.unselectedInsights || '[]');
+                            const allInsights = [...currentSelected, ...currentUnselected];
+                            
+                            // New selected and unselected based on grouped view
+                            const newSelected = [];
+                            const newUnselected = [];
+                            
+                            // Process each insight
+                            allInsights.forEach(insight => {
+                                if (selectionsBySource[sourceUrl].includes(insight)) {
+                                    newSelected.push(insight);
+                                } else {
+                                    newUnselected.push(insight);
+                                }
+                            });
+                            
+                            // Update the dataset
+                            row.dataset.selectedInsights = JSON.stringify(newSelected);
+                            row.dataset.unselectedInsights = JSON.stringify(newUnselected);
+                        } catch (e) {
+                            console.error('Error updating insights selections:', e);
+                        }
+                    }
+                });
+            });
+            
+            // Update enhance button state
+            checkSelectedInsights();
+        }
+        
+        // Check if any documents have been analyzed to enable/disable the Group Insights button
+        function checkGroupInsightsButton() {
+            const queryItems = document.querySelectorAll('.query-item');
+            let hasInsights = false;
+            
+            queryItems.forEach(queryItem => {
+                const rows = queryItem.querySelectorAll('tbody tr:not(.insights-row)');
+                rows.forEach(row => {
+                    if (row.dataset.selectedInsights || row.dataset.unselectedInsights) {
+                        try {
+                            const selected = JSON.parse(row.dataset.selectedInsights || '[]');
+                            const unselected = JSON.parse(row.dataset.unselectedInsights || '[]');
+                            if (selected.length > 0 || unselected.length > 0) {
+                                hasInsights = true;
+                            }
+                        } catch (e) {}
+                    }
+                });
+            });
+            
+            const groupInsightsButton = document.getElementById('groupInsightsByScoreButton');
+            if (hasInsights) {
+                groupInsightsButton.classList.remove('disabled');
+                groupInsightsButton.disabled = false;
+            } else {
+                groupInsightsButton.classList.add('disabled');
+                groupInsightsButton.disabled = true;
+            }
+        }
     </script>
 </head>
 <body>
@@ -1282,6 +1891,12 @@
         <button id="enhanceProblemButton" class="btn enhance-problem-button floating-button disabled" title="Enhance Problem using Selected Insights" onclick="enhanceProblem()" disabled>
             Enhance Problem
         </button>
+        <button id="groupInsightsByScoreButton" class="btn btn-group-insights floating-button disabled" title="Group All Insights by Score" onclick="groupInsightsByScore()" disabled>
+            Group Insights
+        </button>
+        <button id="extractAllInsightsButton" class="btn btn-info floating-button disabled" title="Extract Insights for All Analyzed Documents" onclick="extractAllInsights()" disabled>
+            Extract All Insights
+        </button>
         <button id="analyzeAllButton" class="btn btn-primary floating-button" title="Analyze All Unanalyzed Papers">
             Analyze All
         </button>
@@ -1310,9 +1925,16 @@
             // Check for selected insights periodically to enable/disable enhance button
             setInterval(checkSelectedInsights, 1000);
             
+            // Check for analyzed documents to enable/disable Extract All Insights button
+            setInterval(checkAnalyzedDocuments, 1000);
+            
+            // Check for insights to enable/disable Group Insights by Score button
+            setInterval(checkGroupInsightsButton, 1000);
+            
             // Analyze all button
             document.getElementById('analyzeAllButton').addEventListener('click', function() {
                 analyzeAllPapers();
+                // Button will be enabled when analyses complete and checkAnalyzedDocuments runs
             });
             
             // Remove failed button