mcp-vector-search 0.15.7__py3-none-any.whl

mcp_vector_search/core/factory.py

@@ -0,0 +1,318 @@
+"""Component factory for creating commonly used objects."""
+
+import functools
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, TypeVar
+
+import typer
+from loguru import logger
+
+from ..cli.output import print_error
+from ..config.settings import ProjectConfig
+from .auto_indexer import AutoIndexer
+from .database import ChromaVectorDatabase, PooledChromaVectorDatabase, VectorDatabase
+from .embeddings import CodeBERTEmbeddingFunction, create_embedding_function
+from .indexer import SemanticIndexer
+from .project import ProjectManager
+from .search import SemanticSearchEngine
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+@dataclass
+class ComponentBundle:
+    """Bundle of commonly used components."""
+
+    project_manager: ProjectManager
+    config: ProjectConfig
+    database: VectorDatabase
+    indexer: SemanticIndexer
+    embedding_function: CodeBERTEmbeddingFunction
+    search_engine: SemanticSearchEngine | None = None
+    auto_indexer: AutoIndexer | None = None
+
+
+class ComponentFactory:
+    """Factory for creating commonly used components."""
+
+    @staticmethod
+    def create_project_manager(project_root: Path) -> ProjectManager:
+        """Create a project manager."""
+        return ProjectManager(project_root)
+
+    @staticmethod
+    def load_config(project_root: Path) -> tuple[ProjectManager, ProjectConfig]:
+        """Load project configuration."""
+        project_manager = ComponentFactory.create_project_manager(project_root)
+        config = project_manager.load_config()
+        return project_manager, config
+
+    @staticmethod
+    def create_embedding_function(
+        model_name: str,
+    ) -> tuple[CodeBERTEmbeddingFunction, Any]:
+        """Create embedding function."""
+        return create_embedding_function(model_name)
+
+    @staticmethod
+    def create_database(
+        config: ProjectConfig,
+        embedding_function: CodeBERTEmbeddingFunction,
+        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_defaults,
+            )
+        else:
+            return ChromaVectorDatabase(
+                persist_directory=config.index_path,
+                embedding_function=embedding_function,
+                collection_name="code_search",
+            )
+
+    @staticmethod
+    def create_indexer(
+        database: VectorDatabase, project_root: Path, config: ProjectConfig
+    ) -> SemanticIndexer:
+        """Create semantic indexer."""
+        return SemanticIndexer(
+            database=database,
+            project_root=project_root,
+            config=config,
+        )
+
+    @staticmethod
+    def create_search_engine(
+        database: VectorDatabase,
+        project_root: Path,
+        similarity_threshold: float = 0.7,
+        auto_indexer: AutoIndexer | None = None,
+        enable_auto_reindex: bool = True,
+    ) -> SemanticSearchEngine:
+        """Create semantic search engine."""
+        return SemanticSearchEngine(
+            database=database,
+            project_root=project_root,
+            similarity_threshold=similarity_threshold,
+            auto_indexer=auto_indexer,
+            enable_auto_reindex=enable_auto_reindex,
+        )
+
+    @staticmethod
+    def create_auto_indexer(
+        indexer: SemanticIndexer,
+        database: VectorDatabase,
+        auto_reindex_threshold: int = 5,
+        staleness_threshold: float = 300.0,
+    ) -> AutoIndexer:
+        """Create auto-indexer."""
+        return AutoIndexer(
+            indexer=indexer,
+            database=database,
+            auto_reindex_threshold=auto_reindex_threshold,
+            staleness_threshold=staleness_threshold,
+        )
+
+    @staticmethod
+    async def create_standard_components(
+        project_root: Path,
+        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,
+        auto_reindex_threshold: int = 5,
+        **pool_kwargs,
+    ) -> ComponentBundle:
+        """Create standard set of components for CLI commands.
+
+        Args:
+            project_root: Project root directory
+            use_pooling: Whether to use connection pooling
+            include_search_engine: Whether to create search engine
+            include_auto_indexer: Whether to create auto-indexer
+            similarity_threshold: Default similarity threshold for search
+            auto_reindex_threshold: Max files to auto-reindex
+            **pool_kwargs: Additional arguments for connection pool
+
+        Returns:
+            ComponentBundle with requested components
+        """
+        # Load configuration
+        project_manager, config = ComponentFactory.load_config(project_root)
+
+        # Create embedding function
+        embedding_function, _ = ComponentFactory.create_embedding_function(
+            config.embedding_model
+        )
+
+        # Create database
+        database = ComponentFactory.create_database(
+            config=config,
+            embedding_function=embedding_function,
+            use_pooling=use_pooling,
+            **pool_kwargs,
+        )
+
+        # Create indexer
+        indexer = ComponentFactory.create_indexer(
+            database=database,
+            project_root=project_root,
+            config=config,
+        )
+
+        # Create optional components
+        search_engine = None
+        auto_indexer = None
+
+        if include_auto_indexer:
+            auto_indexer = ComponentFactory.create_auto_indexer(
+                indexer=indexer,
+                database=database,
+                auto_reindex_threshold=auto_reindex_threshold,
+            )
+
+        if include_search_engine:
+            search_engine = ComponentFactory.create_search_engine(
+                database=database,
+                project_root=project_root,
+                similarity_threshold=similarity_threshold,
+                auto_indexer=auto_indexer,
+                enable_auto_reindex=include_auto_indexer,
+            )
+
+        return ComponentBundle(
+            project_manager=project_manager,
+            config=config,
+            database=database,
+            indexer=indexer,
+            embedding_function=embedding_function,
+            search_engine=search_engine,
+            auto_indexer=auto_indexer,
+        )
+
+
+class DatabaseContext:
+    """Context manager for database lifecycle management."""
+
+    def __init__(self, database: VectorDatabase):
+        """Initialize database context.
+
+        Args:
+            database: Vector database instance
+        """
+        self.database = database
+
+    async def __aenter__(self) -> VectorDatabase:
+        """Enter context and initialize database."""
+        await self.database.initialize()
+        return self.database
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit context and close database."""
+        await self.database.close()
+
+
+def handle_cli_errors(operation_name: str) -> Callable[[F], F]:
+    """Decorator for consistent CLI error handling.
+
+    Args:
+        operation_name: Name of the operation for error messages
+
+    Returns:
+        Decorator function
+    """
+
+    def decorator(func: F) -> F:
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                logger.error(f"{operation_name} failed: {e}")
+                print_error(f"{operation_name} failed: {e}")
+                raise typer.Exit(1)
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                logger.error(f"{operation_name} failed: {e}")
+                print_error(f"{operation_name} failed: {e}")
+                raise typer.Exit(1)
+
+        # Return appropriate wrapper based on function type
+        if hasattr(func, "__code__") and "await" in func.__code__.co_names:
+            return async_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator
+
+
+class ConfigurationService:
+    """Centralized configuration management service."""
+
+    def __init__(self, project_root: Path):
+        """Initialize configuration service.
+
+        Args:
+            project_root: Project root directory
+        """
+        self.project_root = project_root
+        self._project_manager: ProjectManager | None = None
+        self._config: ProjectConfig | None = None
+
+    @property
+    def project_manager(self) -> ProjectManager:
+        """Get project manager (lazy loaded)."""
+        if self._project_manager is None:
+            self._project_manager = ProjectManager(self.project_root)
+        return self._project_manager
+
+    @property
+    def config(self) -> ProjectConfig:
+        """Get project configuration (lazy loaded)."""
+        if self._config is None:
+            self._config = self.project_manager.load_config()
+        return self._config
+
+    def ensure_initialized(self) -> bool:
+        """Ensure project is initialized.
+
+        Returns:
+            True if project is initialized, False otherwise
+        """
+        if not self.project_manager.is_initialized():
+            print_error("Project not initialized. Run 'mcp-vector-search init' first.")
+            return False
+        return True
+
+    def reload_config(self) -> None:
+        """Reload configuration from disk."""
+        self._config = None
+
+    def save_config(self, config: ProjectConfig) -> None:
+        """Save configuration to disk.
+
+        Args:
+            config: Configuration to save
+        """
+        self.project_manager.save_config(config)
+        self._config = config

mcp_vector_search/core/git_hooks.py

@@ -0,0 +1,345 @@
+"""Git hooks for automatic reindexing."""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from loguru import logger
+
+
+class GitHookManager:
+    """Manages Git hooks for automatic reindexing."""
+
+    def __init__(self, project_root: Path):
+        """Initialize Git hook manager.
+
+        Args:
+            project_root: Project root directory
+        """
+        self.project_root = project_root
+        self.git_dir = project_root / ".git"
+        self.hooks_dir = self.git_dir / "hooks"
+
+    def is_git_repo(self) -> bool:
+        """Check if project is a Git repository."""
+        return self.git_dir.exists() and self.git_dir.is_dir()
+
+    def install_hooks(self, hook_types: list[str] | None = None) -> bool:
+        """Install Git hooks for automatic reindexing.
+
+        Args:
+            hook_types: List of hook types to install (default: ['post-commit', 'post-merge'])
+
+        Returns:
+            True if hooks were installed successfully
+        """
+        if not self.is_git_repo():
+            logger.error("Not a Git repository")
+            return False
+
+        if hook_types is None:
+            hook_types = ["post-commit", "post-merge", "post-checkout"]
+
+        success = True
+        for hook_type in hook_types:
+            if not self._install_hook(hook_type):
+                success = False
+
+        return success
+
+    def uninstall_hooks(self, hook_types: list[str] | None = None) -> bool:
+        """Uninstall Git hooks.
+
+        Args:
+            hook_types: List of hook types to uninstall (default: all MCP hooks)
+
+        Returns:
+            True if hooks were uninstalled successfully
+        """
+        if hook_types is None:
+            hook_types = ["post-commit", "post-merge", "post-checkout"]
+
+        success = True
+        for hook_type in hook_types:
+            if not self._uninstall_hook(hook_type):
+                success = False
+
+        return success
+
+    def _install_hook(self, hook_type: str) -> bool:
+        """Install a specific Git hook."""
+        try:
+            hook_file = self.hooks_dir / hook_type
+
+            # Create hooks directory if it doesn't exist
+            self.hooks_dir.mkdir(exist_ok=True)
+
+            # Generate hook script
+            hook_script = self._generate_hook_script(hook_type)
+
+            if hook_file.exists():
+                # If hook already exists, try to integrate with it
+                return self._integrate_with_existing_hook(hook_file, hook_script)
+            else:
+                # Create new hook
+                hook_file.write_text(hook_script)
+                hook_file.chmod(0o755)  # Make executable
+                logger.info(f"Installed {hook_type} hook")
+                return True
+
+        except Exception as e:
+            logger.error(f"Failed to install {hook_type} hook: {e}")
+            return False
+
+    def _uninstall_hook(self, hook_type: str) -> bool:
+        """Uninstall a specific Git hook."""
+        try:
+            hook_file = self.hooks_dir / hook_type
+
+            if not hook_file.exists():
+                return True  # Already uninstalled
+
+            content = hook_file.read_text()
+
+            # Check if this is our hook or integrated
+            if "# MCP Vector Search Hook" in content:
+                if (
+                    content.strip().startswith("#!/bin/bash")
+                    and "# MCP Vector Search Hook" in content
+                ):
+                    # This is our hook, remove it
+                    hook_file.unlink()
+                    logger.info(f"Uninstalled {hook_type} hook")
+                else:
+                    # This is integrated, remove our part
+                    return self._remove_from_existing_hook(hook_file)
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to uninstall {hook_type} hook: {e}")
+            return False
+
+    def _generate_hook_script(self, hook_type: str) -> str:
+        """Generate Git hook script."""
+        python_path = sys.executable
+        project_root = str(self.project_root)
+
+        script = f"""#!/bin/bash
+# MCP Vector Search Hook - {hook_type}
+# Auto-generated - do not edit manually
+
+# Check if mcp-vector-search is available
+if ! command -v mcp-vector-search &> /dev/null; then
+    # Try using Python directly
+    if [ -f "{python_path}" ]; then
+        PYTHON_CMD="{python_path}"
+    else
+        PYTHON_CMD="python3"
+    fi
+
+    # Try to run via Python module
+    if $PYTHON_CMD -m mcp_vector_search --help &> /dev/null; then
+        MCP_CMD="$PYTHON_CMD -m mcp_vector_search"
+    else
+        # Silently exit if not available
+        exit 0
+    fi
+else
+    MCP_CMD="mcp-vector-search"
+fi
+
+# Change to project directory
+cd "{project_root}" || exit 0
+
+# Run auto-indexing check
+$MCP_CMD auto-index check --auto-reindex --max-files 10 &> /dev/null || true
+
+# Exit successfully (don't block Git operations)
+exit 0
+"""
+        return script
+
+    def _integrate_with_existing_hook(self, hook_file: Path, our_script: str) -> bool:
+        """Integrate our hook with an existing hook."""
+        try:
+            existing_content = hook_file.read_text()
+
+            # Check if our hook is already integrated
+            if "# MCP Vector Search Hook" in existing_content:
+                logger.info(f"Hook {hook_file.name} already integrated")
+                return True
+
+            # Add our hook to the end
+            integrated_content = existing_content.rstrip() + "\n\n" + our_script
+
+            # Backup original
+            backup_file = hook_file.with_suffix(hook_file.suffix + ".backup")
+            backup_file.write_text(existing_content)
+
+            # Write integrated version
+            hook_file.write_text(integrated_content)
+
+            logger.info(f"Integrated with existing {hook_file.name} hook")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to integrate with existing hook: {e}")
+            return False
+
+    def _remove_from_existing_hook(self, hook_file: Path) -> bool:
+        """Remove our hook from an existing integrated hook."""
+        try:
+            content = hook_file.read_text()
+
+            # Find and remove our section
+            lines = content.split("\n")
+            new_lines = []
+            skip_section = False
+
+            for line in lines:
+                if "# MCP Vector Search Hook" in line:
+                    skip_section = True
+                    continue
+                elif skip_section and line.strip() == "":
+                    # End of our section
+                    skip_section = False
+                    continue
+                elif not skip_section:
+                    new_lines.append(line)
+
+            # Write back the cleaned content
+            hook_file.write_text("\n".join(new_lines))
+
+            logger.info(f"Removed MCP hook from {hook_file.name}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to remove from existing hook: {e}")
+            return False
+
+    def get_hook_status(self) -> dict:
+        """Get status of Git hooks."""
+        if not self.is_git_repo():
+            return {"is_git_repo": False}
+
+        hook_types = ["post-commit", "post-merge", "post-checkout"]
+        status = {
+            "is_git_repo": True,
+            "hooks_dir_exists": self.hooks_dir.exists(),
+            "hooks": {},
+        }
+
+        for hook_type in hook_types:
+            hook_file = self.hooks_dir / hook_type
+            hook_status = {
+                "exists": hook_file.exists(),
+                "executable": False,
+                "has_mcp_hook": False,
+                "is_mcp_only": False,
+            }
+
+            if hook_file.exists():
+                try:
+                    hook_status["executable"] = os.access(hook_file, os.X_OK)
+                    content = hook_file.read_text()
+                    hook_status["has_mcp_hook"] = "# MCP Vector Search Hook" in content
+                    hook_status["is_mcp_only"] = (
+                        hook_status["has_mcp_hook"]
+                        and content.strip().startswith("#!/bin/bash")
+                        and content.count("# MCP Vector Search Hook") == 1
+                    )
+                except Exception:
+                    pass
+
+            status["hooks"][hook_type] = hook_status
+
+        return status
+
+
+class GitChangeDetector:
+    """Detects changed files from Git operations."""
+
+    @staticmethod
+    def get_changed_files_since_commit(
+        commit_hash: str, project_root: Path
+    ) -> set[Path]:
+        """Get files changed since a specific commit.
+
+        Args:
+            commit_hash: Git commit hash
+            project_root: Project root directory
+
+        Returns:
+            Set of changed file paths
+        """
+        try:
+            result = subprocess.run(  # nosec B607
+                ["git", "diff", "--name-only", commit_hash, "HEAD"],
+                cwd=project_root,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            changed_files = set()
+            for line in result.stdout.strip().split("\n"):
+                if line:
+                    file_path = project_root / line
+                    if file_path.exists():
+                        changed_files.add(file_path)
+
+            return changed_files
+
+        except subprocess.CalledProcessError:
+            return set()
+
+    @staticmethod
+    def get_changed_files_in_last_commit(project_root: Path) -> set[Path]:
+        """Get files changed in the last commit.
+
+        Args:
+            project_root: Project root directory
+
+        Returns:
+            Set of changed file paths
+        """
+        try:
+            result = subprocess.run(  # nosec B607
+                ["git", "diff", "--name-only", "HEAD~1", "HEAD"],
+                cwd=project_root,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            changed_files = set()
+            for line in result.stdout.strip().split("\n"):
+                if line:
+                    file_path = project_root / line
+                    if file_path.exists():
+                        changed_files.add(file_path)
+
+            return changed_files
+
+        except subprocess.CalledProcessError:
+            return set()
+
+    @staticmethod
+    def should_trigger_reindex(
+        changed_files: set[Path], file_extensions: list[str]
+    ) -> bool:
+        """Check if changed files should trigger reindexing.
+
+        Args:
+            changed_files: Set of changed file paths
+            file_extensions: List of file extensions to monitor
+
+        Returns:
+            True if reindexing should be triggered
+        """
+        for file_path in changed_files:
+            if file_path.suffix in file_extensions:
+                return True
+        return False