mcp-vector-search 0.12.0__py3-none-any.whl → 0.12.1__py3-none-any.whl

mcp_vector_search/cli/didyoumean.py

@@ -57,6 +57,11 @@ class EnhancedDidYouMeanTyper(typer.Typer):
         # Get the underlying click group
         click_group = super().__call__(*args, **kwargs)
 
+        # If click_group is None (command already executed), return None
+        # This happens after command execution completes successfully
+        if click_group is None:
+            return None
+
         # Create enhanced DYM group with original group's properties
         enhanced_group = EnhancedDidYouMeanGroup(
             name=click_group.name,
@@ -161,6 +166,11 @@ def enhance_existing_typer(app: typer.Typer) -> typer.Typer:
         """Enhanced call that uses EnhancedDidYouMeanGroup."""
         click_group = original_call(*args, **kwargs)
 
+        # If click_group is None (command already executed), return None
+        # This happens after command execution completes successfully
+        if click_group is None:
+            return None
+
         # Create enhanced group
         enhanced_group = EnhancedDidYouMeanGroup(
             name=click_group.name,

mcp_vector_search/cli/main.py

@@ -33,13 +33,15 @@ unfamiliar codebases, finding similar patterns, and integrating with AI tools.
   3. Check status: [green]mcp-vector-search status[/green]
 
 [bold cyan]Main Commands:[/bold cyan]
-  init       🔧 Initialize project
+  install    📦 Install project and MCP integrations
+  uninstall  🗑️  Remove MCP integrations
+  init       🔧 Initialize project (simple)
   demo       🎬 Run interactive demo
   doctor     🩺 Check system health
   status     📊 Show project status
   search     🔍 Search code semantically
   index      📇 Index codebase
-  mcp        🤖 MCP integration for AI tools
+  mcp        🔌 MCP server operations
   config     ⚙️  Configure settings
   visualize  📊 Visualize code relationships
   help       ❓ Get help
@@ -56,48 +58,61 @@ from .commands.config import config_app  # noqa: E402
 from .commands.demo import demo_app  # noqa: E402
 from .commands.index import index_app  # noqa: E402
 from .commands.init import init_app  # noqa: E402
+from .commands.install import install_app  # noqa: E402
 from .commands.mcp import mcp_app  # noqa: E402
 from .commands.search import search_app, search_main  # noqa: E402, F401
 from .commands.status import main as status_main  # noqa: E402
+from .commands.uninstall import uninstall_app  # noqa: E402
 from .commands.visualize import app as visualize_app  # noqa: E402
 
 # ============================================================================
 # MAIN COMMANDS - Clean hierarchy
 # ============================================================================
 
-# 1. INIT - Initialize project
+# 1. INSTALL - Install project and MCP integrations (NEW!)
+app.add_typer(
+    install_app, name="install", help="📦 Install project and MCP integrations"
+)
+
+# 2. UNINSTALL - Remove MCP integrations (NEW!)
+app.add_typer(uninstall_app, name="uninstall", help="🗑️  Remove MCP integrations")
+app.add_typer(uninstall_app, name="remove", help="🗑️  Remove MCP integrations (alias)")
+
+# 3. INIT - Initialize project (simplified)
 # Use Typer group for init to support both direct call and subcommands
 app.add_typer(init_app, name="init", help="🔧 Initialize project for semantic search")
 
-# 2. DEMO - Interactive demo
+# 4. DEMO - Interactive demo
 app.add_typer(demo_app, name="demo", help="🎬 Run interactive demo with sample project")
 
-# 3. DOCTOR - System health check
+# 5. DOCTOR - System health check
 # (defined below inline)
 
-# 4. STATUS - Project status
+# 6. STATUS - Project status
 app.command("status", help="📊 Show project status and statistics")(status_main)
 
-# 5. SEARCH - Search code
+# 7. SEARCH - Search code
 # Register search as both a command and a typer group
 app.add_typer(search_app, name="search", help="🔍 Search code semantically")
 
-# 6. INDEX - Index codebase
+# 8. INDEX - Index codebase
 app.add_typer(index_app, name="index", help="📇 Index codebase for semantic search")
 
-# 7. MCP - MCP integration
-app.add_typer(mcp_app, name="mcp", help="🤖 Manage MCP integration for AI tools")
+# 9. MCP - MCP server operations (RESERVED for server ops only!)
+app.add_typer(mcp_app, name="mcp", help="🔌 MCP server operations")
 
-# 8. CONFIG - Configuration
+# 10. CONFIG - Configuration
 app.add_typer(config_app, name="config", help="⚙️  Manage project configuration")
 
-# 9. VISUALIZE - Code graph visualization
-app.add_typer(visualize_app, name="visualize", help="📊 Visualize code chunk relationships")
+# 11. VISUALIZE - Code graph visualization
+app.add_typer(
+    visualize_app, name="visualize", help="📊 Visualize code chunk relationships"
+)
 
-# 10. HELP - Enhanced help
+# 12. HELP - Enhanced help
 # (defined below inline)
 
-# 10. VERSION - Version info
+# 13. VERSION - Version info
 # (defined below inline)
 
 
@@ -120,11 +135,9 @@ def _deprecated_command(old_cmd: str, new_cmd: str):
     return wrapper
 
 
-# Deprecated: install -> init
-@app.command("install", hidden=True)
-def deprecated_install():
-    """[DEPRECATED] Use 'init' instead."""
-    _deprecated_command("install", "init")()
+# NOTE: 'install' command is now the primary command for project installation
+# Old 'install' was deprecated in favor of 'init' in v0.7.0
+# Now 'install' is back as the hierarchical installation command in v0.13.0
 
 
 # Deprecated: find -> search
@@ -432,7 +445,12 @@ def cli_with_suggestions():
     except Exception as e:
         # For other exceptions, show error and exit if verbose logging is enabled
         # Suppress internal framework errors in normal operation
-        if "--verbose" in sys.argv or "-v" in sys.argv:
+
+        # Suppress harmless didyoumean framework AttributeError (known issue)
+        # This occurs during Click/Typer cleanup after successful command completion
+        if isinstance(e, AttributeError) and "attribute" in str(e) and "name" in str(e):
+            pass  # Ignore - this is a harmless framework cleanup error
+        elif "--verbose" in sys.argv or "-v" in sys.argv:
             click.echo(f"Unexpected error: {e}", err=True)
             sys.exit(1)
         # Otherwise, just exit silently to avoid confusing error messages

mcp_vector_search/core/connection_pool.py

@@ -24,6 +24,16 @@ class PooledConnection:
     in_use: bool = False
     use_count: int = 0
 
+    @property
+    def age(self) -> float:
+        """Get the age of this connection in seconds."""
+        return time.time() - self.created_at
+
+    @property
+    def idle_time(self) -> float:
+        """Get the idle time of this connection in seconds."""
+        return time.time() - self.last_used
+
 
 class ChromaConnectionPool:
     """Connection pool for ChromaDB operations."""
@@ -209,18 +219,18 @@ class ChromaConnectionPool:
                 logger.debug(f"Created new connection (pool size: {len(self._pool)})")
                 return conn
 
-            # Pool is full, wait for a connection to become available
-            self._stats["pool_misses"] += 1
-            logger.warning(
-                "Connection pool exhausted, waiting for available connection"
-            )
+        # Pool is full, wait for a connection to become available (outside lock)
+        self._stats["pool_misses"] += 1
+        logger.warning("Connection pool exhausted, waiting for available connection")
 
-            # Wait for a connection (with timeout)
-            timeout = 30.0  # 30 seconds
-            start_time = time.time()
+        # Wait for a connection (with timeout) - release lock during wait
+        timeout = 30.0  # 30 seconds
+        start_time = time.time()
 
-            while time.time() - start_time < timeout:
-                await asyncio.sleep(0.1)
+        while time.time() - start_time < timeout:
+            await asyncio.sleep(0.1)
+            # Re-acquire lock to check for available connections
+            async with self._lock:
                 for conn in self._pool:
                     if not conn.in_use and self._is_connection_valid(conn):
                         conn.in_use = True
@@ -229,7 +239,7 @@ class ChromaConnectionPool:
                         self._stats["connections_reused"] += 1
                         return conn
 
-            raise DatabaseError("Connection pool timeout: no connections available")
+        raise DatabaseError("Connection pool timeout: no connections available")
 
     async def _release_connection(self, conn: PooledConnection) -> None:
         """Release a connection back to the pool."""
@@ -320,3 +330,31 @@ class ChromaConnectionPool:
         except Exception as e:
             logger.error(f"Connection pool health check failed: {e}")
             return False
+
+    # Backward compatibility aliases for old test API
+    async def cleanup(self) -> None:
+        """Alias for close() method (backward compatibility)."""
+        await self.close()
+
+    def _validate_connection(self, conn: PooledConnection) -> bool:
+        """Alias for _is_connection_valid() method (backward compatibility)."""
+        return self._is_connection_valid(conn)
+
+    async def _cleanup_idle_connections(self) -> None:
+        """Alias for _cleanup_expired_connections() method (backward compatibility)."""
+        await self._cleanup_expired_connections()
+
+    @property
+    def _connections(self) -> list[PooledConnection]:
+        """Alias for _pool attribute (backward compatibility)."""
+        return self._pool
+
+    @property
+    def _max_connections(self) -> int:
+        """Alias for max_connections attribute (backward compatibility)."""
+        return self.max_connections
+
+    @property
+    def _min_connections(self) -> int:
+        """Alias for min_connections attribute (backward compatibility)."""
+        return self.min_connections

mcp_vector_search/core/database.py

@@ -501,13 +501,11 @@ class ChromaVectorDatabase(VectorDatabase):
 
         try:
             # Get all documents from collection
-            results = self._collection.get(
-                include=["metadatas", "documents"]
-            )
+            results = self._collection.get(include=["metadatas", "documents"])
 
             chunks = []
             if results and results.get("ids"):
-                for i, chunk_id in enumerate(results["ids"]):
+                for i, _chunk_id in enumerate(results["ids"]):
                     metadata = results["metadatas"][i]
                     content = results["documents"][i]
 
@@ -802,7 +800,9 @@ class PooledChromaVectorDatabase(VectorDatabase):
                             "decorators": json.dumps(chunk.decorators or []),
                             "parameters": json.dumps(chunk.parameters or []),
                             "return_type": chunk.return_type or "",
-                            "type_annotations": json.dumps(chunk.type_annotations or {}),
+                            "type_annotations": json.dumps(
+                                chunk.type_annotations or {}
+                            ),
                             # Monorepo support
                             "subproject_name": chunk.subproject_name or "",
                             "subproject_path": chunk.subproject_path or "",
@@ -1031,13 +1031,11 @@ class PooledChromaVectorDatabase(VectorDatabase):
         try:
             async with self._pool.get_connection() as conn:
                 # Get all documents from collection
-                results = conn.collection.get(
-                    include=["metadatas", "documents"]
-                )
+                results = conn.collection.get(include=["metadatas", "documents"])
 
                 chunks = []
                 if results and results.get("ids"):
-                    for i, chunk_id in enumerate(results["ids"]):
+                    for i, _chunk_id in enumerate(results["ids"]):
                         metadata = results["metadatas"][i]
                         content = results["documents"][i]
 

mcp_vector_search/core/directory_index.py

@@ -22,7 +22,9 @@ class DirectoryIndex:
         self.index_path = index_path
         self.directories: dict[str, Directory] = {}  # path -> Directory
         self.file_to_directory: dict[str, str] = {}  # file_path -> directory_path
-        self.directory_files: dict[str, list[str]] = defaultdict(list)  # dir_path -> [file_paths]
+        self.directory_files: dict[str, list[str]] = defaultdict(
+            list
+        )  # dir_path -> [file_paths]
 
     def load(self) -> None:
         """Load directory index from disk."""
@@ -31,7 +33,7 @@ class DirectoryIndex:
             return
 
         try:
-            with open(self.index_path, "r") as f:
+            with open(self.index_path) as f:
                 data = json.load(f)
 
             # Load directories
@@ -138,7 +140,7 @@ class DirectoryIndex:
         parent_path_str = str(directory_path)
         subdirs = []
 
-        for dir_path_str, directory in self.directories.items():
+        for _dir_path_str, directory in self.directories.items():
             if directory.parent_path and str(directory.parent_path) == parent_path_str:
                 subdirs.append(directory)
 
@@ -195,7 +197,12 @@ class DirectoryIndex:
                         self.directory_files[dir_path]
                     )
 
-    def rebuild_from_files(self, file_paths: list[Path], root_path: Path, chunk_stats: dict[str, dict] | None = None) -> None:
+    def rebuild_from_files(
+        self,
+        file_paths: list[Path],
+        root_path: Path,
+        chunk_stats: dict[str, dict] | None = None,
+    ) -> None:
         """Rebuild directory index from list of files with statistics from chunks.
 
         Args:
@@ -210,7 +217,9 @@ class DirectoryIndex:
         # Track all unique directories and their statistics
         dir_set = set()
         dir_chunks = defaultdict(int)  # directory -> total chunks
-        dir_languages = defaultdict(lambda: defaultdict(int))  # directory -> {language: count}
+        dir_languages = defaultdict(
+            lambda: defaultdict(int)
+        )  # directory -> {language: count}
         dir_modified = defaultdict(float)  # directory -> most recent modification time
 
         for file_path in file_paths:
@@ -227,12 +236,16 @@ class DirectoryIndex:
                     # Accumulate statistics up the directory tree
                     if chunk_stats and str(file_path) in chunk_stats:
                         stats = chunk_stats[str(file_path)]
-                        dir_chunks[current] += stats.get('chunks', 0)
-                        if 'language' in stats:
-                            dir_languages[current][stats['language']] += stats.get('chunks', 0)
+                        dir_chunks[current] += stats.get("chunks", 0)
+                        if "language" in stats:
+                            dir_languages[current][stats["language"]] += stats.get(
+                                "chunks", 0
+                            )
                         # Track most recent modification time
-                        if 'modified' in stats:
-                            dir_modified[current] = max(dir_modified.get(current, 0), stats['modified'])
+                        if "modified" in stats:
+                            dir_modified[current] = max(
+                                dir_modified.get(current, 0), stats["modified"]
+                            )
 
                     current = current.parent
 
@@ -276,7 +289,9 @@ class DirectoryIndex:
             subdirs = self.get_subdirectories(directory.path)
             directory.subdirectory_count = len(subdirs)
 
-        logger.info(f"Rebuilt directory index with {len(self.directories)} directories, {sum(dir_chunks.values())} total chunks")
+        logger.info(
+            f"Rebuilt directory index with {len(self.directories)} directories, {sum(dir_chunks.values())} total chunks"
+        )
 
     def get_stats(self) -> dict[str, Any]:
         """Get directory index statistics.

mcp_vector_search/core/indexer.py

@@ -17,7 +17,7 @@ from ..utils.monorepo import MonorepoDetector
 from .database import VectorDatabase
 from .directory_index import DirectoryIndex
 from .exceptions import ParsingError
-from .models import CodeChunk
+from .models import CodeChunk, IndexStats
 
 
 class SemanticIndexer:
@@ -179,8 +179,8 @@ class SemanticIndexer:
                         # For now, just track modification time
                         # Chunk counts will be aggregated from the database later if needed
                         chunk_stats[str(file_path)] = {
-                            'modified': mtime,
-                            'chunks': 1,  # Placeholder - real count from chunks
+                            "modified": mtime,
+                            "chunks": 1,  # Placeholder - real count from chunks
                         }
                     except OSError:
                         pass
@@ -197,6 +197,7 @@ class SemanticIndexer:
             except Exception as e:
                 logger.error(f"Failed to update directory index: {e}")
                 import traceback
+
                 logger.debug(traceback.format_exc())
 
         logger.info(
@@ -351,8 +352,14 @@ class SemanticIndexer:
             chunks_with_hierarchy = self._build_chunk_hierarchy(chunks)
 
             # Debug: Check if hierarchy was built
-            methods_with_parents = sum(1 for c in chunks_with_hierarchy if c.chunk_type in ("method", "function") and c.parent_chunk_id)
-            logger.debug(f"After hierarchy build: {methods_with_parents}/{len([c for c in chunks_with_hierarchy if c.chunk_type in ('method', 'function')])} methods have parents")
+            methods_with_parents = sum(
+                1
+                for c in chunks_with_hierarchy
+                if c.chunk_type in ("method", "function") and c.parent_chunk_id
+            )
+            logger.debug(
+                f"After hierarchy build: {methods_with_parents}/{len([c for c in chunks_with_hierarchy if c.chunk_type in ('method', 'function')])} methods have parents"
+            )
 
             # Add chunks to database
             await self.database.add_chunks(chunks_with_hierarchy)
@@ -443,7 +450,11 @@ class SemanticIndexer:
             # Filter out ignored directories IN-PLACE to prevent os.walk from traversing them
             # This is much more efficient than checking every file in ignored directories
             # PERFORMANCE: Pass is_directory=True hint to skip filesystem stat() calls
-            dirs[:] = [d for d in dirs if not self._should_ignore_path(root_path / d, is_directory=True)]
+            dirs[:] = [
+                d
+                for d in dirs
+                if not self._should_ignore_path(root_path / d, is_directory=True)
+            ]
 
             # Check each file in the current directory
             # PERFORMANCE: skip_file_check=True because os.walk guarantees these are files
@@ -489,7 +500,9 @@ class SemanticIndexer:
 
         return self._indexable_files_cache
 
-    def _should_index_file(self, file_path: Path, skip_file_check: bool = False) -> bool:
+    def _should_index_file(
+        self, file_path: Path, skip_file_check: bool = False
+    ) -> bool:
         """Check if a file should be indexed.
 
         Args:
@@ -525,7 +538,9 @@ class SemanticIndexer:
 
         return True
 
-    def _should_ignore_path(self, file_path: Path, is_directory: bool | None = None) -> bool:
+    def _should_ignore_path(
+        self, file_path: Path, is_directory: bool | None = None
+    ) -> bool:
         """Check if a path should be ignored.
 
         Args:
@@ -538,7 +553,9 @@ class SemanticIndexer:
         try:
             # First check gitignore rules if available
             # PERFORMANCE: Pass is_directory hint to avoid redundant stat() calls
-            if self.gitignore_parser and self.gitignore_parser.is_ignored(file_path, is_directory=is_directory):
+            if self.gitignore_parser and self.gitignore_parser.is_ignored(
+                file_path, is_directory=is_directory
+            ):
                 logger.debug(f"Path ignored by .gitignore: {file_path}")
                 return True
 
@@ -677,24 +694,34 @@ class SemanticIndexer:
             # If we can't parse versions, be safe and reindex
             return True
 
-    async def get_indexing_stats(self) -> dict:
+    async def get_indexing_stats(self, db_stats: IndexStats | None = None) -> dict:
         """Get statistics about the indexing process.
 
+        Args:
+            db_stats: Optional pre-fetched database stats to avoid duplicate queries
+
         Returns:
             Dictionary with indexing statistics
+
+        Note:
+            Uses database statistics only for performance on large projects.
+            Filesystem scanning would timeout on 100K+ file projects.
+            Pass db_stats parameter to avoid calling database.get_stats() twice.
         """
         try:
-            # Get database stats
-            db_stats = await self.database.get_stats()
-
-            # Count indexable files asynchronously without blocking
-            indexable_files = await self._find_indexable_files_async()
+            # Get database stats if not provided (fast, no filesystem scan)
+            if db_stats is None:
+                db_stats = await self.database.get_stats()
 
+            # Use database stats for all file counts
+            # This avoids expensive filesystem scans on large projects
             return {
-                "total_indexable_files": len(indexable_files),
+                "total_indexable_files": db_stats.total_files,
                 "indexed_files": db_stats.total_files,
+                "total_files": db_stats.total_files,  # For backward compatibility
                 "total_chunks": db_stats.total_chunks,
                 "languages": db_stats.languages,
+                "file_types": db_stats.file_types,  # Include file type distribution
                 "file_extensions": list(self.file_extensions),
                 "ignore_patterns": list(self._ignore_patterns),
                 "parser_info": self.parser_registry.get_parser_info(),
@@ -706,6 +733,7 @@ class SemanticIndexer:
                 "error": str(e),
                 "total_indexable_files": 0,
                 "indexed_files": 0,
+                "total_files": 0,
                 "total_chunks": 0,
             }
 
@@ -799,9 +827,14 @@ class SemanticIndexer:
 
                     # Save error to error log file
                     try:
-                        error_log_path = self.project_root / ".mcp-vector-search" / "indexing_errors.log"
+                        error_log_path = (
+                            self.project_root
+                            / ".mcp-vector-search"
+                            / "indexing_errors.log"
+                        )
                         with open(error_log_path, "a", encoding="utf-8") as f:
                             from datetime import datetime
+
                             timestamp = datetime.now().isoformat()
                             f.write(f"[{timestamp}] {error_msg}\n")
                     except Exception as log_err:
@@ -834,25 +867,38 @@ class SemanticIndexer:
 
         # Group chunks by type and name
         module_chunks = [c for c in chunks if c.chunk_type in ("module", "imports")]
-        class_chunks = [c for c in chunks if c.chunk_type in ("class", "interface", "mixin")]
-        function_chunks = [c for c in chunks if c.chunk_type in ("function", "method", "constructor")]
+        class_chunks = [
+            c for c in chunks if c.chunk_type in ("class", "interface", "mixin")
+        ]
+        function_chunks = [
+            c for c in chunks if c.chunk_type in ("function", "method", "constructor")
+        ]
 
         # DEBUG: Print what we have (if debug enabled)
         if self.debug:
             import sys
-            print(f"\n[DEBUG] Building hierarchy: {len(module_chunks)} modules, {len(class_chunks)} classes, {len(function_chunks)} functions", file=sys.stderr)
+
+            print(
+                f"\n[DEBUG] Building hierarchy: {len(module_chunks)} modules, {len(class_chunks)} classes, {len(function_chunks)} functions",
+                file=sys.stderr,
+            )
             if class_chunks:
-                print(f"[DEBUG] Class names: {[c.class_name for c in class_chunks[:5]]}", file=sys.stderr)
+                print(
+                    f"[DEBUG] Class names: {[c.class_name for c in class_chunks[:5]]}",
+                    file=sys.stderr,
+                )
             if function_chunks:
-                print(f"[DEBUG] First 5 functions with class_name: {[(f.function_name, f.class_name) for f in function_chunks[:5]]}", file=sys.stderr)
+                print(
+                    f"[DEBUG] First 5 functions with class_name: {[(f.function_name, f.class_name) for f in function_chunks[:5]]}",
+                    file=sys.stderr,
+                )
 
         # Build relationships
         for func in function_chunks:
             if func.class_name:
                 # Find parent class
                 parent_class = next(
-                    (c for c in class_chunks if c.class_name == func.class_name),
-                    None
+                    (c for c in class_chunks if c.class_name == func.class_name), None
                 )
                 if parent_class:
                     func.parent_chunk_id = parent_class.chunk_id
@@ -861,8 +907,14 @@ class SemanticIndexer:
                         parent_class.child_chunk_ids.append(func.chunk_id)
                     if self.debug:
                         import sys
-                        print(f"[DEBUG] ✓ Linked '{func.function_name}' to class '{parent_class.class_name}'", file=sys.stderr)
-                    logger.debug(f"Linked method '{func.function_name}' (ID: {func.chunk_id[:8]}) to class '{parent_class.class_name}' (ID: {parent_class.chunk_id[:8]})")
+
+                        print(
+                            f"[DEBUG] ✓ Linked '{func.function_name}' to class '{parent_class.class_name}'",
+                            file=sys.stderr,
+                        )
+                    logger.debug(
+                        f"Linked method '{func.function_name}' (ID: {func.chunk_id[:8]}) to class '{parent_class.class_name}' (ID: {parent_class.chunk_id[:8]})"
+                    )
             else:
                 # Top-level function
                 if not func.chunk_depth:
@@ -891,23 +943,31 @@ class SemanticIndexer:
         # DEBUG: Print summary
         if self.debug:
             import sys
+
             funcs_with_parents = sum(1 for f in function_chunks if f.parent_chunk_id)
             classes_with_parents = sum(1 for c in class_chunks if c.parent_chunk_id)
-            print(f"[DEBUG] Hierarchy built: {funcs_with_parents}/{len(function_chunks)} functions linked, {classes_with_parents}/{len(class_chunks)} classes linked\n", file=sys.stderr)
+            print(
+                f"[DEBUG] Hierarchy built: {funcs_with_parents}/{len(function_chunks)} functions linked, {classes_with_parents}/{len(class_chunks)} classes linked\n",
+                file=sys.stderr,
+            )
 
         return chunks
 
     def _write_indexing_run_header(self) -> None:
         """Write version and timestamp header to error log at start of indexing run."""
         try:
-            error_log_path = self.project_root / ".mcp-vector-search" / "indexing_errors.log"
+            error_log_path = (
+                self.project_root / ".mcp-vector-search" / "indexing_errors.log"
+            )
             error_log_path.parent.mkdir(parents=True, exist_ok=True)
 
             with open(error_log_path, "a", encoding="utf-8") as f:
                 timestamp = datetime.now(UTC).isoformat()
                 separator = "=" * 80
                 f.write(f"\n{separator}\n")
-                f.write(f"[{timestamp}] Indexing run started - mcp-vector-search v{__version__}\n")
+                f.write(
+                    f"[{timestamp}] Indexing run started - mcp-vector-search v{__version__}\n"
+                )
                 f.write(f"{separator}\n")
         except Exception as e:
             logger.debug(f"Failed to write indexing run header: {e}")

mcp_vector_search/core/models.py

@@ -219,7 +219,9 @@ class Directory:
     languages: dict[str, int] = None  # Language distribution in this directory
     depth: int = 0  # Depth from project root (0 = root)
     is_package: bool = False  # True if contains __init__.py or package.json
-    last_modified: float | None = None  # Most recent file modification time (unix timestamp)
+    last_modified: float | None = (
+        None  # Most recent file modification time (unix timestamp)
+    )
 
     def __post_init__(self) -> None:
         """Initialize default values and generate directory ID."""
@@ -230,6 +232,7 @@ class Directory:
     def id(self) -> str:
         """Generate unique ID for this directory."""
         import hashlib
+
         return hashlib.sha256(str(self.path).encode()).hexdigest()[:16]
 
     def to_dict(self) -> dict[str, Any]: