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

mcp_vector_search/cli/commands/status.py

@@ -0,0 +1,340 @@
+"""Status command for MCP Vector Search CLI."""
+
+import asyncio
+from pathlib import Path
+from typing import Dict, Any
+
+import typer
+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 ..output import (
+    console,
+    print_config,
+    print_dependency_status,
+    print_error,
+    print_index_stats,
+    print_info,
+    print_json,
+    print_project_info,
+)
+
+# Create status subcommand app
+status_app = typer.Typer(help="Show project status and statistics")
+
+
+@status_app.command()
+def main(
+    ctx: typer.Context,
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Show detailed information",
+    ),
+    health_check: bool = typer.Option(
+        False,
+        "--health-check",
+        help="Perform health check of all components",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Output status in JSON format",
+    ),
+) -> None:
+    """Show project status and indexing statistics.
+    
+    This command displays comprehensive information about your MCP Vector Search
+    project including configuration, indexing status, and system health.
+    
+    Examples:
+        mcp-vector-search status
+        mcp-vector-search status --verbose
+        mcp-vector-search status --health-check --json
+    """
+    try:
+        project_root = ctx.obj.get("project_root") or Path.cwd()
+        
+        asyncio.run(show_status(
+            project_root=project_root,
+            verbose=verbose,
+            health_check=health_check,
+            json_output=json_output,
+        ))
+        
+    except Exception as e:
+        logger.error(f"Status check failed: {e}")
+        print_error(f"Status check failed: {e}")
+        raise typer.Exit(1)
+
+
+async def show_status(
+    project_root: Path,
+    verbose: bool = False,
+    health_check: bool = False,
+    json_output: bool = False,
+) -> None:
+    """Show comprehensive project status."""
+    status_data = {}
+    
+    try:
+        # Check if project is initialized
+        project_manager = ProjectManager(project_root)
+        
+        if not project_manager.is_initialized():
+            if json_output:
+                status_data = {
+                    "initialized": False,
+                    "project_root": str(project_root),
+                    "error": "Project not initialized"
+                }
+                print_json(status_data)
+            else:
+                print_error(f"Project not initialized at {project_root}")
+                print_info("Run 'mcp-vector-search init' to initialize the project")
+            return
+        
+        # Get project information
+        project_info = project_manager.get_project_info()
+        config = project_manager.load_config()
+        
+        # Get indexing statistics
+        embedding_function, _ = create_embedding_function(config.embedding_model)
+        database = ChromaVectorDatabase(
+            persist_directory=config.index_path,
+            embedding_function=embedding_function,
+        )
+        
+        indexer = SemanticIndexer(
+            database=database,
+            project_root=project_root,
+            file_extensions=config.file_extensions,
+        )
+        
+        async with database:
+            index_stats = await indexer.get_indexing_stats()
+            db_stats = await database.get_stats()
+        
+        # Compile status data
+        status_data = {
+            "project": {
+                "name": project_info.name,
+                "root_path": str(project_info.root_path),
+                "initialized": project_info.is_initialized,
+                "languages": project_info.languages,
+                "file_count": project_info.file_count,
+            },
+            "configuration": {
+                "embedding_model": config.embedding_model,
+                "similarity_threshold": config.similarity_threshold,
+                "file_extensions": config.file_extensions,
+                "max_chunk_size": config.max_chunk_size,
+                "cache_embeddings": config.cache_embeddings,
+                "watch_files": config.watch_files,
+            },
+            "index": {
+                "total_files": index_stats.get("total_indexable_files", 0),
+                "indexed_files": index_stats.get("indexed_files", 0),
+                "total_chunks": index_stats.get("total_chunks", 0),
+                "languages": index_stats.get("languages", {}),
+                "index_size_mb": db_stats.index_size_mb,
+                "last_updated": db_stats.last_updated,
+            },
+        }
+        
+        # Add health check if requested
+        if health_check:
+            health_status = await perform_health_check(project_root, config)
+            status_data["health"] = health_status
+        
+        # Add verbose information
+        if verbose:
+            status_data["verbose"] = {
+                "config_path": str(project_info.config_path),
+                "index_path": str(project_info.index_path),
+                "ignore_patterns": list(indexer.get_ignore_patterns()),
+                "parser_info": index_stats.get("parser_info", {}),
+            }
+        
+        # Output results
+        if json_output:
+            print_json(status_data)
+        else:
+            _display_status(status_data, verbose)
+            
+    except ProjectNotFoundError:
+        if json_output:
+            print_json({"initialized": False, "error": "Project not initialized"})
+        else:
+            print_error("Project not initialized")
+            print_info("Run 'mcp-vector-search init' to initialize the project")
+    except Exception as e:
+        if json_output:
+            print_json({"error": str(e)})
+        else:
+            print_error(f"Failed to get status: {e}")
+        raise
+
+
+def _display_status(status_data: Dict[str, Any], verbose: bool) -> None:
+    """Display status in human-readable format."""
+    project_data = status_data["project"]
+    config_data = status_data["configuration"]
+    index_data = status_data["index"]
+    
+    # Project information
+    console.print("[bold blue]Project Information[/bold blue]")
+    console.print(f"  Name: {project_data['name']}")
+    console.print(f"  Root: {project_data['root_path']}")
+    console.print(f"  Languages: {', '.join(project_data['languages']) if project_data['languages'] else 'None detected'}")
+    console.print(f"  Indexable Files: {project_data['file_count']}")
+    console.print()
+    
+    # Configuration
+    console.print("[bold blue]Configuration[/bold blue]")
+    console.print(f"  Embedding Model: {config_data['embedding_model']}")
+    console.print(f"  Similarity Threshold: {config_data['similarity_threshold']}")
+    console.print(f"  File Extensions: {', '.join(config_data['file_extensions'])}")
+    console.print(f"  Cache Embeddings: {'✓' if config_data['cache_embeddings'] else '✗'}")
+    console.print()
+    
+    # Index statistics
+    console.print("[bold blue]Index Statistics[/bold blue]")
+    console.print(f"  Indexed Files: {index_data['indexed_files']}/{index_data['total_files']}")
+    console.print(f"  Total Chunks: {index_data['total_chunks']}")
+    console.print(f"  Index Size: {index_data['index_size_mb']:.2f} MB")
+    
+    if index_data['languages']:
+        console.print("  Language Distribution:")
+        for lang, count in index_data['languages'].items():
+            console.print(f"    {lang}: {count} chunks")
+    console.print()
+    
+    # Health check results
+    if "health" in status_data:
+        health_data = status_data["health"]
+        console.print("[bold blue]Health Check[/bold blue]")
+        
+        overall_health = health_data.get("overall", "unknown")
+        if overall_health == "healthy":
+            console.print("[green]✓ System is healthy[/green]")
+        elif overall_health == "warning":
+            console.print("[yellow]⚠ System has warnings[/yellow]")
+        else:
+            console.print("[red]✗ System has issues[/red]")
+        
+        for component, status in health_data.get("components", {}).items():
+            if status == "ok":
+                console.print(f"  [green]✓[/green] {component}")
+            elif status == "warning":
+                console.print(f"  [yellow]⚠[/yellow] {component}")
+            else:
+                console.print(f"  [red]✗[/red] {component}")
+        console.print()
+    
+    # Verbose information
+    if verbose and "verbose" in status_data:
+        verbose_data = status_data["verbose"]
+        console.print("[bold blue]Detailed Information[/bold blue]")
+        console.print(f"  Config Path: {verbose_data['config_path']}")
+        console.print(f"  Index Path: {verbose_data['index_path']}")
+        console.print(f"  Ignore Patterns: {', '.join(verbose_data['ignore_patterns'])}")
+
+
+async def perform_health_check(project_root: Path, config) -> Dict[str, Any]:
+    """Perform comprehensive health check."""
+    health_status = {
+        "overall": "healthy",
+        "components": {},
+        "issues": [],
+    }
+    
+    try:
+        # Check dependencies
+        deps_ok = check_dependencies()
+        health_status["components"]["dependencies"] = "ok" if deps_ok else "error"
+        if not deps_ok:
+            health_status["issues"].append("Missing dependencies")
+        
+        # Check configuration
+        config_ok = True
+        try:
+            # Validate embedding model
+            embedding_function, _ = create_embedding_function(config.embedding_model)
+            health_status["components"]["embedding_model"] = "ok"
+        except Exception as e:
+            config_ok = False
+            health_status["components"]["embedding_model"] = "error"
+            health_status["issues"].append(f"Embedding model error: {e}")
+        
+        # Check database
+        try:
+            database = ChromaVectorDatabase(
+                persist_directory=config.index_path,
+                embedding_function=embedding_function,
+            )
+            async with database:
+                await database.get_stats()
+            health_status["components"]["database"] = "ok"
+        except Exception as e:
+            health_status["components"]["database"] = "error"
+            health_status["issues"].append(f"Database error: {e}")
+        
+        # Check file system permissions
+        try:
+            config.index_path.mkdir(parents=True, exist_ok=True)
+            test_file = config.index_path / ".test_write"
+            test_file.write_text("test")
+            test_file.unlink()
+            health_status["components"]["file_permissions"] = "ok"
+        except Exception as e:
+            health_status["components"]["file_permissions"] = "error"
+            health_status["issues"].append(f"File permission error: {e}")
+        
+        # Determine overall health
+        if any(status == "error" for status in health_status["components"].values()):
+            health_status["overall"] = "error"
+        elif any(status == "warning" for status in health_status["components"].values()):
+            health_status["overall"] = "warning"
+        
+    except Exception as e:
+        health_status["overall"] = "error"
+        health_status["issues"].append(f"Health check failed: {e}")
+    
+    return health_status
+
+
+def check_dependencies() -> bool:
+    """Check if all required dependencies are available."""
+    dependencies = [
+        ("chromadb", "ChromaDB"),
+        ("sentence_transformers", "Sentence Transformers"),
+        ("tree_sitter", "Tree-sitter"),
+        ("tree_sitter_languages", "Tree-sitter Languages"),
+        ("typer", "Typer"),
+        ("rich", "Rich"),
+        ("pydantic", "Pydantic"),
+        ("watchdog", "Watchdog"),
+        ("loguru", "Loguru"),
+    ]
+    
+    all_available = True
+    
+    for module_name, display_name in dependencies:
+        try:
+            __import__(module_name)
+            print_dependency_status(display_name, True)
+        except ImportError:
+            print_dependency_status(display_name, False)
+            all_available = False
+    
+    return all_available
+
+
+if __name__ == "__main__":
+    status_app()

