not answering even tho there is information in the document

script.js

@@ -13,66 +13,171 @@ async function processDocument(file) {
         reader.readAsText(file);
     });
 }
-// Enhanced document search function with semantic matching
+// Enhanced document search with better matching and context
 function searchDocument(question) {
     if (!documentContent) return "Please upload a document first.";
 
     const questionLower = question.toLowerCase();
     const docLower = documentContent.toLowerCase();
     
-    // Split into paragraphs first for better context
-    const paragraphs = documentContent.split('\n\n');
+    // Split into meaningful units (paragraphs or sections)
+    const sections = documentContent.split(/\n\s*\n+/);
     
-    // Search for direct matches first
-    for (const paragraph of paragraphs) {
-        const paraLower = paragraph.toLowerCase();
+    // First try exact matches or very close matches
+    for (const section of sections) {
+        const sectionLower = section.toLowerCase();
         
-        if (paraLower.includes(questionLower) || 
-            (questionLower.includes('what') && paraLower.includes('is') && paraLower.includes(questionLower.split('what is ')[1]))) {
-            // Clean up the paragraph and return the most relevant sentence
-            const sentences = paragraph.split(/[.!?]+/);
-            for (const sentence of sentences) {
-                if (sentence.toLowerCase().includes(questionLower)) {
-                    return sentence.trim() + '.';
-                }
+        // Check for direct question matches
+        if (sectionLower.includes(questionLower)) {
+            return extractBestAnswer(section, questionLower);
+        }
+        
+        // Check for "what is" questions
+        if (questionLower.startsWith('what is') || questionLower.startsWith('what are')) {
+            const targetTerm = questionLower.split(' ').slice(2).join(' ');
+            if (sectionLower.includes(targetTerm)) {
+                return extractDefinition(section, targetTerm);
+            }
+        }
+        
+        // Check for "how to" questions
+        if (questionLower.startsWith('how to') || questionLower.startsWith('how do')) {
+            const action = questionLower.split(' ').slice(2).join(' ');
+            if (sectionLower.includes(action)) {
+                return extractInstructions(section, action);
             }
-            return paragraph.trim();
         }
     }
 
-    // If no direct match, try to find related content
-    const keywords = questionLower.split(' ');
-    let bestMatch = '';
-    let highestScore = 0;
+    // Try semantic matching with weighted keywords
+    const keywords = extractKeywords(questionLower);
+    let bestMatch = { text: '', score: 0 };
     
-    for (const paragraph of paragraphs) {
-        const paraLower = paragraph.toLowerCase();
+    for (const section of sections) {
+        const sectionLower = section.toLowerCase();
         let score = 0;
         
-        for (const word of keywords) {
-            if (word.length > 3 && paraLower.includes(word)) {
-                score++;
+        for (const keyword of keywords) {
+            if (sectionLower.includes(keyword)) {
+                score += keyword.weight;
+                
+                // Bonus for proximity to other keywords
+                const keywordPos = sectionLower.indexOf(keyword);
+                for (const otherKeyword of keywords) {
+                    if (otherKeyword !== keyword) {
+                        const otherPos = sectionLower.indexOf(otherKeyword);
+                        if (otherPos !== -1 && Math.abs(keywordPos - otherPos) < 100) {
+                            score += 5;
+                        }
+                    }
+                }
+            }
+        }
+        
+        if (score > bestMatch.score) {
+            bestMatch = { text: section, score };
+        }
+    }
+    
+    if (bestMatch.score > 0) {
+        return extractRelevantPart(bestMatch.text, keywords);
+    }
+    
+    // As last resort, try to find any relevant information
+    const relevant = findAnyRelevant(questionLower, sections);
+    if (relevant) return relevant;
+    
+    return "I found some information that might be relevant, but couldn't find a direct answer to your question. Try asking differently or check these sections:\n" + 
+           findPossibleSections(questionLower, sections);
+}
+
+// Helper functions
+function extractKeywords(question) {
+    const words = question.split(' ').filter(w => w.length > 3);
+    const weights = {
+        'what': 1, 'how': 2, 'why': 2, 'when': 2, 'where': 2,
+        'is': 1, 'are': 1, 'does': 2, 'do': 1, 'can': 2,
+        'explain': 3, 'describe': 3, 'define': 3, 'list': 2
+    };
+    
+    return words.map(word => ({
+        word: word,
+        weight: weights[word] || 1
+    }));
+}
+
+function extractBestAnswer(text, question) {
+    // Split into sentences
+    const sentences = text.split(/[.!?]+/).map(s => s.trim()).filter(s => s);
+    
+    // Find the most relevant sentence
+    for (const sentence of sentences) {
+        if (sentence.toLowerCase().includes(question)) {
+            return sentence + '.';
+        }
+    }
+    
+    // If no exact match, return first few sentences
+    return sentences.slice(0, 3).join(' ') + '...';
+}
+
+function extractDefinition(text, term) {
+    const sentences = text.split(/[.!?]+/);
+    for (let i = 0; i < sentences.length; i++) {
+        if (sentences[i].toLowerCase().includes(term)) {
+            // Try to get the definition sentence
+            if (sentences[i].toLowerCase().includes('is') || sentences[i].toLowerCase().includes('are')) {
+                return sentences[i].trim() + '.';
+            }
+            // Or combine with next sentence
+            if (i < sentences.length - 1) {
+                return (sentences[i] + ' ' + sentences[i+1]).trim() + '.';
             }
         }
+    }
+    return text.split('\n')[0]; // Fallback to first line
+}
+
+function findAnyRelevant(question, sections) {
+    const keywords = extractKeywords(question).map(k => k.word);
+    
+    for (const section of sections) {
+        const sectionLower = section.toLowerCase();
+        let matches = 0;
+        
+        for (const keyword of keywords) {
+            if (sectionLower.includes(keyword)) matches++;
+        }
         
-        if (score > highestScore) {
-            highestScore = score;
-            bestMatch = paragraph;
+        if (matches >= keywords.length / 2) {
+            return "This might help:\n" + section.split('\n').slice(0, 3).join('\n') + '...';
         }
     }
     
-    if (bestMatch) {
-        // Extract the most relevant sentence
-        const sentences = bestMatch.split(/[.!?]+/);
-        for (const sentence of sentences) {
-            if (sentence.toLowerCase().includes(keywords[0])) {
-                return sentence.trim() + '.';
+    return null;
+}
+
+function findPossibleSections(question, sections) {
+    const keywords = extractKeywords(question).map(k => k.word);
+    const relevantSections = [];
+    
+    for (const section of sections) {
+        const sectionLower = section.toLowerCase();
+        let matches = 0;
+        
+        for (const keyword of keywords) {
+            if (sectionLower.includes(keyword)) matches++;
+        }
+        
+        if (matches > 0) {
+            const firstLine = section.split('\n')[0];
+            if (firstLine && !relevantSections.includes(firstLine)) {
+                relevantSections.push(firstLine);
             }
         }
-        return bestMatch.trim();
     }
     
-    return "I couldn't find a specific answer in the document. Please try rephrasing your question.";
+    return relevantSections.slice(0, 3).map(s => "• " + s).join('\n');
 }
 async function askQuestion(question) {
     if (!documentContent) {