claude_rag/config.py

@@ -66,7 +66,7 @@ class SearchConfig:
     default_limit: int = 10
     enable_bm25: bool = True
     similarity_threshold: float = 0.1
-    expand_queries: bool = False  # Enable automatic query expansion
+    expand_queries: bool = True  # Enable automatic query expansion
 
 
 @dataclass 

claude_rag/query_expander.py

@@ -2,32 +2,8 @@
 """
 Query Expander for Enhanced RAG Search
 
-## What This Does
-Automatically expands search queries to find more relevant results.
-
-Example: "authentication" becomes "authentication login user verification credentials"
-
-## How It Helps  
-- 2-3x more relevant search results
-- Works with any content (code, docs, notes, etc.)
-- Completely transparent to users
-- Uses small, fast LLMs (qwen3:1.7b) for ~100ms expansions
-
-## Usage
-```python
-from claude_rag.query_expander import QueryExpander
-from claude_rag.config import RAGConfig
-
-config = RAGConfig()
-expander = QueryExpander(config)
-
-# Expand a query
-expanded = expander.expand_query("error handling")
-# Result: "error handling exception try catch fault tolerance"
-```
-
-Perfect for beginners - enable in TUI for exploration, 
-disable in CLI for maximum speed.
+Automatically expands user queries with semantically related terms
+to dramatically improve search recall without increasing complexity.
 """
 
 import logging

claude_rag/search.py

@@ -19,7 +19,6 @@ from .ollama_embeddings import OllamaEmbedder as CodeEmbedder
 from .path_handler import display_path
 from .query_expander import QueryExpander
 from .config import ConfigManager
-from datetime import datetime, timedelta
 
 logger = logging.getLogger(__name__)
 console = Console()
@@ -355,8 +354,8 @@ class CodeSearcher:
             )
             hybrid_results.append(result)
         
-        # Apply smart re-ranking for better quality (zero overhead)
-        hybrid_results = self._smart_rerank(hybrid_results)
+        # Sort by combined score
+        hybrid_results.sort(key=lambda x: x.score, reverse=True)
         
         # Apply diversity constraints
         diverse_results = self._apply_diversity_constraints(hybrid_results, top_k)
@@ -367,69 +366,6 @@ class CodeSearcher:
         
         return diverse_results
     
