mcp-vector-search 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

mcp_vector_search/__init__.py

@@ -1,7 +1,7 @@
 """MCP Vector Search - CLI-first semantic code search with MCP integration."""
 
-__version__ = "0.5.1"
-__build__ = "19"
+__version__ = "0.6.1"
+__build__ = "21"
 __author__ = "Robert Matsuoka"
 __email__ = "bobmatnyc@gmail.com"
 

mcp_vector_search/cli/commands/index.py

@@ -22,11 +22,14 @@ from ..output import (
     print_tip,
 )
 
-# Create index subcommand app
-index_app = typer.Typer(help="Index codebase for semantic search")
+# Create index subcommand app with callback for direct usage
+index_app = typer.Typer(
+    help="Index codebase for semantic search",
+    invoke_without_command=True,
+)
 
 
-@index_app.command()
+@index_app.callback(invoke_without_command=True)
 def main(
     ctx: typer.Context,
     watch: bool = typer.Option(
@@ -95,8 +98,12 @@ def main(
 
     [dim]💡 Tip: Use incremental indexing (default) for faster updates on subsequent runs.[/dim]
     """
+    # If a subcommand was invoked, don't run the indexing logic
+    if ctx.invoked_subcommand is not None:
+        return
+
     try:
-        project_root = ctx.obj.get("project_root") or Path.cwd()
+        project_root = (ctx.obj.get("project_root") if ctx.obj else None) or Path.cwd()
 
         # Run async indexing
         asyncio.run(

mcp_vector_search/cli/commands/init.py

@@ -5,6 +5,11 @@ from pathlib import Path
 import typer
 from loguru import logger
 
+from ...config.constants import (
+    SUBPROCESS_INSTALL_TIMEOUT,
+    SUBPROCESS_MCP_TIMEOUT,
+    SUBPROCESS_TEST_TIMEOUT,
+)
 from ...config.defaults import DEFAULT_EMBEDDING_MODELS, DEFAULT_FILE_EXTENSIONS
 from ...core.exceptions import ProjectInitializationError
 from ...core.project import ProjectManager
@@ -150,11 +155,15 @@ def main(
                 install_cmd = ["pip", "install", "-e", str(dev_source_path)]
                 try:
                     result = subprocess.run(
-                        install_cmd, capture_output=True, text=True, timeout=120
+                        install_cmd,
+                        capture_output=True,
+                        text=True,
+                        timeout=SUBPROCESS_INSTALL_TIMEOUT,
                     )
                     if result.returncode == 0:
                         install_success = True
-                except:
+                except (subprocess.TimeoutExpired, OSError, ValueError) as e:
+                    logger.debug(f"pip install method failed: {e}")
                     pass
 
             # Method 2: Try python -m pip
@@ -169,11 +178,15 @@ def main(
                 ]
                 try:
                     result = subprocess.run(
-                        install_cmd, capture_output=True, text=True, timeout=120
+                        install_cmd,
+                        capture_output=True,
+                        text=True,
+                        timeout=SUBPROCESS_INSTALL_TIMEOUT,
                     )
                     if result.returncode == 0:
                         install_success = True
-                except:
+                except (subprocess.TimeoutExpired, OSError, ValueError) as e:
+                    logger.debug(f"python -m pip install method failed: {e}")
                     pass
 
             # Method 3: Try uv if available
@@ -181,11 +194,15 @@ def main(
                 install_cmd = ["uv", "add", "--editable", str(dev_source_path)]
                 try:
                     result = subprocess.run(
-                        install_cmd, capture_output=True, text=True, timeout=120
+                        install_cmd,
+                        capture_output=True,
+                        text=True,
+                        timeout=SUBPROCESS_INSTALL_TIMEOUT,
                     )
                     if result.returncode == 0:
                         install_success = True
-                except:
+                except (subprocess.TimeoutExpired, OSError, ValueError) as e:
+                    logger.debug(f"uv add method failed: {e}")
                     pass
 
             if install_success:
@@ -502,7 +519,10 @@ async def run_init_setup(
                 ] + server_command.split()
 
                 result = subprocess.run(
-                    cmd_args, capture_output=True, text=True, timeout=30
+                    cmd_args,
+                    capture_output=True,
+                    text=True,
+                    timeout=SUBPROCESS_MCP_TIMEOUT,
                 )
 
                 if result.returncode == 0:
@@ -663,7 +683,7 @@ def _test_mcp_server(project_root: Path) -> None:
 
         try:
             stdout, stderr = test_process.communicate(
-                input=json.dumps(init_request) + "\n", timeout=10
+                input=json.dumps(init_request) + "\n", timeout=SUBPROCESS_TEST_TIMEOUT
             )
 
             if test_process.returncode == 0:

mcp_vector_search/cli/commands/install.py

@@ -40,22 +40,22 @@ def detect_ai_tools() -> dict[str, Path]:
         Dictionary mapping tool names to their config file paths.
         For Claude Code, returns a placeholder path since it uses project-scoped .mcp.json
     """
-    HOME = Path.home()
+    home = Path.home()
 
-    CONFIG_LOCATIONS = {
-        "claude-desktop": HOME
+    config_locations = {
+        "claude-desktop": home
         / "Library"
         / "Application Support"
         / "Claude"
         / "claude_desktop_config.json",
-        "cursor": HOME / ".cursor" / "mcp.json",
-        "windsurf": HOME / ".codeium" / "windsurf" / "mcp_config.json",
-        "vscode": HOME / ".vscode" / "mcp.json",
+        "cursor": home / ".cursor" / "mcp.json",
+        "windsurf": home / ".codeium" / "windsurf" / "mcp_config.json",
+        "vscode": home / ".vscode" / "mcp.json",
     }
 
     # Return only tools with existing config files
     detected_tools = {}
-    for tool_name, config_path in CONFIG_LOCATIONS.items():
+    for tool_name, config_path in config_locations.items():
         if config_path.exists():
             detected_tools[tool_name] = config_path
 
@@ -587,12 +587,12 @@ def main():
 
 class UserService:
     '''Service for managing users.'''
-    
+
     def create_user(self, name: str, email: str):
         '''Create a new user with the given name and email.'''
         print(f"Creating user: {name} ({email})")
         return {"name": name, "email": email}
-    
+
     def authenticate_user(self, email: str, password: str):
         '''Authenticate user with email and password.'''
         # Simple authentication logic

mcp_vector_search/cli/commands/reset.py

@@ -83,7 +83,7 @@ def reset_index(
                 raise typer.Exit(0)
 
         # Get the database directory
-        config = project_manager.load_config()
+        project_manager.load_config()
         db_path = root / ".mcp_vector_search" / "db"
 
         if not db_path.exists():

mcp_vector_search/cli/commands/search.py

@@ -9,6 +9,7 @@ from loguru import logger
 from ...core.database import ChromaVectorDatabase
 from ...core.embeddings import create_embedding_function
 from ...core.exceptions import ProjectNotFoundError
+from ...core.indexer import SemanticIndexer
 from ...core.project import ProjectManager
 from ...core.search import SemanticSearchEngine
 from ..didyoumean import create_enhanced_typer
@@ -258,6 +259,47 @@ async def run_search(
         embedding_function=embedding_function,
     )
 
+    # Create indexer for version check
+    indexer = SemanticIndexer(
+        database=database,
+        project_root=project_root,
+        file_extensions=config.file_extensions,
+    )
+
+    # Check if reindex is needed due to version upgrade
+    if config.auto_reindex_on_upgrade and indexer.needs_reindex_for_version():
+        from ..output import console
+
+        index_version = indexer.get_index_version()
+        from ... import __version__
+
+        if index_version:
+            console.print(
+                f"[yellow]⚠️  Index created with version {index_version} (current: {__version__})[/yellow]"
+            )
+        else:
+            console.print(
+                "[yellow]⚠️  Index version not found (legacy format detected)[/yellow]"
+            )
+
+        console.print(
+            "[yellow]   Reindexing to take advantage of improvements...[/yellow]"
+        )
+
+        # Auto-reindex with progress
+        try:
+            indexed_count = await indexer.index_project(
+                force_reindex=True, show_progress=False
+            )
+            console.print(
+                f"[green]✓ Index updated to version {__version__} ({indexed_count} files reindexed)[/green]\n"
+            )
+        except Exception as e:
+            console.print(f"[red]✗ Reindexing failed: {e}[/red]")
+            console.print(
+                "[yellow]  Continuing with existing index (may have outdated patterns)[/yellow]\n"
+            )
+
     search_engine = SemanticSearchEngine(
         database=database,
         project_root=project_root,

mcp_vector_search/cli/commands/status.py

@@ -9,6 +9,7 @@ from typing import Any
 import typer
 from loguru import logger
 
+from ... import __version__
 from ...core.database import ChromaVectorDatabase
 from ...core.embeddings import create_embedding_function
 from ...core.exceptions import ProjectNotFoundError
@@ -165,6 +166,10 @@ async def show_status(
             index_stats = await indexer.get_indexing_stats()
             db_stats = await database.get_stats()
 
+        # Get version information
+        index_version = indexer.get_index_version()
+        needs_reindex = indexer.needs_reindex_for_version()
+
         # Compile status data
         status_data = {
             "project": {
@@ -181,6 +186,7 @@ async def show_status(
                 "max_chunk_size": config.max_chunk_size,
                 "cache_embeddings": config.cache_embeddings,
                 "watch_files": config.watch_files,
+                "auto_reindex_on_upgrade": config.auto_reindex_on_upgrade,
             },
             "index": {
                 "total_files": index_stats.get("total_indexable_files", 0),
@@ -189,6 +195,9 @@ async def show_status(
                 "languages": index_stats.get("languages", {}),
                 "index_size_mb": db_stats.index_size_mb,
                 "last_updated": db_stats.last_updated,
+                "index_version": index_version,
+                "current_version": __version__,
+                "needs_reindex": needs_reindex,
             },
         }
 
@@ -267,12 +276,36 @@ def _display_status(
     console.print(f"  Total Chunks: {index_data['total_chunks']}")
     console.print(f"  Index Size: {index_data['index_size_mb']:.2f} MB")
 
+    # Version information
+    index_version = index_data.get("index_version")
+    current_version = index_data.get("current_version", __version__)
+    needs_reindex = index_data.get("needs_reindex", False)
+
+    if index_version:
+        if needs_reindex:
+            console.print(
+                f"  Version: [yellow]{index_version}[/yellow] (current: {current_version}) [yellow]⚠️  Reindex recommended[/yellow]"
+            )
+        else:
+            console.print(f"  Version: [green]{index_version}[/green] (up to date)")
+    else:
+        console.print(
+            f"  Version: [yellow]Not tracked[/yellow] (current: {current_version}) [yellow]⚠️  Reindex recommended[/yellow]"
+        )
+
     if index_data["languages"]:
         console.print("  Language Distribution:")
         for lang, count in index_data["languages"].items():
             console.print(f"    {lang}: {count} chunks")
     console.print()
 
+    # Show reindex recommendation if needed
+    if needs_reindex:
+        console.print(
+            "[yellow]💡 Tip: Run 'mcp-vector-search index' to reindex with the latest improvements[/yellow]"
+        )
+        console.print()
+
     # Health check results
     if "health" in status_data:
         health_data = status_data["health"]

mcp_vector_search/cli/didyoumean.py

@@ -266,7 +266,6 @@ COMMON_TYPOS = {
     "context": "mcp",
     "m": "mcp",  # Single letter shortcut
     # Install command variations
-    "setup": "install",
     "deploy": "install",
     "add": "install",
     "instal": "install",  # Common typo
@@ -471,7 +470,7 @@ def add_common_suggestions(ctx: click.Context, command_name: str) -> None:
         console.print("\n[yellow]Did you mean one of these?[/yellow]")
 
         # Show up to 3 best matches
-        for cmd, ratio in fuzzy_matches[:3]:
+        for cmd, _ratio in fuzzy_matches[:3]:
             console.print(format_command_suggestion(cmd, show_examples=False))
 
         # Show example for the best match

mcp_vector_search/cli/history.py

@@ -184,8 +184,9 @@ class SearchHistory:
 
             self._save_favorites(favorites)
 
-        except Exception:
+        except Exception as e:
             # Don't show error for this non-critical operation
+            logger.debug(f"Failed to update history ranking: {e}")
             pass
 
     def _load_history(self) -> list[dict[str, Any]]:
@@ -196,7 +197,8 @@ class SearchHistory:
         try:
             with open(self.history_file, encoding="utf-8") as f:
                 return json.load(f)
-        except Exception:
+        except Exception as e:
+            logger.debug(f"Failed to load history file: {e}")
             return []
 
     def _save_history(self, history: list[dict[str, Any]]) -> None:
@@ -212,7 +214,8 @@ class SearchHistory:
         try:
             with open(self.favorites_file, encoding="utf-8") as f:
                 return json.load(f)
-        except Exception:
+        except Exception as e:
+            logger.debug(f"Failed to load favorites file: {e}")
             return []
 
     def _save_favorites(self, favorites: list[dict[str, Any]]) -> None:

mcp_vector_search/cli/main.py

@@ -74,10 +74,10 @@ unfamiliar codebases, finding similar patterns, and integrating with AI tools.
 )
 
 # Import command functions for direct registration and aliases
-from .commands.index import main as index_main
-from .commands.install import demo as install_demo
-from .commands.install import main as install_main
-from .commands.status import main as status_main
+from .commands.index import main as index_main  # noqa: E402
+from .commands.install import demo as install_demo  # noqa: E402
+from .commands.install import main as install_main  # noqa: E402
+from .commands.status import main as status_main  # noqa: E402
 
 # Note: config doesn't have a main function, it uses subcommands via config_app
 app.command("install", help="🚀 Install mcp-vector-search in projects")(install_main)
@@ -377,8 +377,9 @@ def handle_command_error(ctx, param, value):
                 try:
                     project_root = ctx.obj.get("project_root") if ctx.obj else None
                     get_contextual_suggestions(project_root, command_name)
-                except Exception:
+                except Exception as e:
                     # If contextual suggestions fail, don't break the error flow
+                    logger.debug(f"Failed to get contextual suggestions: {e}")
                     pass
         raise
 
@@ -393,7 +394,8 @@ def help_contextual() -> None:
         )
         console.print("[dim]CLI-first semantic code search with MCP integration[/dim]")
         get_contextual_suggestions(project_root)
-    except Exception:
+    except Exception as e:
+        logger.debug(f"Failed to show contextual help: {e}")
         console.print(
             "\n[dim]Use [bold]mcp-vector-search --help[/bold] for more information.[/dim]"
         )
@@ -457,7 +459,10 @@ def cli_with_suggestions():
                 try:
                     project_root = Path.cwd()
                     get_contextual_suggestions(project_root, command_name)
-                except Exception:
+                except Exception as e:
+                    logger.debug(
+                        f"Failed to get contextual suggestions for error handling: {e}"
+                    )
                     pass
 
                 sys.exit(2)  # Exit with error code

mcp_vector_search/cli/suggestions.py

@@ -73,8 +73,9 @@ class ContextualSuggestionProvider:
             # For now, we'll assume false
             state["has_recent_changes"] = False
 
-        except Exception:
+        except Exception as e:
             # If we can't determine state, provide conservative defaults
+            logger.debug(f"Failed to determine project state for suggestions: {e}")
             pass
 
         return state

mcp_vector_search/config/constants.py

@@ -0,0 +1,24 @@
+"""Project-wide constants for MCP Vector Search.
+
+This module contains all magic numbers and configuration constants
+used throughout the application to improve maintainability and clarity.
+"""
+
+# Timeout Constants (in seconds)
+SUBPROCESS_INSTALL_TIMEOUT = 120  # Timeout for package installation commands
+SUBPROCESS_SHORT_TIMEOUT = 10  # Short timeout for quick commands (version checks, etc.)
+SUBPROCESS_MCP_TIMEOUT = 30  # Timeout for MCP server operations
+SUBPROCESS_TEST_TIMEOUT = 5  # Timeout for server test operations
+CONNECTION_POOL_TIMEOUT = 30.0  # Connection pool acquisition timeout
+
+# Chunking Constants
+DEFAULT_CHUNK_SIZE = 50  # Default number of lines per code chunk
+TEXT_CHUNK_SIZE = 30  # Number of lines per text/markdown chunk
+SEARCH_RESULT_LIMIT = 20  # Default number of search results to return
+
+# Threshold Constants
+DEFAULT_SIMILARITY_THRESHOLD = 0.5  # Default similarity threshold for search (0.0-1.0)
+HIGH_SIMILARITY_THRESHOLD = 0.75  # Higher threshold for more precise matches
+
+# Cache Constants
+DEFAULT_CACHE_SIZE = 256  # Default LRU cache size for file reads

mcp_vector_search/config/defaults.py

@@ -108,6 +108,8 @@ DEFAULT_IGNORE_PATTERNS = [
     ".hg",
     "__pycache__",
     ".pytest_cache",
+    ".mypy_cache",  # mypy type checking cache
+    ".ruff_cache",  # ruff linter cache
     "node_modules",
     ".venv",
     "venv",
@@ -120,6 +122,8 @@ DEFAULT_IGNORE_PATTERNS = [
     "*.egg-info",
     ".DS_Store",
     "Thumbs.db",
+    ".claude-mpm",  # Claude MPM directory
+    ".mcp-vector-search",  # Our own index directory
 ]
 
 # File patterns to ignore

mcp_vector_search/config/settings.py

@@ -37,6 +37,10 @@ class ProjectConfig(BaseSettings):
     max_cache_size: int = Field(
         default=1000, gt=0, description="Maximum number of cached embeddings"
     )
+    auto_reindex_on_upgrade: bool = Field(
+        default=True,
+        description="Automatically reindex when tool version is upgraded (minor/major versions)",
+    )
 
     @field_validator("project_root", "index_path", mode="before")
     @classmethod

mcp_vector_search/core/database.py

@@ -483,7 +483,7 @@ class ChromaVectorDatabase(VectorDatabase):
             return
 
         # Check for HNSW index files that might be corrupted
-        collection_path = self.persist_directory / "chroma-collections.parquet"
+        self.persist_directory / "chroma-collections.parquet"
         index_path = self.persist_directory / "index"
 
         if index_path.exists():

mcp_vector_search/core/factory.py

@@ -60,16 +60,24 @@ class ComponentFactory:
     def create_database(
         config: ProjectConfig,
         embedding_function: CodeBERTEmbeddingFunction,
-        use_pooling: bool = False,
+        use_pooling: bool = True,  # Enable pooling by default for 13.6% performance boost
         **pool_kwargs,
     ) -> VectorDatabase:
         """Create vector database."""
         if use_pooling:
+            # Set default pool parameters if not provided
+            pool_defaults = {
+                "max_connections": 10,
+                "min_connections": 2,
+                "max_idle_time": 300.0,
+            }
+            pool_defaults.update(pool_kwargs)
+
             return PooledChromaVectorDatabase(
                 persist_directory=config.index_path,
                 embedding_function=embedding_function,
                 collection_name="code_search",
-                **pool_kwargs,
+                **pool_defaults,
             )
         else:
             return ChromaVectorDatabase(
@@ -124,7 +132,7 @@ class ComponentFactory:
     @staticmethod
     async def create_standard_components(
         project_root: Path,
-        use_pooling: bool = False,
+        use_pooling: bool = True,  # Enable pooling by default for performance
         include_search_engine: bool = False,
         include_auto_indexer: bool = False,
         similarity_threshold: float = 0.7,

mcp_vector_search/core/indexer.py

@@ -3,10 +3,13 @@
 import asyncio
 import json
 import os
+from datetime import UTC, datetime
 from pathlib import Path
 
 from loguru import logger
+from packaging import version
 
+from .. import __version__
 from ..config.defaults import DEFAULT_IGNORE_PATTERNS
 from ..parsers.registry import get_parser_registry
 from ..utils.gitignore import create_gitignore_parser
@@ -40,9 +43,15 @@ class SemanticIndexer:
         self.file_extensions = {ext.lower() for ext in file_extensions}
         self.parser_registry = get_parser_registry()
         self._ignore_patterns = set(DEFAULT_IGNORE_PATTERNS)
-        self.max_workers = max_workers or min(
-            4, (asyncio.get_event_loop().get_debug() and 1) or 4
-        )
+
+        # Safely get event loop for max_workers
+        try:
+            loop = asyncio.get_event_loop()
+            self.max_workers = max_workers or min(4, (loop.get_debug() and 1) or 4)
+        except RuntimeError:
+            # No event loop in current thread
+            self.max_workers = max_workers or 4
+
         self.batch_size = batch_size
         self._index_metadata_file = (
             project_root / ".mcp-vector-search" / "index_metadata.json"
@@ -182,7 +191,13 @@ class SemanticIndexer:
 
         try:
             with open(self._index_metadata_file) as f:
-                return json.load(f)
+                data = json.load(f)
+                # Handle legacy format (just file_mtimes dict) and new format
+                if "file_mtimes" in data:
+                    return data["file_mtimes"]
+                else:
+                    # Legacy format - just return as-is
+                    return data
         except Exception as e:
             logger.warning(f"Failed to load index metadata: {e}")
             return {}
@@ -197,8 +212,15 @@ class SemanticIndexer:
             # Ensure directory exists
             self._index_metadata_file.parent.mkdir(parents=True, exist_ok=True)
 
+            # New metadata format with version tracking
+            data = {
+                "index_version": __version__,
+                "indexed_at": datetime.now(UTC).isoformat(),
+                "file_mtimes": metadata,
+            }
+
             with open(self._index_metadata_file, "w") as f:
-                json.dump(metadata, f, indent=2)
+                json.dump(data, f, indent=2)
         except Exception as e:
             logger.warning(f"Failed to save index metadata: {e}")
 
@@ -447,6 +469,59 @@ class SemanticIndexer:
         """
         return self._ignore_patterns.copy()
 
+    def get_index_version(self) -> str | None:
+        """Get the version of the tool that created the current index.
+
+        Returns:
+            Version string or None if not available
+        """
+        if not self._index_metadata_file.exists():
+            return None
+
+        try:
+            with open(self._index_metadata_file) as f:
+                data = json.load(f)
+                return data.get("index_version")
+        except Exception as e:
+            logger.warning(f"Failed to read index version: {e}")
+            return None
+
+    def needs_reindex_for_version(self) -> bool:
+        """Check if reindex is needed due to version upgrade.
+
+        Returns:
+            True if reindex is needed for version compatibility
+        """
+        index_version = self.get_index_version()
+
+        if not index_version:
+            # No version recorded - this is either a new index or legacy format
+            # Reindex to establish version tracking
+            return True
+
+        try:
+            current = version.parse(__version__)
+            indexed = version.parse(index_version)
+
+            # Reindex on major or minor version change
+            # Patch versions (0.5.1 -> 0.5.2) don't require reindex
+            needs_reindex = (
+                current.major != indexed.major or current.minor != indexed.minor
+            )
+
+            if needs_reindex:
+                logger.info(
+                    f"Version upgrade detected: {index_version} -> {__version__} "
+                    f"(reindex recommended)"
+                )
+
+            return needs_reindex
+
+        except Exception as e:
+            logger.warning(f"Failed to compare versions: {e}")
+            # If we can't parse versions, be safe and reindex
+            return True
+
     async def get_indexing_stats(self) -> dict:
         """Get statistics about the indexing process.