mcp_vector_search/cli/commands/watch.py

@@ -0,0 +1,288 @@
+"""Watch command for MCP Vector Search CLI."""
+
+import asyncio
+import signal
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+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.watcher import FileWatcher
+from ..output import (
+    console,
+    print_error,
+    print_info,
+    print_success,
+    print_warning,
+)
+
+app = typer.Typer(name="watch", help="Watch for file changes and update index")
+
+
+@app.command("main")
+def watch_main(
+    project_root: Path = typer.Argument(
+        Path.cwd(),
+        help="Project root directory to watch",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        readable=True,
+    ),
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Configuration file to use",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Enable verbose output",
+    ),
+) -> None:
+    """Watch for file changes and automatically update the search index.
+    
+    This command starts a file watcher that monitors your project directory
+    for changes to code files. When files are created, modified, or deleted,
+    the search index is automatically updated to reflect the changes.
+    
+    The watcher will:
+    - Monitor all files with configured extensions
+    - Debounce rapid changes to avoid excessive indexing
+    - Update the index incrementally for better performance
+    - Ignore common build/cache directories
+    
+    Press Ctrl+C to stop watching.
+    
+    Examples:
+        mcp-vector-search watch
+        mcp-vector-search watch /path/to/project --verbose
+        mcp-vector-search watch --config custom-config.json
+    """
+    if verbose:
+        logger.remove()
+        logger.add(sys.stderr, level="DEBUG")
+    
+    try:
+        asyncio.run(_watch_async(project_root, config))
+    except KeyboardInterrupt:
+        print_info("Watch stopped by user")
+    except Exception as e:
+        print_error(f"Watch failed: {e}")
+        raise typer.Exit(1)
+
+
+async def _watch_async(project_root: Path, config_path: Optional[Path]) -> None:
+    """Async implementation of watch command."""
+    # Load project configuration
+    try:
+        project_manager = ProjectManager(project_root)
+        if not project_manager.is_initialized():
+            print_error(
+                f"Project not initialized at {project_root}. "
+                "Run 'mcp-vector-search init' first."
+            )
+            raise typer.Exit(1)
+        
+        config = project_manager.load_config()
+        print_info(f"Loaded configuration from {project_root}")
+        
+    except ProjectNotFoundError:
+        print_error(
+            f"No MCP Vector Search project found at {project_root}. "
+            "Run 'mcp-vector-search init' to initialize."
+        )
+        raise typer.Exit(1)
+    
+    # Setup database and indexer
+    try:
+        embedding_function, _ = create_embedding_function(config.embedding_model)
+        database = ChromaVectorDatabase(
+            persist_directory=config.index_path,
+            embedding_function=embedding_function,
+        )
+        
+        indexer = SemanticIndexer(
+            database=database,
+            project_root=project_root,
+            file_extensions=config.file_extensions,
+        )
+        
+        print_info(f"Initialized database at {config.index_path}")
+        
+    except Exception as e:
+        print_error(f"Failed to initialize database: {e}")
+        raise typer.Exit(1)
+    
+    # Start watching
+    try:
+        async with database:
+            watcher = FileWatcher(
+                project_root=project_root,
+                config=config,
+                indexer=indexer,
+                database=database,
+            )
+            
+            print_success("🔍 Starting file watcher...")
+            print_info(f"📁 Watching: {project_root}")
+            print_info(f"📄 Extensions: {', '.join(config.file_extensions)}")
+            print_info("Press Ctrl+C to stop watching")
+            
+            async with watcher:
+                # Set up signal handlers for graceful shutdown
+                stop_event = asyncio.Event()
+                
+                def signal_handler():
+                    print_info("\n⏹️  Stopping file watcher...")
+                    stop_event.set()
+                
+                # Handle SIGINT (Ctrl+C) and SIGTERM
+                if sys.platform != "win32":
+                    loop = asyncio.get_running_loop()
+                    for sig in (signal.SIGINT, signal.SIGTERM):
+                        loop.add_signal_handler(sig, signal_handler)
+                
+                try:
+                    # Wait for stop signal
+                    await stop_event.wait()
+                except KeyboardInterrupt:
+                    signal_handler()
+                
+                print_success("✅ File watcher stopped")
+                
+    except Exception as e:
+        print_error(f"File watching failed: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("status")
+def watch_status(
+    project_root: Path = typer.Argument(
+        Path.cwd(),
+        help="Project root directory",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        readable=True,
+    ),
+) -> None:
+    """Check if file watching is enabled for a project.
+    
+    This command checks the project configuration to see if file watching
+    is enabled and provides information about the watch settings.
+    """
+    try:
+        project_manager = ProjectManager(project_root)
+        if not project_manager.is_initialized():
+            print_error(f"Project not initialized at {project_root}")
+            raise typer.Exit(1)
+        
+        config = project_manager.load_config()
+        
+        console.print("\n[bold]File Watch Status[/bold]")
+        console.print(f"Project: {project_root}")
+        console.print(f"Watch Files: {'✓' if config.watch_files else '✗'}")
+        
+        if config.watch_files:
+            console.print(f"Extensions: {', '.join(config.file_extensions)}")
+            print_info("File watching is enabled for this project")
+        else:
+            print_warning("File watching is disabled for this project")
+            print_info("Enable with: mcp-vector-search config set watch_files true")
+            
+    except ProjectNotFoundError:
+        print_error(f"No MCP Vector Search project found at {project_root}")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_error(f"Failed to check watch status: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("enable")
+def watch_enable(
+    project_root: Path = typer.Argument(
+        Path.cwd(),
+        help="Project root directory",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        readable=True,
+    ),
+) -> None:
+    """Enable file watching for a project.
+    
+    This command enables the watch_files setting in the project configuration.
+    After enabling, you can use 'mcp-vector-search watch' to start monitoring.
+    """
+    try:
+        project_manager = ProjectManager(project_root)
+        if not project_manager.is_initialized():
+            print_error(f"Project not initialized at {project_root}")
+            raise typer.Exit(1)
+        
+        config = project_manager.load_config()
+        config.watch_files = True
+        project_manager.save_config(config)
+        
+        print_success("✅ File watching enabled")
+        print_info("Start watching with: mcp-vector-search watch")
+        
+    except ProjectNotFoundError:
+        print_error(f"No MCP Vector Search project found at {project_root}")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_error(f"Failed to enable file watching: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("disable")
+def watch_disable(
+    project_root: Path = typer.Argument(
+        Path.cwd(),
+        help="Project root directory",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        readable=True,
+    ),
+) -> None:
+    """Disable file watching for a project.
+    
+    This command disables the watch_files setting in the project configuration.
+    """
+    try:
+        project_manager = ProjectManager(project_root)
+        if not project_manager.is_initialized():
+            print_error(f"Project not initialized at {project_root}")
+            raise typer.Exit(1)
+        
+        config = project_manager.load_config()
+        config.watch_files = False
+        project_manager.save_config(config)
+        
+        print_success("✅ File watching disabled")
+        
+    except ProjectNotFoundError:
+        print_error(f"No MCP Vector Search project found at {project_root}")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_error(f"Failed to disable file watching: {e}")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()