mcp-vector-search 0.0.3__py3-none-any.whl → 0.4.12__py3-none-any.whl

mcp_vector_search/core/project.py

@@ -2,7 +2,6 @@
 
 import json
 from pathlib import Path
-from typing import List, Optional, Set
 
 from loguru import logger
 
@@ -14,6 +13,7 @@ from ..config.defaults import (
     get_language_from_extension,
 )
 from ..config.settings import ProjectConfig
+from ..utils.gitignore import create_gitignore_parser
 from .exceptions import (
     ConfigurationError,
     ProjectInitializationError,
@@ -25,19 +25,26 @@ from .models import ProjectInfo
 class ProjectManager:
     """Manages project detection, initialization, and configuration."""
 
-    def __init__(self, project_root: Optional[Path] = None) -> None:
+    def __init__(self, project_root: Path | None = None) -> None:
         """Initialize project manager.
-        
+
         Args:
             project_root: Project root directory. If None, will auto-detect.
         """
         self.project_root = project_root or self._detect_project_root()
-        self._config: Optional[ProjectConfig] = None
+        self._config: ProjectConfig | None = None
+
+        # Initialize gitignore parser
+        try:
+            self.gitignore_parser = create_gitignore_parser(self.project_root)
+        except Exception as e:
+            logger.debug(f"Failed to load gitignore patterns: {e}")
+            self.gitignore_parser = None
 
     def _detect_project_root(self) -> Path:
         """Auto-detect project root directory."""
         current = Path.cwd()
-        
+
         # Look for common project indicators
         indicators = [
             ".git",
@@ -50,14 +57,14 @@ class ProjectManager:
             "build.gradle",
             ".project",
         ]
-        
+
         # Walk up the directory tree
         for path in [current] + list(current.parents):
             for indicator in indicators:
                 if (path / indicator).exists():
                     logger.debug(f"Detected project root: {path} (found {indicator})")
                     return path
-        
+
         # Default to current directory
         logger.debug(f"Using current directory as project root: {current}")
         return current
@@ -66,27 +73,27 @@ class ProjectManager:
         """Check if project is initialized for MCP Vector Search."""
         config_path = get_default_config_path(self.project_root)
         index_path = get_default_index_path(self.project_root)
-        
+
         return config_path.exists() and index_path.exists()
 
     def initialize(
         self,
-        file_extensions: Optional[List[str]] = None,
+        file_extensions: list[str] | None = None,
         embedding_model: str = "microsoft/codebert-base",
-        similarity_threshold: float = 0.75,
+        similarity_threshold: float = 0.5,
         force: bool = False,
     ) -> ProjectConfig:
         """Initialize project for MCP Vector Search.
-        
+
         Args:
             file_extensions: File extensions to index
             embedding_model: Embedding model to use
             similarity_threshold: Similarity threshold for search
             force: Force re-initialization if already exists
-            
+
         Returns:
             Project configuration
-            
+
         Raises:
             ProjectInitializationError: If initialization fails
         """
@@ -99,11 +106,13 @@ class ProjectManager:
             # Create index directory
             index_path = get_default_index_path(self.project_root)
             index_path.mkdir(parents=True, exist_ok=True)
-            
+
             # Detect languages and files
             detected_languages = self.detect_languages()
-            file_count = self.count_indexable_files(file_extensions or DEFAULT_FILE_EXTENSIONS)
-            
+            file_count = self.count_indexable_files(
+                file_extensions or DEFAULT_FILE_EXTENSIONS
+            )
+
             # Create configuration
             config = ProjectConfig(
                 project_root=self.project_root,
@@ -113,29 +122,31 @@ class ProjectManager:
                 similarity_threshold=similarity_threshold,
                 languages=detected_languages,
             )
-            
+
             # Save configuration
             self.save_config(config)
-            
+
             logger.info(
                 f"Initialized project at {self.project_root}",
                 languages=detected_languages,
                 file_count=file_count,
                 extensions=config.file_extensions,
             )
-            
+
             self._config = config
             return config
-            
+
         except Exception as e:
-            raise ProjectInitializationError(f"Failed to initialize project: {e}") from e
+            raise ProjectInitializationError(
+                f"Failed to initialize project: {e}"
+            ) from e
 
     def load_config(self) -> ProjectConfig:
         """Load project configuration.
-        
+
         Returns:
             Project configuration
-            
+
         Raises:
             ProjectNotFoundError: If project is not initialized
             ConfigurationError: If configuration is invalid
@@ -146,45 +157,45 @@ class ProjectManager:
             )
 
         config_path = get_default_config_path(self.project_root)
-        
+
         try:
-            with open(config_path, "r") as f:
+            with open(config_path) as f:
                 config_data = json.load(f)
-            
+
             # Convert paths back to Path objects
             config_data["project_root"] = Path(config_data["project_root"])
             config_data["index_path"] = Path(config_data["index_path"])
-            
+
             config = ProjectConfig(**config_data)
             self._config = config
             return config
-            
+
         except Exception as e:
             raise ConfigurationError(f"Failed to load configuration: {e}") from e
 
     def save_config(self, config: ProjectConfig) -> None:
         """Save project configuration.
-        
+
         Args:
             config: Project configuration to save
-            
+
         Raises:
             ConfigurationError: If saving fails
         """
         config_path = get_default_config_path(self.project_root)
         config_path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         try:
             # Convert to JSON-serializable format
-            config_data = config.dict()
+            config_data = config.model_dump()
             config_data["project_root"] = str(config.project_root)
             config_data["index_path"] = str(config.index_path)
-            
+
             with open(config_path, "w") as f:
                 json.dump(config_data, f, indent=2)
-                
+
             logger.debug(f"Saved configuration to {config_path}")
-            
+
         except Exception as e:
             raise ConfigurationError(f"Failed to save configuration: {e}") from e
 
@@ -195,27 +206,27 @@ class ProjectManager:
             self._config = self.load_config()
         return self._config
 
-    def detect_languages(self) -> List[str]:
+    def detect_languages(self) -> list[str]:
         """Detect programming languages in the project.
-        
+
         Returns:
             List of detected language names
         """
-        languages: Set[str] = set()
-        
+        languages: set[str] = set()
+
         for file_path in self._iter_source_files():
             language = get_language_from_extension(file_path.suffix)
             if language != "text":
                 languages.add(language)
-        
-        return sorted(list(languages))
 
-    def count_indexable_files(self, extensions: List[str]) -> int:
+        return sorted(languages)
+
+    def count_indexable_files(self, extensions: list[str]) -> int:
         """Count files that can be indexed.
-        
+
         Args:
             extensions: File extensions to count
-            
+
         Returns:
             Number of indexable files
         """
@@ -227,17 +238,17 @@ class ProjectManager:
 
     def get_project_info(self) -> ProjectInfo:
         """Get comprehensive project information.
-        
+
         Returns:
             Project information
         """
         config_path = get_default_config_path(self.project_root)
         index_path = get_default_index_path(self.project_root)
-        
+
         is_initialized = self.is_initialized()
         languages = []
         file_count = 0
-        
+
         if is_initialized:
             try:
                 config = self.config
@@ -246,7 +257,7 @@ class ProjectManager:
             except Exception:
                 # Ignore errors when getting detailed info
                 pass
-        
+
         return ProjectInfo(
             name=self.project_root.name,
             root_path=self.project_root,
@@ -257,40 +268,44 @@ class ProjectManager:
             file_count=file_count,
         )
 
-    def _iter_source_files(self) -> List[Path]:
+    def _iter_source_files(self) -> list[Path]:
         """Iterate over source files in the project.
-        
+
         Returns:
             List of source file paths
         """
         files = []
-        
+
         for path in self.project_root.rglob("*"):
             if not path.is_file():
                 continue
-                
+
             # Skip ignored patterns
             if self._should_ignore_path(path):
                 continue
-                
+
             files.append(path)
-        
+
         return files
 
     def _should_ignore_path(self, path: Path) -> bool:
         """Check if a path should be ignored.
-        
+
         Args:
             path: Path to check
-            
+
         Returns:
             True if path should be ignored
         """
+        # First check gitignore rules if available
+        if self.gitignore_parser and self.gitignore_parser.is_ignored(path):
+            return True
+
         # Check if any parent directory is in ignore patterns
         for part in path.parts:
             if part in DEFAULT_IGNORE_PATTERNS:
                 return True
-        
+
         # Check relative path from project root
         try:
             relative_path = path.relative_to(self.project_root)
@@ -300,5 +315,5 @@ class ProjectManager:
         except ValueError:
             # Path is not relative to project root
             return True
-        
+
         return False

mcp_vector_search/core/scheduler.py

@@ -0,0 +1,330 @@
+"""Scheduling utilities for automatic reindexing."""
+
+import platform
+import subprocess
+import sys
+from pathlib import Path
+
+from loguru import logger
+
+
+class SchedulerManager:
+    """Manages scheduled tasks for automatic reindexing."""
+
+    def __init__(self, project_root: Path):
+        """Initialize scheduler manager.
+
+        Args:
+            project_root: Project root directory
+        """
+        self.project_root = project_root
+        self.system = platform.system().lower()
+
+    def install_scheduled_task(
+        self, interval_minutes: int = 60, task_name: str | None = None
+    ) -> bool:
+        """Install a scheduled task for automatic reindexing.
+
+        Args:
+            interval_minutes: Interval between reindex checks in minutes
+            task_name: Custom task name (auto-generated if None)
+
+        Returns:
+            True if task was installed successfully
+        """
+        if task_name is None:
+            safe_path = str(self.project_root).replace("/", "_").replace("\\", "_")
+            task_name = f"mcp_vector_search_reindex_{safe_path}"
+
+        if self.system == "linux" or self.system == "darwin":
+            return self._install_cron_job(interval_minutes, task_name)
+        elif self.system == "windows":
+            return self._install_windows_task(interval_minutes, task_name)
+        else:
+            logger.error(f"Unsupported system: {self.system}")
+            return False
+
+    def uninstall_scheduled_task(self, task_name: str | None = None) -> bool:
+        """Uninstall scheduled task.
+
+        Args:
+            task_name: Task name to uninstall (auto-generated if None)
+
+        Returns:
+            True if task was uninstalled successfully
+        """
+        if task_name is None:
+            safe_path = str(self.project_root).replace("/", "_").replace("\\", "_")
+            task_name = f"mcp_vector_search_reindex_{safe_path}"
+
+        if self.system == "linux" or self.system == "darwin":
+            return self._uninstall_cron_job(task_name)
+        elif self.system == "windows":
+            return self._uninstall_windows_task(task_name)
+        else:
+            logger.error(f"Unsupported system: {self.system}")
+            return False
+
+    def _install_cron_job(self, interval_minutes: int, task_name: str) -> bool:
+        """Install cron job on Linux/macOS."""
+        try:
+            # Generate cron command
+            python_path = sys.executable
+            project_root = str(self.project_root)
+
+            # Create wrapper script
+            script_content = f'''#!/bin/bash
+# MCP Vector Search Auto-Reindex - {task_name}
+cd "{project_root}" || exit 1
+
+# Check if mcp-vector-search is available
+if command -v mcp-vector-search &> /dev/null; then
+    mcp-vector-search auto-index check --auto-reindex --max-files 10
+elif [ -f "{python_path}" ]; then
+    "{python_path}" -m mcp_vector_search auto-index check --auto-reindex --max-files 10
+else
+    python3 -m mcp_vector_search auto-index check --auto-reindex --max-files 10
+fi
+'''
+
+            # Write script to temp file
+            script_dir = Path.home() / ".mcp-vector-search" / "scripts"
+            script_dir.mkdir(parents=True, exist_ok=True)
+            script_file = script_dir / f"{task_name}.sh"
+
+            script_file.write_text(script_content)
+            script_file.chmod(0o755)
+
+            # Calculate cron schedule
+            if interval_minutes >= 60:
+                # Hourly or less frequent
+                hours = interval_minutes // 60
+                cron_schedule = f"0 */{hours} * * *"
+            else:
+                # More frequent than hourly
+                cron_schedule = f"*/{interval_minutes} * * * *"
+
+            # Add to crontab
+            cron_entry = f"{cron_schedule} {script_file} # {task_name}\n"
+
+            # Get current crontab
+            try:
+                result = subprocess.run(
+                    ["crontab", "-l"], capture_output=True, text=True, check=True
+                )
+                current_crontab = result.stdout
+            except subprocess.CalledProcessError:
+                current_crontab = ""
+
+            # Check if entry already exists
+            if task_name in current_crontab:
+                logger.info(f"Cron job {task_name} already exists")
+                return True
+
+            # Add new entry
+            new_crontab = current_crontab + cron_entry
+
+            # Install new crontab
+            process = subprocess.Popen(
+                ["crontab", "-"], stdin=subprocess.PIPE, text=True
+            )
+            process.communicate(input=new_crontab)
+
+            if process.returncode == 0:
+                logger.info(f"Installed cron job: {task_name}")
+                logger.info(f"Schedule: every {interval_minutes} minutes")
+                logger.info(f"Script: {script_file}")
+                return True
+            else:
+                logger.error("Failed to install cron job")
+                return False
+
+        except Exception as e:
+            logger.error(f"Failed to install cron job: {e}")
+            return False
+
+    def _uninstall_cron_job(self, task_name: str) -> bool:
+        """Uninstall cron job on Linux/macOS."""
+        try:
+            # Get current crontab
+            try:
+                result = subprocess.run(
+                    ["crontab", "-l"], capture_output=True, text=True, check=True
+                )
+                current_crontab = result.stdout
+            except subprocess.CalledProcessError:
+                logger.info("No crontab found")
+                return True
+
+            # Remove lines containing task name
+            lines = current_crontab.split("\n")
+            new_lines = [line for line in lines if task_name not in line]
+            new_crontab = "\n".join(new_lines)
+
+            # Install new crontab
+            if new_crontab.strip():
+                process = subprocess.Popen(
+                    ["crontab", "-"], stdin=subprocess.PIPE, text=True
+                )
+                process.communicate(input=new_crontab)
+            else:
+                # Remove crontab entirely if empty
+                subprocess.run(["crontab", "-r"], check=False)
+
+            # Remove script file
+            script_dir = Path.home() / ".mcp-vector-search" / "scripts"
+            script_file = script_dir / f"{task_name}.sh"
+            if script_file.exists():
+                script_file.unlink()
+
+            logger.info(f"Uninstalled cron job: {task_name}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to uninstall cron job: {e}")
+            return False
+
+    def _install_windows_task(self, interval_minutes: int, task_name: str) -> bool:
+        """Install Windows scheduled task."""
+        try:
+            python_path = sys.executable
+            project_root = str(self.project_root)
+
+            # Create PowerShell script
+            script_content = f'''# MCP Vector Search Auto-Reindex - {task_name}
+Set-Location "{project_root}"
+
+try {{
+    if (Get-Command "mcp-vector-search" -ErrorAction SilentlyContinue) {{
+        mcp-vector-search auto-index check --auto-reindex --max-files 10
+    }} elseif (Test-Path "{python_path}") {{
+        & "{python_path}" -m mcp_vector_search auto-index check --auto-reindex --max-files 10
+    }} else {{
+        python -m mcp_vector_search auto-index check --auto-reindex --max-files 10
+    }}
+}} catch {{
+    # Silently ignore errors
+}}
+'''
+
+            # Write script
+            script_dir = Path.home() / ".mcp-vector-search" / "scripts"
+            script_dir.mkdir(parents=True, exist_ok=True)
+            script_file = script_dir / f"{task_name}.ps1"
+
+            script_file.write_text(script_content)
+
+            # Create scheduled task using schtasks
+            cmd = [
+                "schtasks",
+                "/create",
+                "/tn",
+                task_name,
+                "/tr",
+                f'powershell.exe -ExecutionPolicy Bypass -File "{script_file}"',
+                "/sc",
+                "minute",
+                "/mo",
+                str(interval_minutes),
+                "/f",  # Force overwrite if exists
+            ]
+
+            result = subprocess.run(cmd, capture_output=True, text=True)
+
+            if result.returncode == 0:
+                logger.info(f"Installed Windows task: {task_name}")
+                logger.info(f"Schedule: every {interval_minutes} minutes")
+                return True
+            else:
+                logger.error(f"Failed to install Windows task: {result.stderr}")
+                return False
+
+        except Exception as e:
+            logger.error(f"Failed to install Windows task: {e}")
+            return False
+
+    def _uninstall_windows_task(self, task_name: str) -> bool:
+        """Uninstall Windows scheduled task."""
+        try:
+            # Delete scheduled task
+            cmd = ["schtasks", "/delete", "/tn", task_name, "/f"]
+            result = subprocess.run(cmd, capture_output=True, text=True)
+
+            # Remove script file
+            script_dir = Path.home() / ".mcp-vector-search" / "scripts"
+            script_file = script_dir / f"{task_name}.ps1"
+            if script_file.exists():
+                script_file.unlink()
+
+            if result.returncode == 0:
+                logger.info(f"Uninstalled Windows task: {task_name}")
+                return True
+            else:
+                # Task might not exist, which is fine
+                logger.info(
+                    f"Windows task {task_name} was not found (already uninstalled)"
+                )
+                return True
+
+        except Exception as e:
+            logger.error(f"Failed to uninstall Windows task: {e}")
+            return False
+
+    def get_scheduled_task_status(self, task_name: str | None = None) -> dict:
+        """Get status of scheduled tasks.
+
+        Args:
+            task_name: Task name to check (auto-generated if None)
+
+        Returns:
+            Dictionary with task status information
+        """
+        if task_name is None:
+            safe_path = str(self.project_root).replace("/", "_").replace("\\", "_")
+            task_name = f"mcp_vector_search_reindex_{safe_path}"
+
+        status = {
+            "system": self.system,
+            "task_name": task_name,
+            "exists": False,
+            "enabled": False,
+            "last_run": None,
+            "next_run": None,
+        }
+
+        if self.system == "linux" or self.system == "darwin":
+            status.update(self._get_cron_status(task_name))
+        elif self.system == "windows":
+            status.update(self._get_windows_task_status(task_name))
+
+        return status
+
+    def _get_cron_status(self, task_name: str) -> dict:
+        """Get cron job status."""
+        try:
+            result = subprocess.run(
+                ["crontab", "-l"], capture_output=True, text=True, check=True
+            )
+
+            exists = task_name in result.stdout
+            return {"exists": exists, "enabled": exists}
+
+        except subprocess.CalledProcessError:
+            return {"exists": False, "enabled": False}
+
+    def _get_windows_task_status(self, task_name: str) -> dict:
+        """Get Windows task status."""
+        try:
+            result = subprocess.run(
+                ["schtasks", "/query", "/tn", task_name], capture_output=True, text=True
+            )
+
+            if result.returncode == 0:
+                # Parse output for status
+                enabled = "Ready" in result.stdout or "Running" in result.stdout
+                return {"exists": True, "enabled": enabled}
+            else:
+                return {"exists": False, "enabled": False}
+
+        except Exception:
+            return {"exists": False, "enabled": False}