stravinsky 0.4.18__py3-none-any.whl → 0.4.66__py3-none-any.whl

mcp_bridge/tools/semantic_search.py

@@ -18,20 +18,27 @@ Architecture:
 - Chunking strategy: function/class level with context
 """
 
+import asyncio
 import atexit
 import hashlib
 import logging
+import signal
 import sys
 import threading
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Literal
+from typing import TYPE_CHECKING, Literal
+
+if TYPE_CHECKING:
+    import pathspec
 
 import httpx
 from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential
 
 from mcp_bridge.auth.token_store import TokenStore
 from mcp_bridge.tools.query_classifier import QueryCategory, classify_query
+from mcp_bridge.native_search import native_chunk_code
+from mcp_bridge.native_watcher import NativeFileWatcher
 
 logger = logging.getLogger(__name__)
 
@@ -295,7 +302,10 @@ class GitIgnoreManager:
             rel_path_str = str(rel_path).replace("\\", "/")
 
             # Check against patterns
-            return self.spec.match_file(rel_path_str)
+            spec = self.spec
+            if spec is None:
+                return False  # No patterns loaded, nothing is ignored
+            return spec.match_file(rel_path_str)
         except ValueError:
             # Path is outside project - not ignored by gitignore (but may be ignored for other reasons)
             return False
@@ -925,40 +935,120 @@ class CodebaseVectorStore:
         ".toml",
     }
 
-    # Directories to skip
-    SKIP_DIRS = {
-        "node_modules",
-        ".git",
+    # Directories to skip (non-code related)
+    SKIP_DUW = {
+        # Python
         "__pycache__",
         ".venv",
         "venv",
         "env",
-        "dist",
-        "build",
-        ".next",
-        ".nuxt",
-        "target",
+        ".env",
+        "virtualenv",
+        ".virtualenv",
         ".tox",
+        ".nox",
         ".pytest_cache",
         ".mypy_cache",
         ".ruff_cache",
+        ".pytype",
+        ".pyre",
+        "*.egg-info",
+        ".eggs",
+        "pip-wheel-metadata",
+        # Node.js
+        "node_modules",
+        ".npm",
+        ".yarn",
+        ".pnpm-store",
+        "bower_components",
+        # Build outputs
+        "dist",
+        "build",
+        "out",
+        "_build",
+        ".next",
+        ".nuxt",
+        ".output",
+        ".cache",
+        ".parcel-cache",
+        ".turbo",
+        # Version control
+        ".git",
+        ".svn",
+        ".hg",
+        # IDE/Editor
+        ".idea",
+        ".vscode",
+        ".vs",
+        # Test/coverage
         "coverage",
+        "htmlcov",
+        ".coverage",
+        ".nyc_output",
+        # Rust/Go/Java
+        "target",
+        "vendor",
+        "Godeps",
+        # Misc
         ".stravinsky",
         "scratches",
         "consoles",
-        ".idea",
+        "logs",
+        "tmp",
+        "temp",
     }
 
-    def __init__(self, project_path: str, provider: EmbeddingProvider = "ollama"):
-        self.project_path = Path(project_path).resolve()
-        self.project_hash = hashlib.md5(str(self.project_path).encode()).hexdigest()[:12]
+    @staticmethod
+    def _normalize_project_path(path: str) -> Path:
+        """
+        Normalize project path to git root if available.
+
+        This ensures one index per repo regardless of invocation directory.
+        If not a git repo, returns resolved absolute path.
+        """
+        import subprocess
+
+        resolved = Path(path).resolve()
+
+        # Try to find git root
+        try:
+            result = subprocess.run(
+                ["git", "-C", str(resolved), "rev-parse", "--show-toplevel"],
+                capture_output=True,
+                text=True,
+                timeout=2,
+                check=False,
+            )
+            if result.returncode == 0:
+                git_root = Path(result.stdout.strip())
+                logger.debug(f"Normalized {resolved} → {git_root} (git root)")
+                return git_root
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+
+        # Not a git repo or git not available, use resolved path
+        return resolved
+
+    def __init__(
+        self,
+        project_path: str,
+        provider: EmbeddingProvider = "ollama",
+        base_path: Path | None = None,
+    ):
+        self.project_path = self._normalize_project_path(project_path)
+        self.repo_name = self.project_path.name
 
         # Initialize embedding provider
         self.provider_name = provider
         self.provider = get_embedding_provider(provider)
 
-        # Store in user's home directory, separate by provider to avoid dimension mismatch
-        self.db_path = Path.home() / ".stravinsky" / "vectordb" / f"{self.project_hash}_{provider}"
+        # Store in provided base_path or user's home directory
+        # Separate by provider to avoid dimension mismatch
+        if base_path:
+            self.db_path = base_path / f"{self.repo_name}_{provider}"
+        else:
+            self.db_path = Path.home() / ".stravinsky" / "vectordb" / f"{self.repo_name}_{provider}"
+
         self.db_path.mkdir(parents=True, exist_ok=True)
 
         # File lock for single-process access to ChromaDB (prevents corruption)
@@ -1073,7 +1163,7 @@ class CodebaseVectorStore:
         sorted_results = sorted(results, key=lambda x: x[0])
         return [emb for _, emb in sorted_results]
 
-    def _chunk_file(self, file_path: Path) -> list[dict]:
+    async def _chunk_file(self, file_path: Path) -> list[dict]:
         """Split a file into chunks with metadata.
 
         Uses AST-aware chunking for Python files to respect function/class