-    def _smart_rerank(self, results: List[SearchResult]) -> List[SearchResult]:
-        """
-        Smart result re-ranking for better quality with zero overhead.
-        
-        Boosts scores based on:
-        - File importance (README, main files, configs)
-        - Content freshness (recently modified files)
-        - File type relevance
-        """
-        now = datetime.now()
-        
-        for result in results:
-            # File importance boost (20% boost for important files)
-            file_path_lower = str(result.file_path).lower()
-            important_patterns = [
-                'readme', 'main.', 'index.', '__init__', 'config',
-                'setup', 'install', 'getting', 'started', 'docs/',
-                'documentation', 'guide', 'tutorial', 'example'
-            ]
-            
-            if any(pattern in file_path_lower for pattern in important_patterns):
-                result.score *= 1.2
-                logger.debug(f"Important file boost: {result.file_path}")
-            
-            # Recency boost (10% boost for files modified in last week)
-            # Note: This uses file modification time if available in the data
-            try:
-                # Get file modification time (this is lightweight)
-                file_mtime = Path(result.file_path).stat().st_mtime
-                modified_date = datetime.fromtimestamp(file_mtime)
-                days_old = (now - modified_date).days
-                
-                if days_old <= 7:  # Modified in last week
-                    result.score *= 1.1
-                    logger.debug(f"Recent file boost: {result.file_path} ({days_old} days old)")
-                elif days_old <= 30:  # Modified in last month
-                    result.score *= 1.05
-                    
-            except (OSError, ValueError):
-                # File doesn't exist or can't get stats - no boost
-                pass
-            
-            # Content type relevance boost
-            if hasattr(result, 'chunk_type'):
-                if result.chunk_type in ['function', 'class', 'method']:
-                    # Code definitions are usually more valuable
-                    result.score *= 1.1
-                elif result.chunk_type in ['comment', 'docstring']:
-                    # Documentation is valuable for understanding
-                    result.score *= 1.05
-            
-            # Penalize very short content (likely not useful)
-            if len(result.content.strip()) < 50:
-                result.score *= 0.9
-            
-            # Small boost for content with good structure (has multiple lines)
-            lines = result.content.strip().split('\n')
-            if len(lines) >= 3 and any(len(line.strip()) > 10 for line in lines):
-                result.score *= 1.02
-        
-        # Sort by updated scores
-        return sorted(results, key=lambda x: x.score, reverse=True)
-    
     def _apply_diversity_constraints(self, results: List[SearchResult], top_k: int) -> List[SearchResult]:
         """
         Apply diversity constraints to search results.

docs/QUERY_EXPANSION.md

@@ -1,97 +0,0 @@
-# Query Expansion Guide
-
-## What Is Query Expansion?
-
-Query expansion automatically adds related terms to your search to find more relevant results.
-
-**Example:**
-- You search: `"authentication"`
-- System expands to: `"authentication login user verification credentials security"`
-- Result: 2-3x more relevant matches!
-
-## How It Works
-
-```mermaid
-graph LR
-    A[User Query] --> B[LLM Expands]
-    B --> C[Enhanced Search]
-    C --> D[Better Results]
-    
-    style A fill:#e1f5fe
-    style D fill:#e8f5e8
-```
-
-1. **Your query** goes to a small, fast LLM (like qwen3:1.7b)
-2. **LLM adds related terms** that people might use when writing about the topic
-3. **Both semantic and keyword search** use the expanded query
-4. **You get much better results** without changing anything
-
-## When Is It Enabled?
-
-- ❌ **CLI commands**: Disabled by default (for speed)
-- ✅ **TUI interface**: Auto-enabled (when you have time to explore)
-- ⚙️ **Configurable**: Can be enabled/disabled in config.yaml
-
-## Configuration
-
-Edit `config.yaml`:
-
-```yaml
-# Search behavior settings
-search:
-  expand_queries: false         # Enable automatic query expansion
-
-# LLM expansion settings  
-llm:
-  max_expansion_terms: 8        # How many terms to add
-  expansion_model: auto         # Which model to use
-  ollama_host: localhost:11434  # Ollama server
-```
-
-## Performance
-
-- **Speed**: ~100ms on most systems (depends on your hardware)
-- **Caching**: Repeated queries are instant
-- **Model Selection**: Automatically uses fastest available model
-
-## Examples
-
-**Code Search:**
-```
-"error handling" → "error handling exception try catch fault tolerance recovery"
-```
-
-**Documentation Search:**
-```
-"installation" → "installation setup install deploy configuration getting started"
-```
-
-**Any Content:**
-```
-"budget planning" → "budget planning financial forecast cost analysis spending plan"
-```
-
-## Troubleshooting
-
-**Query expansion not working?**
-1. Check if Ollama is running: `curl http://localhost:11434/api/tags`
-2. Verify you have a model installed: `ollama list`
-3. Check logs with `--verbose` flag
-
-**Too slow?**
-1. Disable in config.yaml: `expand_queries: false`
-2. Or use faster model: `expansion_model: "qwen3:0.6b"`
-
-**Poor expansions?**
-1. Try different model: `expansion_model: "qwen3:1.7b"`
-2. Reduce terms: `max_expansion_terms: 5`
-
-## Technical Details
-
-The QueryExpander class:
-- Uses temperature 0.1 for consistent results
-- Limits expansions to prevent very long queries
-- Handles model selection automatically
-- Includes smart caching to avoid repeated calls
-
-Perfect for beginners because it "just works" - enable it when you want better results, disable when you want maximum speed.

examples/config.yaml

@@ -41,13 +41,3 @@ search:
   default_limit: 10           # Default number of results
   enable_bm25: true             # Enable keyword matching boost
   similarity_threshold: 0.1        # Minimum similarity score
-  expand_queries: false         # Enable automatic query expansion (TUI auto-enables)
-
-# LLM synthesis and query expansion settings
-llm:
-  ollama_host: localhost:11434
-  synthesis_model: auto    # 'auto', 'qwen3:1.7b', etc.
-  expansion_model: auto     # Usually same as synthesis_model
-  max_expansion_terms: 8        # Maximum terms to add to queries
-  enable_synthesis: false       # Enable synthesis by default
-  synthesis_temperature: 0.3      # LLM temperature for analysis

rag-tui.py

@@ -306,8 +306,6 @@ class SimpleTUI:
             from claude_rag.search import CodeSearcher
             
             searcher = CodeSearcher(self.project_path)
-            # Enable query expansion in TUI for better results
-            searcher.config.search.expand_queries = True
             results = searcher.search(query, top_k=limit)
             
             if not results:

tests/03_system_validation.py

@@ -15,9 +15,7 @@ if sys.platform == 'win32':
 from claude_rag.chunker import CodeChunker
 from claude_rag.indexer import ProjectIndexer
 from claude_rag.search import CodeSearcher
-from claude_rag.ollama_embeddings import OllamaEmbedder as CodeEmbedder
-from claude_rag.query_expander import QueryExpander
-from claude_rag.config import RAGConfig
+from claude_rag.embeddings import CodeEmbedder
 
 def test_chunker():
     """Test that chunker creates chunks with all required metadata."""
@@ -321,63 +319,6 @@ def test_server():
         print(f"    Server error: {e}")
         return False
 
-def test_new_features():
-    """Test new features: query expansion and smart ranking."""
-    print("\n5. Testing New Features (Query Expansion & Smart Ranking)...")
-    
-    try:
-        # Test configuration loading
-        config = RAGConfig()
-        print(f"    ✅ Configuration loaded successfully")
-        print(f"       Query expansion enabled: {config.search.expand_queries}")
-        print(f"       Max expansion terms: {config.llm.max_expansion_terms}")
-        
-        # Test query expander (will use mock if Ollama unavailable)
-        expander = QueryExpander(config)
-        test_query = "authentication"
-        
-        if expander.is_available():
-            expanded = expander.expand_query(test_query)
-            print(f"    ✅ Query expansion working: '{test_query}' → '{expanded}'")
-        else:
-            print(f"    ⚠️  Query expansion offline (Ollama not available)")
-            # Test that it still returns original query
-            expanded = expander.expand_query(test_query)
-            if expanded == test_query:
-                print(f"    ✅ Graceful degradation working: returns original query")
-            else:
-                print(f"    ❌ Error: should return original query when offline")
-                return False
-        
-        # Test smart ranking (this always works as it's zero-overhead)
-        print("    🧮 Testing smart ranking...")
-        
-        # Create a simple test to verify the method exists and can be called
-        with tempfile.TemporaryDirectory() as temp_dir:
-            temp_path = Path(temp_dir)
-            
-            # Create a simple test project
-            test_file = temp_path / "README.md"
-            test_file.write_text("# Test Project\nThis is a test README file.")
-            
-            try:
-                searcher = CodeSearcher(temp_path)
-                # Test that the _smart_rerank method exists
-                if hasattr(searcher, '_smart_rerank'):
-                    print("    ✅ Smart ranking method available")
-                    return True
-                else:
-                    print("    ❌ Smart ranking method not found")
-                    return False
-                    
-            except Exception as e:
-                print(f"    ❌ Smart ranking test failed: {e}")
-                return False
-        
-    except Exception as e:
-        print(f"    ❌ New features test failed: {e}")
-        return False
-
 def main():
     """Run all integration tests."""
     print("=" * 50)
@@ -388,8 +329,7 @@ def main():
         "Chunker": test_chunker(),
         "Indexer": test_indexer_storage(), 
         "Search": test_search_integration(),
-        "Server": test_server(),
-        "New Features": test_new_features()
+        "Server": test_server()
     }
     
     print("\n" + "=" * 50)

tests/test_ollama_integration.py

@@ -1,321 +0,0 @@
-#!/usr/bin/env python3
-"""
-Beginner-Friendly Ollama Integration Tests
-
-These tests help users troubleshoot their Ollama setup and identify
-what's working and what needs attention.
-
-Run with: python3 tests/test_ollama_integration.py
-"""
-
-import unittest
-import requests
-import json
-import sys
-from pathlib import Path
-from unittest.mock import patch, MagicMock
-
-# Add project to path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from claude_rag.query_expander import QueryExpander
-from claude_rag.llm_synthesizer import LLMSynthesizer  
-from claude_rag.config import RAGConfig
-
-
-class TestOllamaIntegration(unittest.TestCase):
-    """
-    Tests to help beginners troubleshoot their Ollama setup.
-    
-    Each test explains what it's checking and gives clear feedback
-    about what's working or needs to be fixed.
-    """
-    
-    def setUp(self):
-        """Set up test configuration."""
-        self.config = RAGConfig()
-        print(f"\n🧪 Testing with Ollama host: {self.config.llm.ollama_host}")
-    
-    def test_01_ollama_server_running(self):
-        """
-        ✅ Check if Ollama server is running and responding.
-        
-        This test verifies that:
-        - Ollama is installed and running
-        - The API endpoint is accessible
-        - Basic connectivity works
-        """
-        print("\n📡 Testing Ollama server connectivity...")
-        
-        try:
-            response = requests.get(
-                f"http://{self.config.llm.ollama_host}/api/tags", 
-                timeout=5
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                models = data.get('models', [])
-                print(f"   ✅ Ollama server is running!")
-                print(f"   📦 Found {len(models)} models available")
-                
-                if models:
-                    print("   🎯 Available models:")
-                    for model in models[:5]:  # Show first 5
-                        name = model.get('name', 'unknown')
-                        size = model.get('size', 0) 
-                        print(f"      • {name} ({size//1000000:.0f}MB)")
-                    if len(models) > 5:
-                        print(f"      ... and {len(models)-5} more")
-                else:
-                    print("   ⚠️  No models found. Install with: ollama pull qwen3:1.7b")
-                
-                self.assertTrue(True)
-            else:
-                self.fail(f"Ollama server responded with status {response.status_code}")
-                
-        except requests.exceptions.ConnectionError:
-            self.fail(
-                "❌ Cannot connect to Ollama server.\n"
-                "   💡 Solutions:\n"
-                "   • Start Ollama: ollama serve\n"
-                "   • Check if running on different port\n"
-                "   • Verify Ollama is installed: ollama --version"
-            )
-        except Exception as e:
-            self.fail(f"❌ Unexpected error: {e}")
-    
-    def test_02_embedding_model_available(self):
-        """
-        ✅ Check if embedding model is available.
-        
-        This test verifies that:
-        - The embedding model (nomic-embed-text) is installed
-        - Embedding API calls work correctly
-        - Model responds with valid embeddings
-        """
-        print("\n🧠 Testing embedding model availability...")
-        
-        try:
-            # Test embedding generation
-            response = requests.post(
-                f"http://{self.config.llm.ollama_host}/api/embeddings",
-                json={
-                    "model": "nomic-embed-text",
-                    "prompt": "test embedding"
-                },
-                timeout=10
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                embedding = data.get('embedding', [])
-                
-                if embedding and len(embedding) > 0:
-                    print(f"   ✅ Embedding model working!")
-                    print(f"   📊 Generated {len(embedding)}-dimensional vectors")
-                    self.assertTrue(len(embedding) > 100)  # Should be substantial vectors
-                else:
-                    self.fail("Embedding response was empty")
-            else:
-                # Check if model needs to be installed
-                if response.status_code == 404:
-                    self.fail(
-                        "❌ Embedding model not found.\n"
-                        "   💡 Install with: ollama pull nomic-embed-text"
-                    )
-                else:
-                    self.fail(f"Embedding API error: {response.status_code}")
-                    
-        except Exception as e:
-            self.fail(f"❌ Embedding test failed: {e}")
-    
-    def test_03_llm_model_available(self):
-        """
-        ✅ Check if LLM models are available for synthesis/expansion.
-        
-        This test verifies that:
-        - At least one LLM model is available
-        - The model can generate text responses
-        - Response quality is reasonable
-        """
-        print("\n🤖 Testing LLM model availability...")
-        
-        synthesizer = LLMSynthesizer(config=self.config)
-        
-        if not synthesizer.is_available():
-            self.fail(
-                "❌ No LLM models available.\n"
-                "   💡 Install a model like: ollama pull qwen3:1.7b"
-            )
-        
-        print(f"   ✅ Found {len(synthesizer.available_models)} LLM models")
-        print(f"   🎯 Will use: {synthesizer.model}")
-        
-        # Test basic text generation
-        try:
-            response = synthesizer._call_ollama(
-                "Complete this: The capital of France is", 
-                temperature=0.1
-            )
-            
-            if response and len(response.strip()) > 0:
-                print(f"   ✅ Model generating responses!")
-                print(f"   💬 Sample response: '{response[:50]}...'")
-                
-                # Basic quality check
-                if "paris" in response.lower():
-                    print("   🎯 Response quality looks good!")
-                else:
-                    print("   ⚠️  Response quality might be low")
-                    
-                self.assertTrue(len(response) > 5)
-            else:
-                self.fail("Model produced empty response")
-                
-        except Exception as e:
-            self.fail(f"❌ LLM generation test failed: {e}")
-    
-    def test_04_query_expansion_working(self):
-        """
-        ✅ Check if query expansion is working correctly.
-        
-        This test verifies that:
-        - QueryExpander can connect to Ollama
-        - Expansion produces reasonable results
-        - Caching is working
-        """
-        print("\n🔍 Testing query expansion...")
-        
-        # Enable expansion for testing
-        self.config.search.expand_queries = True
-        expander = QueryExpander(self.config)
-        
-        if not expander.is_available():
-            self.skipTest("⏭️  Skipping - Ollama not available (tested above)")
-        
-        # Test expansion
-        test_query = "authentication"
-        expanded = expander.expand_query(test_query)
-        
-        print(f"   📝 Original: '{test_query}'")
-        print(f"   ➡️  Expanded: '{expanded}'")
-        
-        # Quality checks
-        if expanded == test_query:
-            print("   ⚠️  No expansion occurred (might be normal for simple queries)")
-        else:
-            # Should contain original query
-            self.assertIn(test_query.lower(), expanded.lower())
-            
-            # Should be longer
-            self.assertGreater(len(expanded.split()), len(test_query.split()))
-            
-            # Test caching
-            cached = expander.expand_query(test_query)
-            self.assertEqual(expanded, cached)
-            print("   ✅ Expansion and caching working!")
-    
-    def test_05_with_mocked_ollama(self):
-        """
-        ✅ Test components work with mocked Ollama (for offline testing).
-        
-        This test verifies that:
-        - System gracefully handles Ollama being unavailable
-        - Fallback behaviors work correctly
-        - Error messages are helpful
-        """
-        print("\n🎭 Testing with mocked Ollama responses...")
-        
-        # Mock successful embedding response
-        mock_embedding_response = MagicMock()
-        mock_embedding_response.status_code = 200
-        mock_embedding_response.json.return_value = {
-            'embedding': [0.1] * 768  # Standard embedding size
-        }
-        
-        # Mock LLM response
-        mock_llm_response = MagicMock()
-        mock_llm_response.status_code = 200
-        mock_llm_response.json.return_value = {
-            'response': 'authentication login user verification credentials'
-        }
-        
-        with patch('requests.post', side_effect=[mock_embedding_response, mock_llm_response]):
-            # Test query expansion with mocked response
-            expander = QueryExpander(self.config)
-            expander.enabled = True
-            
-            expanded = expander._llm_expand_query("authentication")
-            if expanded:
-                print(f"   ✅ Mocked expansion: '{expanded}'")
-                self.assertIn("authentication", expanded)
-            else:
-                print("   ⚠️  Expansion returned None (might be expected)")
-        
-        # Test graceful degradation when Ollama unavailable
-        with patch('requests.get', side_effect=requests.exceptions.ConnectionError()):
-            expander_offline = QueryExpander(self.config)
-            
-            # Should handle unavailable server gracefully
-            self.assertFalse(expander_offline.is_available())
-            
-            # Should return original query when offline
-            result = expander_offline.expand_query("test query")
-            self.assertEqual(result, "test query")
-            print("   ✅ Graceful offline behavior working!")
-    
-    def test_06_configuration_validation(self):
-        """
-        ✅ Check if configuration is valid and complete.
-        
-        This test verifies that:
-        - All required config sections exist
-        - Values are reasonable
-        - Host/port settings are valid
-        """
-        print("\n⚙️  Testing configuration validation...")
-        
-        # Check LLM config
-        self.assertIsNotNone(self.config.llm)
-        self.assertTrue(self.config.llm.ollama_host)
-        self.assertTrue(isinstance(self.config.llm.max_expansion_terms, int))
-        self.assertGreater(self.config.llm.max_expansion_terms, 0)
-        
-        print(f"   ✅ LLM config valid")
-        print(f"      Host: {self.config.llm.ollama_host}")
-        print(f"      Max expansion terms: {self.config.llm.max_expansion_terms}")
-        
-        # Check search config  
-        self.assertIsNotNone(self.config.search)
-        self.assertGreater(self.config.search.default_limit, 0)
-        print(f"   ✅ Search config valid")
-        print(f"      Default limit: {self.config.search.default_limit}")
-        print(f"      Query expansion: {self.config.search.expand_queries}")
-
-
-def run_troubleshooting():
-    """
-    Run all troubleshooting tests with beginner-friendly output.
-    """
-    print("🔧 FSS-Mini-RAG Ollama Integration Tests")
-    print("=" * 50)
-    print("These tests help you troubleshoot your Ollama setup.")
-    print("Each test explains what it's checking and how to fix issues.")
-    print()
-    
-    # Run tests with detailed output
-    unittest.main(verbosity=2, exit=False)
-    
-    print("\n" + "=" * 50)
-    print("💡 Common Solutions:")
-    print("   • Install Ollama: https://ollama.ai/download")
-    print("   • Start server: ollama serve")
-    print("   • Install models: ollama pull qwen3:1.7b")
-    print("   • Install embedding model: ollama pull nomic-embed-text")
-    print()
-    print("📚 For more help, see docs/QUERY_EXPANSION.md")
-
-
-if __name__ == '__main__':
-    run_troubleshooting()

tests/test_smart_ranking.py

@@ -1,314 +0,0 @@
-#!/usr/bin/env python3
-"""
-Smart Result Ranking Tests
-
-Tests to verify that the smart re-ranking system is working correctly
-and producing better quality results.
-
-Run with: python3 tests/test_smart_ranking.py
-"""
-
-import unittest
-import sys
-from pathlib import Path
-from datetime import datetime, timedelta
-from unittest.mock import patch, MagicMock
-
-# Add project to path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from claude_rag.search import SearchResult, CodeSearcher
-
-
-class TestSmartRanking(unittest.TestCase):
-    """
-    Test smart result re-ranking for better search quality.
-    
-    These tests verify that important files, recent files, and
-    well-structured content get appropriate boosts.
-    """
-    
-    def setUp(self):
-        """Set up test results for ranking."""
-        # Create mock search results with different characteristics
-        self.mock_results = [
-            SearchResult(
-                file_path=Path("random_temp_file.txt"),
-                content="short text",
-                score=0.8,
-                start_line=1,
-                end_line=2,
-                chunk_type="text",
-                name="temp",
-                language="text"
-            ),
-            SearchResult(
-                file_path=Path("README.md"), 
-                content="This is a comprehensive README file\nwith detailed installation instructions\nand usage examples for beginners.",
-                score=0.7,  # Lower initial score
-                start_line=1,
-                end_line=5,
-                chunk_type="markdown",
-                name="Installation Guide",
-                language="markdown"
-            ),
-            SearchResult(
-                file_path=Path("src/main.py"),
-                content="def main():\n    \"\"\"Main application entry point.\"\"\"\n    app = create_app()\n    return app.run()",
-                score=0.75,
-                start_line=10,
-                end_line=15,
-                chunk_type="function",
-                name="main",
-                language="python"
-            ),
-            SearchResult(
-                file_path=Path("temp/cache_123.log"),
-                content="log entry",
-                score=0.85,
-                start_line=1,
-                end_line=1,
-                chunk_type="text", 
-                name="log",
-                language="text"
-            )
-        ]
-    
-    def test_01_important_file_boost(self):
-        """
-        ✅ Test that important files get ranking boosts.
-        
-        README files, main files, config files, etc. should be
-        ranked higher than random temporary files.
-        """
-        print("\n📈 Testing important file boost...")
-        
-        # Create a minimal CodeSearcher to test ranking
-        searcher = MagicMock()
-        searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
-        
-        # Test re-ranking
-        ranked = searcher._smart_rerank(self.mock_results.copy())
-        
-        # Find README and temp file results
-        readme_result = next((r for r in ranked if 'README' in str(r.file_path)), None)
-        temp_result = next((r for r in ranked if 'temp' in str(r.file_path)), None)
-        
-        self.assertIsNotNone(readme_result)
-        self.assertIsNotNone(temp_result)
-        
-        # README should be boosted (original 0.7 * 1.2 = 0.84)
-        self.assertGreater(readme_result.score, 0.8)
-        
-        # README should now rank higher than the temp file
-        readme_index = ranked.index(readme_result)
-        temp_index = ranked.index(temp_result)
-        self.assertLess(readme_index, temp_index)
-        
-        print(f"   ✅ README boosted from 0.7 to {readme_result.score:.3f}")
-        print(f"   📊 README now ranks #{readme_index + 1}, temp file ranks #{temp_index + 1}")
-    
-    def test_02_content_quality_boost(self):
-        """
-        ✅ Test that well-structured content gets boosts.
-        
-        Content with multiple lines and good structure should
-        rank higher than very short snippets.
-        """
-        print("\n📝 Testing content quality boost...")
-        
-        searcher = MagicMock()
-        searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
-        
-        ranked = searcher._smart_rerank(self.mock_results.copy())
-        
-        # Find short and long content results
-        short_result = next((r for r in ranked if len(r.content.strip()) < 20), None)
-        structured_result = next((r for r in ranked if 'README' in str(r.file_path)), None)
-        
-        if short_result:
-            # Short content should be penalized (score * 0.9)
-            print(f"   📉 Short content penalized: {short_result.score:.3f}")
-            # Original was likely reduced
-        
-        if structured_result:
-            # Well-structured content gets small boost (score * 1.02)
-            lines = structured_result.content.strip().split('\n')
-            if len(lines) >= 3:
-                print(f"   📈 Structured content boosted: {structured_result.score:.3f}")
-                print(f"      ({len(lines)} lines of content)")
-        
-        self.assertTrue(True)  # Test passes if no exceptions
-    
-    def test_03_chunk_type_relevance(self):
-        """
-        ✅ Test that relevant chunk types get appropriate boosts.
-        
-        Functions, classes, and documentation should be ranked
-        higher than random text snippets.
-        """
-        print("\n🏷️  Testing chunk type relevance...")
-        
-        searcher = MagicMock()
-        searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
-        
-        ranked = searcher._smart_rerank(self.mock_results.copy())
-        
-        # Find function result
-        function_result = next((r for r in ranked if r.chunk_type == 'function'), None)
-        
-        if function_result:
-            # Function should get boost (original score * 1.1)
-            print(f"   ✅ Function chunk boosted: {function_result.score:.3f}")
-            print(f"      Function: {function_result.name}")
-            
-            # Should rank well compared to original score
-            original_score = 0.75
-            self.assertGreater(function_result.score, original_score)
-        
-        self.assertTrue(True)
-    
-    @patch('pathlib.Path.stat')
-    def test_04_recency_boost(self, mock_stat):
-        """
-        ✅ Test that recently modified files get ranking boosts.
-        
-        Files modified in the last week should rank higher than
-        very old files.
-        """
-        print("\n⏰ Testing recency boost...")
-        
-        # Mock file stats for different modification times
-        now = datetime.now()
-        
-        def mock_stat_side_effect(file_path):
-            mock_stat_obj = MagicMock()
-            
-            if 'README' in str(file_path):
-                # Recent file (2 days ago)
-                recent_time = (now - timedelta(days=2)).timestamp()
-                mock_stat_obj.st_mtime = recent_time
-            else:
-                # Old file (2 months ago)
-                old_time = (now - timedelta(days=60)).timestamp()
-                mock_stat_obj.st_mtime = old_time
-                
-            return mock_stat_obj
-        
-        # Apply mock to Path.stat for each result
-        mock_stat.side_effect = lambda: mock_stat_side_effect("dummy")
-        
-        # Patch the Path constructor to return mocked paths
-        with patch.object(Path, 'stat', side_effect=mock_stat_side_effect):
-            searcher = MagicMock()
-            searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
-            
-            ranked = searcher._smart_rerank(self.mock_results.copy())
-            
-            readme_result = next((r for r in ranked if 'README' in str(r.file_path)), None)
-            
-            if readme_result:
-                # Recent file should get boost
-                # Original 0.7 * 1.2 (important) * 1.1 (recent) * 1.02 (structured) ≈ 0.88
-                print(f"   ✅ Recent file boosted: {readme_result.score:.3f}")
-                self.assertGreater(readme_result.score, 0.8)
-            
-        print("   📅 Recency boost system working!")
-    
-    def test_05_overall_ranking_quality(self):
-        """
-        ✅ Test that overall ranking produces sensible results.
-        
-        After all boosts and penalties, the ranking should make sense:
-        - Important, recent, well-structured files should rank highest
-        - Short, temporary, old files should rank lowest
-        """
-        print("\n🏆 Testing overall ranking quality...")
-        
-        searcher = MagicMock()
-        searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
-        
-        # Test with original unsorted results
-        unsorted = self.mock_results.copy()
-        ranked = searcher._smart_rerank(unsorted)
-        
-        print("   📊 Final ranking:")
-        for i, result in enumerate(ranked, 1):
-            file_name = Path(result.file_path).name
-            print(f"      {i}. {file_name} (score: {result.score:.3f})")
-        
-        # Quality checks:
-        # 1. Results should be sorted by score (descending)
-        scores = [r.score for r in ranked]
-        self.assertEqual(scores, sorted(scores, reverse=True))
-        
-        # 2. README should rank higher than temp files
-        readme_pos = next((i for i, r in enumerate(ranked) if 'README' in str(r.file_path)), None)
-        temp_pos = next((i for i, r in enumerate(ranked) if 'temp' in str(r.file_path)), None)
-        
-        if readme_pos is not None and temp_pos is not None:
-            self.assertLess(readme_pos, temp_pos)
-            print(f"   ✅ README ranks #{readme_pos + 1}, temp file ranks #{temp_pos + 1}")
-        
-        # 3. Function/code should rank well
-        function_pos = next((i for i, r in enumerate(ranked) if r.chunk_type == 'function'), None)
-        if function_pos is not None:
-            self.assertLess(function_pos, len(ranked) // 2)  # Should be in top half
-            print(f"   ✅ Function code ranks #{function_pos + 1}")
-        
-        print("   🎯 Ranking quality looks good!")
-    
-    def test_06_zero_overhead_verification(self):
-        """
-        ✅ Verify that smart ranking adds zero overhead.
-        
-        The ranking should only use existing data and lightweight operations.
-        No additional API calls or expensive operations.
-        """
-        print("\n⚡ Testing zero overhead...")
-        
-        searcher = MagicMock()
-        searcher._smart_rerank = CodeSearcher._smart_rerank.__get__(searcher)
-        
-        import time
-        
-        # Time the ranking operation
-        start_time = time.time()
-        ranked = searcher._smart_rerank(self.mock_results.copy())
-        end_time = time.time()
-        
-        ranking_time = (end_time - start_time) * 1000  # Convert to milliseconds
-        
-        print(f"   ⏱️  Ranking took {ranking_time:.2f}ms for {len(self.mock_results)} results")
-        
-        # Should be very fast (< 10ms for small result sets)
-        self.assertLess(ranking_time, 50)  # Very generous upper bound
-        
-        # Verify no external calls were made (check that we only use existing data)
-        # This is implicitly tested by the fact that we're using mock objects
-        print("   ✅ Zero overhead verified - only uses existing result data!")
-
-
-def run_ranking_tests():
-    """
-    Run smart ranking tests with detailed output.
-    """
-    print("🧮 Smart Result Ranking Tests")
-    print("=" * 40)
-    print("Testing the zero-overhead ranking improvements.")
-    print()
-    
-    unittest.main(verbosity=2, exit=False)
-    
-    print("\n" + "=" * 40)
-    print("💡 Smart Ranking Features:")
-    print("   • Important files (README, main, config) get 20% boost")
-    print("   • Recent files (< 1 week) get 10% boost") 
-    print("   • Functions/classes get 10% boost")
-    print("   • Well-structured content gets 2% boost")
-    print("   • Very short content gets 10% penalty")
-    print("   • All boosts are cumulative for maximum quality")
-
-
-if __name__ == '__main__':
-    run_ranking_tests()

tests/troubleshoot.py

@@ -1,86 +0,0 @@
-#!/usr/bin/env python3
-"""
-FSS-Mini-RAG Troubleshooting Tool
-
-A beginner-friendly troubleshooting tool that checks your setup
-and helps identify what's working and what needs attention.
-
-Run with: python3 tests/troubleshoot.py
-"""
-
-import sys
-import subprocess
-from pathlib import Path
-
-# Add project to path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-def main():
-    """Run comprehensive troubleshooting checks."""
-    
-    print("🔧 FSS-Mini-RAG Troubleshooting Tool")
-    print("=" * 50)
-    print("This tool checks your setup and helps fix common issues.")
-    print()
-    
-    # Menu of available tests
-    print("Available tests:")
-    print("  1. Full Ollama Integration Test")
-    print("  2. Smart Ranking Test")
-    print("  3. Basic System Validation")
-    print("  4. All Tests (recommended)")
-    print()
-    
-    choice = input("Select test (1-4, or Enter for all): ").strip()
-    
-    if choice == "1" or choice == "" or choice == "4":
-        print("\n" + "🤖 OLLAMA INTEGRATION TESTS".center(50, "="))
-        run_test("test_ollama_integration.py")
-    
-    if choice == "2" or choice == "" or choice == "4":
-        print("\n" + "🧮 SMART RANKING TESTS".center(50, "="))
-        run_test("test_smart_ranking.py")
-    
-    if choice == "3" or choice == "" or choice == "4":
-        print("\n" + "🔍 SYSTEM VALIDATION TESTS".center(50, "="))
-        run_test("03_system_validation.py")
-    
-    print("\n" + "✅ TROUBLESHOOTING COMPLETE".center(50, "="))
-    print("💡 If you're still having issues:")
-    print("   • Check docs/QUERY_EXPANSION.md for setup help")
-    print("   • Ensure Ollama is installed: https://ollama.ai/download")
-    print("   • Start Ollama server: ollama serve")
-    print("   • Install models: ollama pull qwen3:1.7b")
-
-def run_test(test_file):
-    """Run a specific test file."""
-    test_path = Path(__file__).parent / test_file
-    
-    if not test_path.exists():
-        print(f"❌ Test file not found: {test_file}")
-        return
-    
-    try:
-        # Run the test
-        result = subprocess.run([
-            sys.executable, str(test_path)
-        ], capture_output=True, text=True, timeout=60)
-        
-        # Show output
-        if result.stdout:
-            print(result.stdout)
-        if result.stderr:
-            print("STDERR:", result.stderr)
-            
-        if result.returncode == 0:
-            print(f"✅ {test_file} completed successfully!")
-        else:
-            print(f"⚠️  {test_file} had some issues (return code: {result.returncode})")
-            
-    except subprocess.TimeoutExpired:
-        print(f"⏰ {test_file} timed out after 60 seconds")
-    except Exception as e:
-        print(f"❌ Error running {test_file}: {e}")
-
-if __name__ == "__main__":
-    main()