mcp-vector-search 1.0.3__py3-none-any.whl → 1.1.22__py3-none-any.whl

mcp_vector_search/cli/commands/index.py

@@ -1,6 +1,11 @@
 """Index command for MCP Vector Search CLI."""
 
 import asyncio
+import json
+import os
+import signal
+import subprocess
+import sys
 from pathlib import Path
 
 import typer
@@ -19,6 +24,7 @@ from ..output import (
     print_next_steps,
     print_success,
     print_tip,
+    print_warning,
 )
 
 # Create index subcommand app with callback for direct usage
@@ -38,6 +44,13 @@ def main(
         help="Watch for file changes and update index incrementally",
         rich_help_panel="⚙️  Advanced Options",
     ),
+    background: bool = typer.Option(
+        False,
+        "--background",
+        "-bg",
+        help="Run indexing in background (detached process)",
+        rich_help_panel="⚙️  Advanced Options",
+    ),
     incremental: bool = typer.Option(
         True,
         "--incremental/--full",
@@ -58,6 +71,12 @@ def main(
         help="Force reindexing of all files",
         rich_help_panel="📊 Indexing Options",
     ),
+    auto_analyze: bool = typer.Option(
+        True,
+        "--analyze/--no-analyze",
+        help="Automatically run analysis after force reindex",
+        rich_help_panel="📊 Indexing Options",
+    ),
     batch_size: int = typer.Option(
         32,
         "--batch-size",
@@ -74,12 +93,21 @@ def main(
         help="Enable debug output (shows hierarchy building details)",
         rich_help_panel="🔍 Debugging",
     ),
+    skip_relationships: bool = typer.Option(
+        True,
+        "--skip-relationships/--compute-relationships",
+        help="Skip relationship computation during indexing (default: skip). Relationships are computed lazily by the visualizer when needed.",
+        rich_help_panel="⚡ Performance",
+    ),
 ) -> None:
     """📑 Index your codebase for semantic search.
 
     Parses code files, generates semantic embeddings, and stores them in ChromaDB.
     Supports incremental indexing to skip unchanged files for faster updates.
 
+    When using --force, automatically runs code analysis after indexing completes
+    (can be disabled with --no-analyze).
+
     [bold cyan]Basic Examples:[/bold cyan]
 
     [green]Index entire project:[/green]
@@ -88,6 +116,9 @@ def main(
     [green]Force full reindex:[/green]
         $ mcp-vector-search index --force
 
+    [green]Force reindex without analysis:[/green]
+        $ mcp-vector-search index --force --no-analyze
+
     [green]Custom file extensions:[/green]
         $ mcp-vector-search index --extensions .py,.js,.ts,.md
 
@@ -102,7 +133,10 @@ def main(
     [green]Optimize for large projects:[/green]
         $ mcp-vector-search index --batch-size 64
 
-    [dim]💡 Tip: Use incremental indexing (default) for faster updates on subsequent runs.[/dim]
+    [green]Pre-compute relationships (slower indexing, instant visualization):[/green]
+        $ mcp-vector-search index --compute-relationships
+
+    [dim]💡 Tip: Relationships are computed lazily by the visualizer for instant indexing.[/dim]
     """
     # If a subcommand was invoked, don't run the indexing logic
     if ctx.invoked_subcommand is not None:
@@ -111,6 +145,11 @@ def main(
     try:
         project_root = (ctx.obj.get("project_root") if ctx.obj else None) or Path.cwd()
 
+        # Handle background mode
+        if background:
+            _spawn_background_indexer(project_root, force, extensions)
+            return
+
         # Run async indexing
         asyncio.run(
             run_indexing(
@@ -122,9 +161,23 @@ def main(
                 batch_size=batch_size,
                 show_progress=True,
                 debug=debug,
+                skip_relationships=skip_relationships,
             )
         )
 
+        # Auto-analyze after force reindex
+        if force and auto_analyze:
+            from .analyze import run_analysis
+
+            print_info("\n📊 Running analysis after reindex...")
+            asyncio.run(
+                run_analysis(
+                    project_root=project_root,
+                    quick_mode=True,  # Use quick mode for speed
+                    show_smells=True,
+                )
+            )
+
     except KeyboardInterrupt:
         print_info("Indexing interrupted by user")
         raise typer.Exit(0)
@@ -134,6 +187,120 @@ def main(
         raise typer.Exit(1)
 
 
+def _spawn_background_indexer(
+    project_root: Path, force: bool = False, extensions: str | None = None
+) -> None:
+    """Spawn background indexing process.
+
+    Args:
+        project_root: Project root directory
+        force: Force reindexing of all files
+        extensions: Override file extensions (comma-separated)
+    """
+    # Check for existing background process
+    progress_file = project_root / ".mcp-vector-search" / "indexing_progress.json"
+    if progress_file.exists():
+        try:
+            with open(progress_file) as f:
+                progress = json.load(f)
+            pid = progress.get("pid")
+            if pid and _is_process_alive(pid):
+                print_warning(f"Background indexing already in progress (PID: {pid})")
+                print_info("Use 'mcp-vector-search index status' to check progress")
+                print_info("Use 'mcp-vector-search index cancel' to cancel")
+                return
+            else:
+                # Stale progress file, remove it
+                progress_file.unlink()
+        except Exception as e:
+            logger.warning(f"Failed to read progress file: {e}")
+            progress_file.unlink()
+
+    # Build command
+    python_exe = sys.executable
+    cmd = [
+        python_exe,
+        "-m",
+        "mcp_vector_search.cli.commands.index_background",
+        "--project-root",
+        str(project_root),
+    ]
+
+    if force:
+        cmd.append("--force")
+
+    if extensions:
+        cmd.extend(["--extensions", extensions])
+
+    # Spawn detached process
+    try:
+        if sys.platform == "win32":
+            # Windows detachment flags
+            detached_process = 0x00000008
+            create_new_process_group = 0x00000200
+
+            process = subprocess.Popen(
+                cmd,
+                creationflags=detached_process | create_new_process_group,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+            )
+        else:
+            # Unix detachment (fork + setsid)
+            process = subprocess.Popen(
+                cmd,
+                start_new_session=True,  # Creates new process group
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+            )
+
+        pid = process.pid
+        print_success(f"Started background indexing (PID: {pid})")
+        print_info(f"Progress file: {progress_file}")
+        print_info(
+            f"Log file: {project_root / '.mcp-vector-search' / 'indexing_background.log'}"
+        )
+        print_info("")
+        print_info("Use [cyan]mcp-vector-search index status[/cyan] to check progress")
+        print_info("Use [cyan]mcp-vector-search index cancel[/cyan] to cancel")
+
+    except Exception as e:
+        logger.error(f"Failed to spawn background process: {e}")
+        print_error(f"Failed to start background indexing: {e}")
+        raise typer.Exit(1)
+
+
+def _is_process_alive(pid: int) -> bool:
+    """Check if process with given PID is alive.
+
+    Args:
+        pid: Process ID to check
+
+    Returns:
+        True if process is alive, False otherwise
+    """
+    try:
+        if sys.platform == "win32":
+            # Windows: try to open process
+            import ctypes
+
+            kernel32 = ctypes.windll.kernel32
+            process_query_information = 0x0400
+            handle = kernel32.OpenProcess(process_query_information, False, pid)
+            if handle:
+                kernel32.CloseHandle(handle)
+                return True
+            return False
+        else:
+            # Unix: send signal 0 (no-op, just checks if process exists)
+            os.kill(pid, 0)
+            return True
+    except (OSError, ProcessLookupError, AttributeError):
+        return False
+
+
 async def run_indexing(
     project_root: Path,
     watch: bool = False,
@@ -143,6 +310,7 @@ async def run_indexing(
     batch_size: int = 32,
     show_progress: bool = True,
     debug: bool = False,
+    skip_relationships: bool = False,
 ) -> None:
     """Run the indexing process."""
     # Load project configuration
@@ -197,7 +365,9 @@ async def run_indexing(
             if watch:
                 await _run_watch_mode(indexer, show_progress)
             else:
-                await _run_batch_indexing(indexer, force_reindex, show_progress)
+                await _run_batch_indexing(
+                    indexer, force_reindex, show_progress, skip_relationships
+                )
 
     except Exception as e:
         logger.error(f"Indexing error: {e}")
@@ -208,6 +378,7 @@ async def _run_batch_indexing(
     indexer: SemanticIndexer,
     force_reindex: bool,
     show_progress: bool,
+    skip_relationships: bool = False,
 ) -> None:
     """Run batch indexing of all files."""
     if show_progress:
@@ -357,6 +528,30 @@ async def _run_batch_indexing(
             except Exception as e:
                 logger.error(f"Failed to update directory index: {e}")
 
+            # Mark relationships for background computation (unless skipped)
+            if not skip_relationships and indexed_count > 0:
+                try:
+                    console.print(
+                        "\n[cyan]Marking relationships for background computation...[/cyan]"
+                    )
+                    all_chunks = await indexer.database.get_all_chunks()
+
+                    if len(all_chunks) > 0:
+                        await indexer.relationship_store.compute_and_store(
+                            all_chunks, indexer.database, background=True
+                        )
+                        console.print(
+                            "[green]✓[/green] Relationships marked for background computation"
+                        )
+                        console.print(
+                            "[dim]  → Use 'mcp-vector-search index relationships' to compute now[/dim]"
+                        )
+                except Exception as e:
+                    logger.warning(f"Failed to mark relationships: {e}")
+                    console.print(
+                        "[yellow]⚠ Relationships not marked (visualization will compute on demand)[/yellow]"
+                    )
+
             # Final progress summary
             console.print()
             if failed_count > 0:
@@ -375,6 +570,7 @@ async def _run_batch_indexing(
         indexed_count = await indexer.index_project(
             force_reindex=force_reindex,
             show_progress=show_progress,
+            skip_relationships=skip_relationships,
         )
 
     # Show statistics
@@ -733,6 +929,237 @@ def health_cmd(
     health_main(project_root=project_root, repair=repair)
 
 
+@index_app.command("status")
+def status_cmd(
+    ctx: typer.Context,
+) -> None:
+    """📊 Show background indexing status.
+
+    Displays the current progress of any background indexing process.
+
+    Examples:
+        mcp-vector-search index status
+    """
+    try:
+        project_root = ctx.obj.get("project_root") or Path.cwd()
+        _show_background_status(project_root)
+    except Exception as e:
+        logger.error(f"Status check failed: {e}")
+        print_error(f"Status check failed: {e}")
+        raise typer.Exit(1)
+
+
+@index_app.command("cancel")
+def cancel_cmd(
+    ctx: typer.Context,
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Force termination without confirmation",
+    ),
+) -> None:
+    """🛑 Cancel background indexing process.
+
+    Terminates any running background indexing process and cleans up.
+
+    Examples:
+        mcp-vector-search index cancel
+        mcp-vector-search index cancel --force
+    """
+    try:
+        project_root = ctx.obj.get("project_root") or Path.cwd()
+        _cancel_background_indexer(project_root, force)
+    except Exception as e:
+        logger.error(f"Cancel failed: {e}")
+        print_error(f"Cancel failed: {e}")
+        raise typer.Exit(1)
+
+
+def _show_background_status(project_root: Path) -> None:
+    """Show background indexing status.
+
+    Args:
+        project_root: Project root directory
+    """
+    from rich.table import Table
+
+    from ..output import console
+
+    progress_file = project_root / ".mcp-vector-search" / "indexing_progress.json"
+
+    if not progress_file.exists():
+        print_info("No background indexing in progress")
+        return
+
+    # Read progress
+    try:
+        with open(progress_file) as f:
+            progress = json.load(f)
+    except Exception as e:
+        print_error(f"Failed to read progress file: {e}")
+        return
+
+    # Check if process is alive
+    pid = progress.get("pid")
+    is_alive = _is_process_alive(pid) if pid else False
+
+    if not is_alive:
+        print_warning(f"Process {pid} is no longer running")
+        print_info("The background indexing process has stopped")
+        print_info("Run [cyan]mcp-vector-search index --background[/cyan] to restart")
+        # Optionally clean up stale file
+        return
+
+    # Display progress with Rich table
+    table = Table(title="Background Indexing Status", show_header=True)
+    table.add_column("Metric", style="cyan", width=20)
+    table.add_column("Value", style="green")
+
+    # Format status with color
+    status = progress.get("status", "unknown")
+    status_colors = {
+        "initializing": "yellow",
+        "scanning": "cyan",
+        "running": "green",
+        "computing_relationships": "cyan",
+        "completed": "green",
+        "failed": "red",
+        "cancelled": "yellow",
+    }
+    status_color = status_colors.get(status, "white")
+
+    table.add_row("PID", str(pid))
+    table.add_row("Status", f"[{status_color}]{status}[/{status_color}]")
+
+    # Progress percentage
+    total = progress.get("total_files", 0)
+    processed = progress.get("processed_files", 0)
+    if total > 0:
+        percentage = (processed / total) * 100
+        table.add_row(
+            "Progress",
+            f"{processed}/{total} files ({percentage:.1f}%)",
+        )
+    else:
+        table.add_row("Progress", f"{processed} files")
+
+    current_file = progress.get("current_file")
+    if current_file:
+        table.add_row("Current File", current_file)
+
+    table.add_row("Chunks Created", str(progress.get("chunks_created", 0)))
+    table.add_row("Errors", str(progress.get("errors", 0)))
+
+    # ETA
+    eta_seconds = progress.get("eta_seconds", 0)
+    if eta_seconds > 0:
+        eta_minutes = eta_seconds / 60
+        if eta_minutes < 1:
+            table.add_row("ETA", f"{eta_seconds} seconds")
+        else:
+            table.add_row("ETA", f"{eta_minutes:.1f} minutes")
+
+    # Last updated
+    last_updated = progress.get("last_updated")
+    if last_updated:
+        table.add_row("Last Updated", last_updated)
+
+    console.print(table)
+
+    # Show log file location
+    log_file = project_root / ".mcp-vector-search" / "indexing_background.log"
+    if log_file.exists():
+        print_info(f"\nLog file: {log_file}")
+
+
+def _cancel_background_indexer(project_root: Path, force: bool = False) -> None:
+    """Cancel background indexing process.
+
+    Args:
+        project_root: Project root directory
+        force: Skip confirmation prompt
+    """
+    progress_file = project_root / ".mcp-vector-search" / "indexing_progress.json"
+
+    if not progress_file.exists():
+        print_info("No background indexing in progress")
+        return
+
+    # Read progress
+    try:
+        with open(progress_file) as f:
+            progress = json.load(f)
+    except Exception as e:
+        print_error(f"Failed to read progress file: {e}")
+        return
+
+    pid = progress.get("pid")
+    if not pid:
+        print_error("No PID found in progress file")
+        return
+
+    # Check if process is alive
+    if not _is_process_alive(pid):
+        print_warning(f"Process {pid} is not running (already completed?)")
+        # Clean up stale progress file
+        try:
+            progress_file.unlink()
+            print_info("Cleaned up stale progress file")
+        except Exception as e:
+            logger.error(f"Failed to clean up progress file: {e}")
+        return
+
+    # Confirm cancellation
+    if not force:
+        from ..output import confirm_action
+
+        if not confirm_action(
+            f"Cancel background indexing process (PID: {pid})?", default=False
+        ):
+            print_info("Cancellation aborted")
+            return
+
+    # Send termination signal
+    try:
+        if sys.platform == "win32":
+            # Windows: terminate process
+            import ctypes
+
+            kernel32 = ctypes.windll.kernel32
+            process_terminate = 0x0001
+            handle = kernel32.OpenProcess(process_terminate, False, pid)
+            if handle:
+                kernel32.TerminateProcess(handle, 0)
+                kernel32.CloseHandle(handle)
+                print_success(f"Cancelled indexing process {pid}")
+            else:
+                print_error(f"Failed to open process {pid}")
+                return
+        else:
+            # Unix: send SIGTERM
+            os.kill(pid, signal.SIGTERM)
+            print_success(f"Cancelled indexing process {pid}")
+
+        # Clean up progress file after a brief delay
+        import time
+
+        time.sleep(0.5)
+        if progress_file.exists():
+            progress_file.unlink()
+            print_info("Cleaned up progress file")
+
+    except ProcessLookupError:
+        print_warning(f"Process {pid} not found (already completed?)")
+        if progress_file.exists():
+            progress_file.unlink()
+    except PermissionError:
+        print_error(f"Permission denied to cancel process {pid}")
+    except Exception as e:
+        logger.error(f"Failed to cancel process: {e}")
+        print_error(f"Failed to cancel process: {e}")
+
+
 def _prune_error_log(log_path: Path, max_lines: int = 1000) -> None:
     """Prune error log to keep only the most recent N lines.
 
@@ -758,5 +1185,176 @@ def _prune_error_log(log_path: Path, max_lines: int = 1000) -> None:
         logger.warning(f"Failed to prune error log: {e}")
 
 
+@index_app.command("relationships")
+def compute_relationships_cmd(
+    ctx: typer.Context,
+    background: bool = typer.Option(
+        False,
+        "--background",
+        "-bg",
+        help="Run relationship computation in background (non-blocking)",
+    ),
+) -> None:
+    """🔗 Compute semantic relationships for visualization.
+
+    By default, indexing marks relationships for background computation.
+    This command lets you compute them immediately or spawn a background task.
+
+    Examples:
+        # Compute relationships now (blocks until complete)
+        mcp-vector-search index relationships
+
+        # Compute in background (returns immediately)
+        mcp-vector-search index relationships --background
+    """
+    try:
+        project_root = ctx.obj.get("project_root") or Path.cwd()
+
+        if background:
+            # Spawn background relationship computation
+            print_info("Starting background relationship computation...")
+            _spawn_background_relationships(project_root)
+        else:
+            # Compute synchronously
+            asyncio.run(_compute_relationships_sync(project_root))
+
+    except Exception as e:
+        logger.error(f"Relationship computation failed: {e}")
+        print_error(f"Relationship computation failed: {e}")
+        raise typer.Exit(1)
+
+
+def _spawn_background_relationships(project_root: Path) -> None:
+    """Spawn background relationship computation process.
+
+    Args:
+        project_root: Project root directory
+    """
+    # Build command
+    python_exe = sys.executable
+    cmd = [
+        python_exe,
+        "-m",
+        "mcp_vector_search.cli.commands.index_background",
+        "--project-root",
+        str(project_root),
+        "--relationships-only",  # New flag for relationship-only mode
+    ]
+
+    # Spawn detached process (reuse existing background infrastructure)
+    try:
+        if sys.platform == "win32":
+            detached_process = 0x00000008
+            create_new_process_group = 0x00000200
+
+            process = subprocess.Popen(
+                cmd,
+                creationflags=detached_process | create_new_process_group,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+            )
+        else:
+            process = subprocess.Popen(
+                cmd,
+                start_new_session=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+            )
+
+        pid = process.pid
+        print_success(f"Started background relationship computation (PID: {pid})")
+        print_info(
+            f"Log file: {project_root / '.mcp-vector-search' / 'relationships_background.log'}"
+        )
+
+    except Exception as e:
+        logger.error(f"Failed to spawn background process: {e}")
+        print_error(f"Failed to start background computation: {e}")
+        raise typer.Exit(1)
+
+
+async def _compute_relationships_sync(project_root: Path) -> None:
+    """Compute relationships synchronously (blocking).
+
+    Args:
+        project_root: Project root directory
+    """
+    from rich.progress import (
+        BarColumn,
+        Progress,
+        SpinnerColumn,
+        TextColumn,
+        TimeRemainingColumn,
+    )
+
+    from ..output import console
+
+    # Load project configuration
+    project_manager = ProjectManager(project_root)
+
+    if not project_manager.is_initialized():
+        raise ProjectNotFoundError(
+            f"Project not initialized at {project_root}. Run 'mcp-vector-search init' first."
+        )
+
+    config = project_manager.load_config()
+
+    console.print(f"[cyan]Project:[/cyan] {project_root}")
+    console.print(f"[cyan]Embedding model:[/cyan] {config.embedding_model}")
+
+    # Setup database
+    embedding_function, _ = create_embedding_function(config.embedding_model)
+    database = ChromaVectorDatabase(
+        persist_directory=config.index_path,
+        embedding_function=embedding_function,
+    )
+
+    async with database:
+        # Get all chunks
+        console.print("[cyan]Fetching chunks from database...[/cyan]")
+        all_chunks = await database.get_all_chunks()
+
+        if len(all_chunks) == 0:
+            console.print(
+                "[yellow]No chunks found in index. Run 'mcp-vector-search index' first.[/yellow]"
+            )
+            raise typer.Exit(1)
+
+        console.print(f"[green]✓[/green] Retrieved {len(all_chunks)} chunks\n")
+
+        # Initialize relationship store
+        from ...core.relationships import RelationshipStore
+
+        relationship_store = RelationshipStore(project_root)
+
+        # Compute relationships with progress
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(bar_width=40),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            TimeRemainingColumn(),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Computing semantic relationships...", total=100)
+
+            # Compute and store (non-background mode)
+            rel_stats = await relationship_store.compute_and_store(
+                all_chunks, database, background=False
+            )
+
+            progress.update(task, completed=100)
+
+        # Show results
+        console.print()
+        console.print(
+            f"[green]✓[/green] Computed {rel_stats['semantic_links']} semantic links "
+            f"in {rel_stats['computation_time']:.1f}s"
+        )
+        print_success("Relationships ready for visualization")
+
+
 if __name__ == "__main__":
     index_app()