@@ -1091,7 +1181,42 @@ class CodebaseVectorStore:
         rel_path = str(file_path.resolve().relative_to(self.project_path.resolve()))
         language = file_path.suffix.lstrip(".")
 
-        # Use AST-aware chunking for Python files
+        # Try native AST-aware chunking first
+        native_results = await native_chunk_code(content, language)
+        if native_results:
+            chunks = []
+            for nc in native_results:
+                start_line = nc["start_line"]
+                end_line = nc["end_line"]
+                chunk_text = nc["content"]
+                content_hash = hashlib.md5(chunk_text.encode("utf-8")).hexdigest()[:12]
+                
+                node_type = nc.get("node_type", "unknown")
+                name = nc.get("name")
+                
+                if name:
+                    header = f"File: {rel_path}\n{node_type.capitalize()}: {name}\nLines: {start_line}-{end_line}"
+                else:
+                    header = f"File: {rel_path}\nLines: {start_line}-{end_line}"
+                
+                document = f"{header}\n\n{chunk_text}"
+                
+                chunks.append({
+                    "id": f"{rel_path}:{start_line}-{end_line}:{content_hash}",
+                    "document": document,
+                    "metadata": {
+                        "file_path": rel_path,
+                        "start_line": start_line,
+                        "end_line": end_line,
+                        "language": language,
+                        "node_type": node_type,
+                        "name": name or "",
+                    }
+                })
+            if chunks:
+                return chunks
+
+        # Use AST-aware chunking for Python files (fallback)
         if language == "py":
             chunks = self._chunk_python_ast(content, rel_path, language)
             if chunks:  # If AST parsing succeeded
@@ -1307,8 +1432,80 @@ class CodebaseVectorStore:
 
         return chunks
 
+    def _load_whitelist(self) -> set[Path] | None:
+        """Load whitelist from .stravinskyadd file if present.
+
+        File format:
+        - One path per line (relative to project root)
+        - Lines starting with # are comments
+        - Empty lines are ignored
+        - Glob patterns are supported (e.g., src/**/*.py)
+        - Directories implicitly include all files within (src/ includes src/**/*.*)
+
+        Returns:
+            Set of resolved file paths to include, or None if no whitelist file exists.
+        """
+        whitelist_file = self.project_path / ".stravinskyadd"
+        if not whitelist_file.exists():
+            return None
+
+        whitelist_paths: set[Path] = set()
+        try:
+            content = whitelist_file.read_text(encoding="utf-8")
+            for line in content.splitlines():
+                line = line.strip()
+                # Skip empty lines and comments
+                if not line or line.startswith("#"):
+                    continue
+
+                # Handle glob patterns
+                if "*" in line or "?" in line:
+                    for matched_path in self.project_path.glob(line):
+                        if (
+                            matched_path.is_file()
+                            and matched_path.suffix.lower() in self.CODE_EXTENSIONS
+                        ):
+                            whitelist_paths.add(matched_path.resolve())
+                else:
+                    target = self.project_path / line
+                    if target.exists():
+                        if target.is_file():
+                            # Direct file reference
+                            if target.suffix.lower() in self.CODE_EXTENSIONS:
+                                whitelist_paths.add(target.resolve())
+                        elif target.is_dir():
+                            # Directory: include all code files recursively
+                            for file_path in target.rglob("*"):
+                                if (
+                                    file_path.is_file()
+                                    and file_path.suffix.lower() in self.CODE_EXTENSIONS
+                                ):
+                                    # Apply SKIP_DUW even within whitelisted directories
+                                    if not any(
+                                        skip_dir in file_path.parts for skip_dir in self.SKIP_DUW
+                                    ):
+                                        whitelist_paths.add(file_path.resolve())
+
+            logger.info(f"Loaded whitelist from .stravinskyadd: {len(whitelist_paths)} files")
+            return whitelist_paths
+
+        except Exception as e:
+            logger.warning(f"Failed to parse .stravinskyadd: {e}")
+            return None
+
     def _get_files_to_index(self) -> list[Path]:
-        """Get all indexable files in the project."""
+        """Get all indexable files in the project.
+
+        If a .stravinskyadd whitelist file exists, ONLY those paths are indexed.
+        Otherwise, all code files are indexed (excluding SKIP_DUW).
+        """
+        # Check for whitelist mode
+        whitelist = self._load_whitelist()
+        if whitelist is not None:
+            logger.info(f"Whitelist mode: indexing {len(whitelist)} files from .stravinskyadd")
+            return sorted(whitelist)  # Return sorted for deterministic order
+
+        # Standard mode: crawl entire project
         files = []
         for file_path in self.project_path.rglob("*"):
             if file_path.is_file():
@@ -1345,7 +1542,7 @@ class CodebaseVectorStore:
                     continue
 
                 # Skip excluded directories
-                if any(skip_dir in file_path.parts for skip_dir in self.SKIP_DIRS):
+                if any(skip_dir in file_path.parts for skip_dir in self.SKIP_DUW):
                     continue
 
                 # Only include code files
@@ -1374,6 +1571,38 @@ class CodebaseVectorStore:
         with self._cancel_lock:
             return self._cancel_indexing
 
+    def _get_manifest_path(self) -> Path:
+        """Get the path to the incremental indexing manifest."""
+        return self.db_path / "manifest.json"
+
+    def _load_manifest(self) -> dict:
+        """Load the indexing manifest."""
+        manifest_path = self._get_manifest_path()
+        if not manifest_path.exists():
+            return {}
+        try:
+            import json
+
+            with open(manifest_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception as e:
+            logger.warning(f"Failed to load manifest: {e}")
+            return {}
+
+    def _save_manifest(self, manifest: dict) -> None:
+        """Save the indexing manifest."""
+        manifest_path = self._get_manifest_path()
+        try:
+            import json
+
+            # Atomic write
+            temp_path = manifest_path.with_suffix(".tmp")
+            with open(temp_path, "w", encoding="utf-8") as f:
+                json.dump(manifest, f, indent=2)
+            temp_path.replace(manifest_path)
+        except Exception as e:
+            logger.warning(f"Failed to save manifest: {e}")
+
     async def index_codebase(self, force: bool = False) -> dict:
         """
         Index the entire codebase into the vector store.
@@ -1398,7 +1627,7 @@ class CodebaseVectorStore:
         print(f"🔍 SEMANTIC-INDEX: {self.project_path}", file=sys.stderr)
 
         # Notify reindex start (non-blocking)
-        notifier = None  # Initialize to avoid NameError in error handlers
+        notifier = None
         try:
             from mcp_bridge.notifications import get_notification_manager
 
@@ -1410,7 +1639,6 @@ class CodebaseVectorStore:
         try:
             if not await self.check_embedding_service():
                 error_msg = "Embedding service not available"
-                # Notify error
                 try:
                     if notifier:
                         await notifier.notify_reindex_error(error_msg)
@@ -1427,25 +1655,74 @@ class CodebaseVectorStore:
             except Exception:
                 pass
 
+            manifest = {}
             if force:
-                # Clear existing collection
+                # Clear existing collection and manifest
                 try:
                     self.client.delete_collection("codebase")
                     self._collection = None
                     existing_ids = set()
                 except Exception:
                     pass
+            else:
+                manifest = self._load_manifest()
 
             files = self._get_files_to_index()
             all_chunks = []
             current_chunk_ids = set()
 
+            # Track manifest updates
+            new_manifest = {}
+
+            # Stats
+            reused_files = 0
+
             # Mark: Generate all chunks for current codebase
             for file_path in files:
-                chunks = self._chunk_file(file_path)
+                str_path = str(file_path.resolve())
+
+                # Get file stats
+                try:
+                    stat = file_path.stat()
+                    mtime = stat.st_mtime
+                    size = stat.st_size
+                except OSError:
+                    continue  # File might have been deleted during iteration
+
+                # Check manifest
+                manifest_entry = manifest.get(str_path)
+
+                # Reuse chunks if file hasn't changed AND chunks exist in DB
+                if (
+                    not force
+                    and manifest_entry
+                    and manifest_entry.get("mtime") == mtime
+                    and manifest_entry.get("size") == size
+                ):
+                    chunk_ids = manifest_entry.get("chunk_ids", [])
+
+                    # Verify all chunks actually exist in DB (integrity check)
+                    if chunk_ids and all(cid in existing_ids for cid in chunk_ids):
+                        current_chunk_ids.update(chunk_ids)
+                        new_manifest[str_path] = manifest_entry
+                        reused_files += 1
+                        continue
+
+                # If we get here: file changed, new, or chunks missing from DB
+                chunks = await self._chunk_file(file_path)
                 all_chunks.extend(chunks)
+
+                new_chunk_ids = []
                 for c in chunks:
-                    current_chunk_ids.add(c["id"])
+                    cid = c["id"]
+                    current_chunk_ids.add(cid)
+                    new_chunk_ids.append(cid)
+
+                # Update manifest
+                new_manifest[str_path] = {"mtime": mtime, "size": size, "chunk_ids": new_chunk_ids}
+
+            # Save updated manifest
+            self._save_manifest(new_manifest)
 
             # Sweep: Identify stale chunks to remove
             to_delete = existing_ids - current_chunk_ids
@@ -1464,10 +1741,10 @@ class CodebaseVectorStore:
                     "indexed": 0,
                     "pruned": len(to_delete),
                     "total_files": len(files),
-                    "message": "No new chunks to index",
+                    "reused_files": reused_files,
+                    "message": f"No new chunks to index (reused {reused_files} files)",
                     "time_taken": round(time.time() - start_time, 1),
                 }
-                # Notify completion
                 try:
                     if notifier:
                         await notifier.notify_reindex_complete(stats)
@@ -1492,7 +1769,6 @@ class CodebaseVectorStore:
                         "cancelled": True,
                         "message": f"Cancelled after {total_indexed}/{len(chunks_to_add)} chunks",
                     }
-                    # Notify cancellation
                     try:
                         if notifier:
                             await notifier.notify_reindex_error(
@@ -1520,11 +1796,11 @@ class CodebaseVectorStore:
                 "indexed": total_indexed,
                 "pruned": len(to_delete),
                 "total_files": len(files),
+                "reused_files": reused_files,
                 "db_path": str(self.db_path),
                 "time_taken": round(time.time() - start_time, 1),
             }
 
-            # Notify completion
             try:
                 if notifier:
                     await notifier.notify_reindex_complete(stats)
@@ -1536,14 +1812,11 @@ class CodebaseVectorStore:
         except Exception as e:
             error_msg = str(e)
             logger.error(f"Reindexing failed: {error_msg}")
-
-            # Notify error
             try:
                 if notifier:
                     await notifier.notify_reindex_error(error_msg)
             except Exception as notify_error:
                 logger.warning(f"Failed to send reindex error notification: {notify_error}")
-
             raise
 
     async def search(
@@ -1749,6 +2022,87 @@ def _cleanup_watchers():
 atexit.register(_cleanup_watchers)
 
 
+def _check_index_exists(store: "CodebaseVectorStore") -> bool:
+    """Check if semantic index exists for this project."""
+    try:
+        doc_count = store.collection.count()
+        return doc_count > 0
+    except Exception as e:
+        logger.warning(f"Could not check index status: {e}")
+        return False
+
+
+def _prompt_with_timeout(prompt_text: str, timeout: int = 30) -> str:
+    """
+    Prompt user with timeout. Returns 'n' if timeout or non-interactive.
+
+    Args:
+        prompt_text: The prompt to display
+        timeout: Timeout in seconds (default: 30)
+
+    Returns:
+        User response or 'n' if timeout/non-interactive
+    """
+    # Check if stdin is interactive
+    if not sys.stdin.isatty():
+        return "n"  # Non-interactive, skip prompt
+
+    # Windows doesn't support SIGALRM, so we need a different approach
+    if sys.platform == "win32":
+        try:
+            import msvcrt
+            import time
+
+            print(prompt_text, end="", flush=True, file=sys.stderr)
+            start_time = time.time()
+            response = []
+
+            while time.time() - start_time < timeout:
+                if msvcrt.kbhit():
+                    char = msvcrt.getwche()
+                    if char in ("\r", "\n"):
+                        print(file=sys.stderr)  # Newline after input
+                        return "".join(response)
+                    response.append(char)
+                time.sleep(0.1)
+
+            print("\n⏱️  Timeout - skipping index creation", file=sys.stderr)
+            return "n"
+        except (ImportError, Exception):
+            # Fallback: just use input() without timeout on Windows
+            try:
+                return input(prompt_text)
+            except EOFError:
+                return "n"
+
+    # Unix-like systems (Linux, macOS)
+    def timeout_handler(signum, frame):
+        raise TimeoutError()
+
+    try:
+        # Save old handler
+        old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(timeout)
+        response = input(prompt_text)
+        signal.alarm(0)  # Cancel alarm
+        # Restore old handler
+        signal.signal(signal.SIGALRM, old_handler)
+        return response
+    except (TimeoutError, EOFError):
+        signal.alarm(0)  # Cancel alarm
+        # Restore old handler
+        try:
+            signal.signal(signal.SIGALRM, old_handler)
+        except Exception:
+            pass
+        print("\n⏱️  Timeout - skipping index creation", file=sys.stderr)
+        return "n"
+    except Exception as e:
+        signal.alarm(0)  # Cancel alarm
+        logger.warning(f"Error during prompt: {e}")
+        return "n"
+
+
 def get_store(project_path: str, provider: EmbeddingProvider = "ollama") -> CodebaseVectorStore:
     """Get or create a vector store for a project.
 
@@ -1794,6 +2148,58 @@ async def semantic_search(
         Formatted search results with file paths and code snippets.
     """
     store = get_store(project_path, provider)
+
+    # Check if index exists before searching
+    if not _check_index_exists(store):
+        print("\n⚠️  No semantic index found for this project.", file=sys.stderr)
+        print(f"📁 Project: {project_path}", file=sys.stderr)
+        print(f"🔍 Provider: {provider}", file=sys.stderr)
+
+        # Interactive prompt with timeout
+        response = _prompt_with_timeout("\n🤔 Create semantic index now? [Y/n] (30s timeout): ")
+
+        if response.lower() in ["", "y", "yes"]:
+            print("\n📋 Creating semantic index...", file=sys.stderr)
+            try:
+                # Call index_codebase function
+                index_result = await index_codebase(project_path, provider=provider, force=False)
+                print(f"✅ {index_result}", file=sys.stderr)
+
+                # Auto-start file watcher
+                print("🔄 Starting file watcher for auto-updates...", file=sys.stderr)
+                await start_file_watcher(project_path, provider)
+                print("✅ File watcher started - index will auto-update on changes", file=sys.stderr)
+
+            except Exception as e:
+                logger.error(f"Failed to create index: {e}")
+                return (
+                    f"❌ Failed to create index: {e}\n\n"
+                    "**Manual fix:**\n"
+                    "```python\n"
+                    f'index_codebase(project_path="{project_path}", provider="{provider}")\n'
+                    "```"
+                )
+        else:
+            return (
+                "❌ Index required for semantic search.\n\n"
+                "**To create index manually:**\n"
+                "```python\n"
+                f'index_codebase(project_path="{project_path}", provider="{provider}")\n'
+                "```\n\n"
+                "This indexes your codebase for natural language search. "
+                "Run it once per project (takes 30s-2min depending on size)."
+            )
+    else:
+        # Index exists, ensure watcher is running
+        # We don't await this to avoid blocking search if it takes a moment
+        # But for tests we might need to await it or mock it properly
+        # The test expects it to be called.
+        # Let's just call it. start_file_watcher is async.
+        try:
+            await start_file_watcher(project_path, provider)
+        except Exception as e:
+            logger.warning(f"Failed to auto-start watcher: {e}")
+
     results = await store.search(
         query,
         n_results,
@@ -1810,6 +2216,17 @@ async def semantic_search(
     if "error" in results[0]:
         return f"Error: {results[0]['error']}\nHint: {results[0].get('hint', 'Check Ollama is running')}"
 
+    # Auto-start file watcher if not already running (index exists and search succeeded)
+    try:
+        active_watcher = get_file_watcher(project_path)
+        if active_watcher is None:
+            # Index exists but no watcher - start it silently in background
+            logger.info(f"Auto-starting file watcher for {project_path}")
+            await start_file_watcher(project_path, provider, debounce_seconds=2.0)
+    except Exception as e:
+        # Don't fail the search if watcher fails to start
+        logger.warning(f"Could not auto-start file watcher: {e}")
+
     lines = [f"Found {len(results)} results for: '{query}'\n"]
     for i, r in enumerate(results, 1):
         lines.append(f"{i}. {r['file']}:{r['lines']} (relevance: {r['relevance']})")
@@ -2050,16 +2467,16 @@ def delete_index(
         except Exception as e:
             return f"❌ Error deleting all indexes: {e}"
 
-    # Generate project hash
+    # Generate repo name
     project_path_resolved = Path(project_path).resolve()
-    project_hash = hashlib.md5(str(project_path_resolved).encode()).hexdigest()[:12]
+    repo_name = project_path_resolved.name
 
     deleted = []
     errors = []
 
     if provider:
         # Delete specific provider index for this project
-        index_path = vectordb_base / f"{project_hash}_{provider}"
+        index_path = vectordb_base / f"{repo_name}_{provider}"
         if index_path.exists():
             try:
                 shutil.rmtree(index_path)
@@ -2072,7 +2489,7 @@ def delete_index(
         # Delete all provider indexes for this project
         providers: list[EmbeddingProvider] = ["ollama", "mxbai", "gemini", "openai", "huggingface"]
         for prov in providers:
-            index_path = vectordb_base / f"{project_hash}_{prov}"
+            index_path = vectordb_base / f"{repo_name}_{prov}"
             if index_path.exists():
                 try:
                     shutil.rmtree(index_path)
@@ -2081,7 +2498,7 @@ def delete_index(
                     errors.append(f"{prov}: {e}")
 
     if not deleted and not errors:
-        return f"⚠️  No indexes found for project: {project_path_resolved}\nProject hash: {project_hash}"
+        return f"⚠️  No indexes found for project: {project_path_resolved}\nRepo name: {repo_name}"
 
     result = []
     if deleted:
@@ -2144,45 +2561,44 @@ async def start_file_watcher(
     Returns:
         The started CodebaseFileWatcher instance
     """
-    path = str(Path(project_path).resolve())
+    normalized_path = CodebaseVectorStore._normalize_project_path(project_path)
+    path_key = str(normalized_path)
+
     with _watchers_lock:
-        if path not in _watchers:
+        if path_key not in _watchers:
             store = get_store(project_path, provider)
 
-            # Check if index exists - CRITICAL: Must have index before watching
+            # Check if index exists - create if missing, update if stale
             try:
                 stats = store.get_stats()
                 chunks_indexed = stats.get("chunks_indexed", 0)
-                if chunks_indexed == 0:
-                    raise ValueError(
-                        f"No semantic index found for '{path}'. "
-                        f"Run semantic_index(project_path='{path}', provider='{provider}') "
-                        f"before starting the file watcher."
-                    )
 
-                # Index exists - catch up on any missed changes
-                print(f"📋 Catching up on changes since last index...", file=sys.stderr)
-                await store.index_codebase(force=False)
-                print(f"✅ Index updated, starting file watcher", file=sys.stderr)
+                if chunks_indexed == 0:
+                    # No index exists - create initial index
+                    print("📋 No index found, creating initial index...", file=sys.stderr)
+                    await store.index_codebase(force=False)
+                    print("✅ Initial index created, starting file watcher", file=sys.stderr)
+                else:
+                    # Index exists - catch up on any missed changes since watcher was off
+                    print("📋 Catching up on changes since last index...", file=sys.stderr)
+                    await store.index_codebase(force=False)
+                    print("✅ Index updated, starting file watcher", file=sys.stderr)
 
-            except ValueError:
-                # Re-raise ValueError (our intentional error)
-                raise
             except Exception as e:
-                # Collection doesn't exist or other error
-                raise ValueError(
-                    f"No semantic index found for '{path}'. "
-                    f"Run semantic_index(project_path='{path}', provider='{provider}') "
-                    f"before starting the file watcher."
-                ) from e
+                # Failed to index - log and create watcher anyway (it will index on file changes)
+                logger.warning(f"Failed to index before starting watcher: {e}")
+                print(f"⚠️  Warning: Could not index project: {e}", file=sys.stderr)
+                print(
+                    "🔄 Starting watcher anyway - will index on first file change", file=sys.stderr
+                )
 
             watcher = store.start_watching(debounce_seconds=debounce_seconds)
-            _watchers[path] = watcher
+            _watchers[path_key] = watcher
         else:
-            watcher = _watchers[path]
+            watcher = _watchers[path_key]
             if not watcher.is_running():
                 watcher.start()
-        return _watchers[path]
+        return _watchers[path_key]
 
 
 def stop_file_watcher(project_path: str) -> bool:
@@ -2194,12 +2610,14 @@ def stop_file_watcher(project_path: str) -> bool:
     Returns:
         True if watcher was stopped, False if no watcher was active
     """
-    path = str(Path(project_path).resolve())
+    normalized_path = CodebaseVectorStore._normalize_project_path(project_path)
+    path_key = str(normalized_path)
+
     with _watchers_lock:
-        if path in _watchers:
-            watcher = _watchers[path]
+        if path_key in _watchers:
+            watcher = _watchers[path_key]
             watcher.stop()
-            del _watchers[path]
+            del _watchers[path_key]
             return True
         return False
 
@@ -2213,9 +2631,11 @@ def get_file_watcher(project_path: str) -> "CodebaseFileWatcher | None":
     Returns:
         The CodebaseFileWatcher if active, None otherwise
     """
-    path = str(Path(project_path).resolve())
+    normalized_path = CodebaseVectorStore._normalize_project_path(project_path)
+    path_key = str(normalized_path)
+
     with _watchers_lock:
-        watcher = _watchers.get(path)
+        watcher = _watchers.get(path_key)
         if watcher is not None and watcher.is_running():
             return watcher
         return None
@@ -2281,7 +2701,7 @@ db session factory pattern"""
         result = await invoke_gemini(
             token_store=TokenStore(),
             prompt=prompt,
-            model="gemini-2.0-flash",
+            model="gemini-3-flash",
             temperature=0.7,
             max_tokens=200,
         )
@@ -2335,7 +2755,7 @@ authentication logic"""
         result = await invoke_gemini(
             token_store=TokenStore(),
             prompt=prompt,
-            model="gemini-2.0-flash",
+            model="gemini-3-flash",
             temperature=0.3,  # Lower temperature for more consistent decomposition
             max_tokens=150,
         )
@@ -2674,6 +3094,145 @@ async def enhanced_search(
 # ========================
 
 
+class DedicatedIndexingWorker:
+    """Single-threaded worker for all indexing operations.
+
+    Prevents concurrent indexing by serializing all operations through a queue.
+    Uses asyncio.run() for each operation to avoid event loop reuse issues.
+    """
+
+    def __init__(self, store: "CodebaseVectorStore"):
+        """Initialize the indexing worker.
+
+        Args:
+            store: CodebaseVectorStore instance for reindexing
+        """
+        import queue
+
+        self.store = store
+        self._queue: queue.Queue = queue.Queue(maxsize=1)  # Max 1 pending request (debouncing)
+        self._thread: threading.Thread | None = None
+        self._shutdown = threading.Event()
+        self._log_file = Path.home() / ".stravinsky" / "logs" / "file_watcher.log"
+        self._log_file.parent.mkdir(parents=True, exist_ok=True)
+
+    def start(self) -> None:
+        """Start the worker thread."""
+        if self._thread is not None and self._thread.is_alive():
+            logger.warning("Indexing worker already running")
+            return
+
+        self._shutdown.clear()
+        self._thread = threading.Thread(
+            target=self._run_worker, daemon=False, name="IndexingWorker"
+        )
+        self._thread.start()
+        logger.info(f"Started indexing worker for {self.store.project_path}")
+
+    def _log_error(self, msg: str, exc: Exception | None = None):
+        """Write error to log file with timestamp and full traceback."""
+        import traceback
+        from datetime import datetime
+
+        timestamp = datetime.now().isoformat()
+        try:
+            with open(self._log_file, "a") as f:
+                f.write(f"\n{'=' * 80}\n")
+                f.write(f"[{timestamp}] {msg}\n")
+                if exc:
+                    f.write(f"Exception: {type(exc).__name__}: {exc}\n")
+                    f.write(traceback.format_exc())
+                f.write(f"{'=' * 80}\n")
+        except Exception as log_exc:
+            logger.error(f"Failed to write to log file: {log_exc}")
+        logger.error(f"{msg} (logged to {self._log_file})")
+
+    def _run_worker(self) -> None:
+        """Worker thread entry point - processes queue with asyncio.run() per operation."""
+        import queue
+
+        self._log_error(f"🟢 File watcher started for {self.store.project_path}")
+
+        try:
+            while not self._shutdown.is_set():
+                try:
+                    # Wait for reindex request (blocking with timeout)
+                    self._queue.get(timeout=0.5)
+                    self._queue.task_done()
+
+                    # Use asyncio.run() for each operation (creates fresh loop)
+                    # This avoids "event loop already running" errors
+                    try:
+                        asyncio.run(self._do_reindex())
+                        self._log_error(f"✅ Reindex completed for {self.store.project_path}")
+                    except Exception as e:
+                        self._log_error(f"⚠️ Reindex failed for {self.store.project_path}", e)
+
+                except queue.Empty:
+                    continue  # No work, check shutdown flag
+                except Exception as e:
+                    self._log_error(f"⚠️ Queue processing error for {self.store.project_path}", e)
+
+        except Exception as e:
+            self._log_error(f"⚠️ Worker thread crashed for {self.store.project_path}", e)
+        finally:
+            self._log_error(f"🔴 File watcher stopped for {self.store.project_path}")
+
+    async def _do_reindex(self) -> None:
+        """Execute reindex with retry logic for ALL error types."""
+        import sqlite3
+
+        from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential
+
+        @retry(
+            stop=stop_after_attempt(3),
+            wait=wait_exponential(multiplier=1, min=2, max=10),
+            retry=retry_if_exception_type(
+                (
+                    httpx.HTTPError,
+                    ConnectionError,
+                    TimeoutError,
+                    sqlite3.OperationalError,  # Database locked
+                    OSError,  # File system errors
+                )
+            ),
+            reraise=True,
+        )
+        async def _indexed():
+            await self.store.index_codebase(force=False)
+
+        await _indexed()
+
+    def request_reindex(self, files: list[Path]) -> None:
+        """Request reindex from any thread (thread-safe).
+
+        Args:
+            files: List of files that changed (for logging only)
+        """
+        import queue
+
+        try:
+            # Non-blocking put - drops if queue full (natural debouncing)
+            self._queue.put_nowait("reindex")
+            logger.debug(f"📥 Queued reindex for {len(files)} files: {[f.name for f in files[:5]]}")
+        except queue.Full:
+            # Already have pending reindex - this is fine (debouncing)
+            logger.debug(f"Reindex already queued, skipping {len(files)} files")
+
+    def shutdown(self) -> None:
+        """Graceful shutdown of worker thread."""
+        if self._shutdown.is_set():
+            return  # Already shutting down
+
+        self._shutdown.set()
+        if self._thread is not None and self._thread.is_alive():
+            self._thread.join(timeout=10)  # Wait up to 10 seconds
+            if self._thread.is_alive():
+                self._log_error("⚠️ Worker thread failed to stop within timeout")
+            self._thread = None
+        logger.info("Indexing worker shut down")
+
+
 class CodebaseFileWatcher:
     """Watch a project directory for file changes and trigger reindexing.
 
@@ -2684,6 +3243,7 @@ class CodebaseFileWatcher:
     - Debounces rapid changes to batch them into a single reindex
     - Thread-safe with daemon threads for clean shutdown
     - Integrates with CodebaseVectorStore for incremental indexing
+    - Uses dedicated worker thread to prevent concurrent indexing
     """
 
     # Default debounce time in seconds
@@ -2709,6 +3269,9 @@ class CodebaseFileWatcher:
         # Observer and handler for watchdog
         self._observer = None
         self._event_handler = None
+        
+        # Native watcher
+        self._native_watcher: NativeFileWatcher | None = None
 
         # Thread safety
         self._lock = threading.Lock()
@@ -2719,10 +3282,14 @@ class CodebaseFileWatcher:
         self._pending_files: set[Path] = set()
         self._pending_lock = threading.Lock()
 
+        # Dedicated indexing worker (prevents concurrent access)
+        self._indexing_worker = DedicatedIndexingWorker(store)
+
     def start(self) -> None:
         """Start watching the project directory.
 
         Creates and starts a watchdog observer in a daemon thread.
+        Also starts the dedicated indexing worker thread.
         """
         with self._lock:
             if self._running:
@@ -2730,6 +3297,23 @@ class CodebaseFileWatcher:
                 return
 
             try:
+                # Start indexing worker first (must be running before file events arrive)
+                self._indexing_worker.start()
+
+                # Try native watcher first
+                try:
+                    self._native_watcher = NativeFileWatcher(
+                        str(self.project_path),
+                        on_change=lambda type, path: self._on_file_changed(Path(path))
+                    )
+                    self._native_watcher.start()
+                    self._running = True
+                    logger.info(f"Native file watcher started for {self.project_path}")
+                    return
+                except (FileNotFoundError, Exception) as e:
+                    logger.info(f"Native watcher not available, falling back to watchdog: {e}")
+                    self._native_watcher = None
+
                 watchdog = get_watchdog()
                 Observer = watchdog["Observer"]
 
@@ -2755,25 +3339,37 @@ class CodebaseFileWatcher:
             except Exception as e:
                 logger.error(f"Failed to start file watcher: {e}")
                 self._running = False
+                # Clean up worker if observer failed
+                self._indexing_worker.shutdown()
                 raise
 
     def stop(self) -> None:
         """Stop watching the project directory.
 
-        Cancels any pending reindex timers and stops the observer.
+        Cancels any pending reindex timers, stops the observer, and shuts down the indexing worker.
         """
         with self._lock:
-            # Cancel pending reindex
-            if self._pending_reindex_timer is not None:
-                self._pending_reindex_timer.cancel()
-                self._pending_reindex_timer = None
+            # Cancel pending reindex timer
+            with self._pending_lock:
+                if self._pending_reindex_timer:
+                    self._pending_reindex_timer.cancel()
+                    self._pending_reindex_timer = None
+                self._pending_files.clear()
+
+            # Stop native watcher
+            if self._native_watcher:
+                self._native_watcher.stop()
+                self._native_watcher = None
 
             # Stop observer
-            if self._observer is not None:
+            if self._observer:
                 self._observer.stop()
                 self._observer.join(timeout=5)  # Wait up to 5 seconds for shutdown
                 self._observer = None
 
+            # Shutdown indexing worker
+            self._indexing_worker.shutdown()
+
             self._event_handler = None
             self._running = False
             logger.info(f"File watcher stopped for {self.project_path}")
@@ -2820,11 +3416,9 @@ class CodebaseFileWatcher:
     def _trigger_reindex(self) -> None:
         """Trigger reindexing of accumulated changed files.
 
-        This is called after the debounce period expires. It performs an
-        incremental reindex focusing on the changed files.
+        This is called after the debounce period expires. Delegates to the
+        dedicated indexing worker to prevent concurrent access.
         """
-        import asyncio
-
         with self._pending_lock:
             if not self._pending_files:
                 self._pending_reindex_timer = None
@@ -2834,17 +3428,8 @@ class CodebaseFileWatcher:
             self._pending_files.clear()
             self._pending_reindex_timer = None
 
-        # Run async reindex in a new event loop
-        try:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                loop.run_until_complete(self.store.index_codebase(force=False))
-                logger.debug(f"Reindexed {len(files_to_index)} changed files")
-            finally:
-                loop.close()
-        except Exception as e:
-            logger.error(f"Error during file watcher reindex: {e}")
+        # Delegate to dedicated worker (prevents concurrent indexing)
+        self._indexing_worker.request_reindex(files_to_index)
 
 
 def _create_file_change_handler_class():