@mc1global/opencode-jarvis 0.13.1 → 0.14.0

package/scripts/rag/rag_cli_commands.py.bak4

@@ -1,1557 +0,0 @@
-"""
-RAG CLI Index and Update Commands.
-
-Implements index, update, delete, and batch-update commands.
-
-Supports 3 output modes:
-- MODERN: Rich Live UI for interactive terminal
-- LEGACY: Verbose logging for debugging
-- TOON: Token-optimized output for LLM agents
-
-Key improvement: Now uses .gitignore from the TARGET workspace being indexed,
-not from JARVIS's cwd. Also detects excludable directories when no .gitignore exists.
-
-Type Hints: Required (mypy compliant)
-Docstring: Google format
-"""
-
-import logging
-import time
-from pathlib import Path
-from typing import List, Optional, Tuple
-
-from src.shared.cli import OutputMode, detect_output_mode, toon_ok, toon_error
-from scripts.rag.rag_config import RAGConfigManager
-from src.application.rag.use_cases.index_code_use_case import IndexCodeUseCase
-from src.infrastructure.rag.gitignore_aware_loader import (
-    GitignoreAwareDocumentLoader,
-    ExclusionSuggestion,
-)
-from src.infrastructure.rag.document_loader_repository import DocumentLoaderRepository
-from src.infrastructure.rag.oracle_document_loader import OracleDocumentLoader
-from src.infrastructure.rag.vector_store_repository import VectorStoreRepository
-from src.infrastructure.rag.vector_store_repository_observable import (
-    ObservableVectorStoreRepository,
-)
-from src.infrastructure.rag.hierarchical_domain_inference import (
-    HierarchicalDomainInference,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def check_workspace_gitignore(data_path: str) -> Tuple[bool, List[ExclusionSuggestion]]:
-    """
-    Check if workspace has .gitignore and detect excludable directories.
-
-    Args:
-        data_path: Path to the workspace being indexed
-
-    Returns:
-        Tuple of (has_gitignore: bool, suggestions: List[ExclusionSuggestion])
-    """
-    data_path_obj = Path(data_path).resolve()
-
-    # ARCHITECTURAL FIX: Use global context for consistent gitignore detection
-    # Don't create new loader, just check if .gitignore exists in the path
-    gitignore_path = data_path_obj / ".gitignore"
-    found_gitignore = gitignore_path.exists()
-
-    if not found_gitignore:
-        # Create temporary loader only for detecting excludable directories
-        loader = GitignoreAwareDocumentLoader()
-        suggestions = loader.detect_excludable_directories(data_path_obj)
-    else:
-        suggestions = []
-
-    suggestions = []
-    if not found_gitignore:
-        # Scan for excludable directories
-        suggestions = loader.detect_excludable_directories(data_path_obj)
-
-    return found_gitignore, suggestions
-
-
-def show_exclusion_suggestions_modern(
-    suggestions: List[ExclusionSuggestion],
-    data_path: str,
-    force: bool = False,
-) -> Tuple[bool, bool]:
-    """
-    Show exclusion suggestions in Rich UI format with user interaction.
-
-    Args:
-        suggestions: List of suggested exclusions
-        data_path: Path being indexed
-        force: If True, skip confirmation and proceed
-
-    Returns:
-        Tuple of (proceed: bool, created_gitignore: bool)
-    """
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.table import Table
-    from rich.prompt import Prompt, Confirm
-
-    console = Console()
-
-    console.print()
-    console.print(
-        Panel(
-            f"[yellow]No .gitignore found in:[/yellow]\n[cyan]{data_path}[/cyan]",
-            title="[bold yellow]Warning: Missing .gitignore[/bold yellow]",
-            border_style="yellow",
-        )
-    )
-
-    if not suggestions:
-        console.print("[green]No potentially excludable directories detected.[/green]")
-        console.print("[dim]Proceeding with config/rag.yaml exclusion patterns.[/dim]")
-        return True, False
-
-    console.print()
-    console.print(
-        f"[yellow]Detected {len(suggestions)} directories that should likely be excluded:[/yellow]"
-    )
-    console.print()
-
-    table = Table(show_header=True, header_style="bold")
-    table.add_column("#", style="dim", width=3)
-    table.add_column("Directory", style="cyan")
-    table.add_column("Size", justify="right", style="magenta")
-    table.add_column("Reason", style="white")
-
-    data_path_obj = Path(data_path).resolve()
-    for i, s in enumerate(suggestions, 1):
-        rel_path = (
-            s.path.relative_to(data_path_obj)
-            if s.path.is_relative_to(data_path_obj)
-            else s.path
-        )
-        table.add_row(str(i), str(rel_path), s.size_estimate, s.reason)
-
-    console.print(table)
-    console.print()
-
-    # If force mode, skip confirmation
-    if force:
-        console.print(
-            "[dim]--force flag set, proceeding with config fallback patterns.[/dim]"
-        )
-        return True, False
-
-    # Interactive prompt
-    console.print("[bold]Options:[/bold]")
-    console.print(
-        "  [cyan]1[/cyan] - Create .gitignore with suggested patterns and continue"
-    )
-    console.print(
-        "  [cyan]2[/cyan] - Continue anyway (use config/rag.yaml fallback patterns)"
-    )
-    console.print("  [cyan]3[/cyan] - Abort indexing")
-    console.print()
-
-    choice = Prompt.ask(
-        "[bold]Choose an option[/bold]", choices=["1", "2", "3"], default="2"
-    )
-
-    if choice == "1":
-        # Create .gitignore
-        created = _create_gitignore_from_suggestions(
-            data_path_obj, suggestions, console
-        )
-        if created:
-            console.print(
-                "[green]Created .gitignore file. Continuing with indexing...[/green]"
-            )
-            return True, True
-        else:
-            console.print(
-                "[yellow]Could not create .gitignore. Continuing with fallback patterns...[/yellow]"
-            )
-            return True, False
-    elif choice == "2":
-        console.print("[dim]Proceeding with config/rag.yaml exclusion patterns.[/dim]")
-        return True, False
-    else:
-        console.print("[red]Indexing aborted by user.[/red]")
-        return False, False
-
-
-def _create_gitignore_from_suggestions(
-    data_path: Path,
-    suggestions: List[ExclusionSuggestion],
-    console,
-) -> bool:
-    """
-    Create a .gitignore file from the suggested exclusions.
-
-    Args:
-        data_path: Root directory where to create .gitignore
-        suggestions: List of exclusion suggestions
-        console: Rich console for output
-
-    Returns:
-        True if created successfully
-    """
-    gitignore_path = data_path / ".gitignore"
-
-    # Check if already exists
-    if gitignore_path.exists():
-        console.print(f"[yellow].gitignore already exists at {gitignore_path}[/yellow]")
-        return False
-
-    try:
-        lines = [
-            "# Generated by JARVIS RAG indexer",
-            "# Based on detected excludable directories",
-            "",
-        ]
-
-        for s in suggestions:
-            # Get directory name relative to root
-            try:
-                rel_path = s.path.relative_to(data_path)
-                dir_name = str(rel_path).split("/")[0]  # Get top-level directory
-            except ValueError:
-                dir_name = s.path.name
-
-            # Add pattern with comment
-            lines.append(f"# {s.reason}")
-            lines.append(f"{dir_name}/")
-            lines.append("")
-
-        # Add common patterns
-        lines.extend(
-            [
-                "# Common patterns",
-                "*.pyc",
-                "*.pyo",
-                "__pycache__/",
-                "*.log",
-                "*.tmp",
-                ".DS_Store",
-                "Thumbs.db",
-            ]
-        )
-
-        gitignore_path.write_text("\n".join(lines))
-        console.print(f"[green]Created: {gitignore_path}[/green]")
-        return True
-
-    except Exception as e:
-        console.print(f"[red]Error creating .gitignore: {e}[/red]")
-        return False
-
-    console.print()
-    console.print(
-        f"[yellow]Detected {len(suggestions)} directories that should likely be excluded:[/yellow]"
-    )
-    console.print()
-
-    table = Table(show_header=True, header_style="bold")
-    table.add_column("#", style="dim", width=3)
-    table.add_column("Directory", style="cyan")
-    table.add_column("Size", justify="right", style="magenta")
-    table.add_column("Reason", style="white")
-
-    for i, s in enumerate(suggestions, 1):
-        rel_path = (
-            s.path.relative_to(Path(data_path).resolve())
-            if s.path.is_relative_to(Path(data_path).resolve())
-            else s.path
-        )
-        table.add_row(str(i), str(rel_path), s.size_estimate, s.reason)
-
-    console.print(table)
-    console.print()
-
-    console.print("[bold yellow]Recommendation:[/bold yellow]")
-    console.print("  1. Create a .gitignore file in your project with these patterns")
-    console.print(
-        "  2. Or add exclusions to config/rag.yaml under rag.exclusions.patterns"
-    )
-    console.print()
-    console.print(
-        "[dim]The indexing will proceed using config/rag.yaml exclusion patterns as fallback.[/dim]"
-    )
-    console.print()
-
-    return True
-
-
-def show_exclusion_suggestions_toon(
-    suggestions: List[ExclusionSuggestion],
-    data_path: str,
-    force: bool = False,
-) -> bool:
-    """
-    Show exclusion suggestions in TOON format for agents.
-
-    When excludable directories are found and --force is not set,
-    this function returns False to abort indexing. The agent should
-    then decide to either:
-    1. Re-run with --force to proceed with fallback patterns
-    2. Create a .gitignore in the project first
-    3. Skip indexing this project
-
-    Args:
-        suggestions: List of suggested exclusions
-        data_path: Path being indexed
-        force: If True, proceed despite warnings
-
-    Returns:
-        True if should proceed, False to abort
-    """
-    print(f"warn:rag:index:no_gitignore:{data_path}")
-
-    if suggestions:
-        print(f"warn:rag:index:excludable_dirs:{len(suggestions)}")
-        data_path_obj = Path(data_path).resolve()
-        for s in suggestions:
-            rel_path = (
-                s.path.relative_to(data_path_obj)
-                if s.path.is_relative_to(data_path_obj)
-                else s.path
-            )
-            print(f"warn:excludable:{rel_path}:{s.size_estimate}:{s.reason}")
-
-        if not force:
-            print(
-                "error:rag:index:confirmation_required:use --force to proceed with fallback patterns"
-            )
-            print("hint:rag:index:create .gitignore in project or use --force flag")
-            return False
-        else:
-            print(
-                "info:rag:index:proceeding with --force using config fallback patterns"
-            )
-            return True
-
-    # No excludable dirs found, safe to proceed
-    print("info:rag:index:no_excludable_dirs_found:proceeding with config fallback")
-    return True
-
-
-def _is_oracle_path(data_dir: str) -> bool:
-    """
-    Detect if directory path contains ORACLE documents.
-
-    ORACLE documents are identified by path patterns:
-    - oracle/
-    - opencode_cli_resources/oracle
-
-    Args:
-        data_dir: Directory path to check
-
-    Returns:
-        True if path matches ORACLE patterns
-    """
-    path_lower = data_dir.lower()
-    oracle_patterns = ["oracle/", "opencode_cli_resources/oracle"]
-
-    for pattern in oracle_patterns:
-        if pattern.lower() in path_lower:
-            return True
-
-    return False
-
-
-def _create_document_loader(
-    use_gitignore: bool = True,
-    data_dir: str = None,
-    workspace: str = None,
-    workspace_root: str = None,
-):
-    """
-    Factory function for creating document loaders with proper context.
-
-    ARCHITECTURAL FIX: Sets global workspace context to ensure ALL instances
-    use the correct .gitignore, preventing cross-contamination.
-
-    This is the SINGLE SOURCE OF TRUTH for document loader creation.
-    All other creation points should use this factory.
-
-    Args:
-        use_gitignore: Whether to use gitignore-aware loading
-        data_dir: Optional data directory for ORACLE detection
-        workspace: Workspace name for context
-        workspace_root: Workspace root path for .gitignore resolution
-
-    Returns:
-        Properly configured document loader instance
-    """
-    if use_gitignore:
-        # Auto-detect ORACLE documents if data_dir provided
-        if data_dir and _is_oracle_path(data_dir):
-            return OracleDocumentLoader()
-        else:
-            # CRITICAL FIX: Set global workspace context BEFORE creating loader
-            if workspace and workspace_root:
-                GitignoreAwareDocumentLoader.set_global_workspace_context(
-                    workspace, workspace_root
-                )
-
-            # Create GitignoreAwareDocumentLoader with FULL CONTEXT
-            return GitignoreAwareDocumentLoader(
-                target_directory=workspace_root, workspace_context=workspace
-            )
-    else:
-        # For update operations, check if path is ORACLE
-        if data_dir and _is_oracle_path(data_dir):
-            return OracleDocumentLoader()
-        else:
-            return DocumentLoaderRepository()
-
-
-def create_repositories(
-    config,
-    observable: bool = True,
-    use_gitignore: bool = True,
-    workspace: str = None,
-    data_dir: str = None,
-    workspace_root: str = None,
-):
-    """
-    Factory for creating repository instances.
-
-    Args:
-        config: RAG configuration object
-        observable: Use observable version with progress tracking
-        use_gitignore: Use gitignore-aware loader (False for update operations)
-        workspace: Workspace name for per-workspace RAG isolation.
-                  If provided, uses workspace-specific ChromaDB.
-                  If None, falls back to config.vectorstore.persist_dir (legacy).
-        data_dir: Optional data directory to detect ORACLE documents.
-                 If path contains ORACLE patterns, uses OracleDocumentLoader.
-
-    Returns:
-        Tuple of (document_repository, vector_store_repository)
-    """
-    # ARCHITECTURAL FIX: Create document loader with full context
-    doc_repo = _create_document_loader(
-        use_gitignore=use_gitignore,
-        data_dir=data_dir,
-        workspace=workspace,
-        workspace_root=workspace_root,
-    )
-
-    # Determine store_path: workspace-based or legacy config-based
-    if workspace:
-        store_path = None  # Let repository resolve via workspace parameter
-    else:
-        store_path = config.vectorstore.persist_dir
-
-    if observable:
-        vector_repo = ObservableVectorStoreRepository(
-            store_path=store_path,
-            workspace=workspace,
-            ollama_host=config.ollama.host_url,
-            embedding_model=config.ollama.embedding_model,
-            batch_size=config.processing.batch_size
-            if hasattr(config.processing, "batch_size")
-            else 50,
-            collection_name=config.vectorstore.collection_name,
-            show_progress=True,
-        )
-    else:
-        vector_repo = VectorStoreRepository(
-            store_path=store_path,
-            workspace=workspace,
-            ollama_host=config.ollama.host_url,
-            embedding_model=config.ollama.embedding_model,
-            collection_name=config.vectorstore.collection_name,
-        )
-
-    return doc_repo, vector_repo
-
-
-def _get_workspace_index_paths(config, workspace_name: str) -> list:
-    """
-    Get index_paths for a workspace from config.
-
-    Args:
-        config: RAG configuration object
-        workspace_name: Workspace identifier
-
-    Returns:
-        List of paths to index, or empty list if not configured
-    """
-    # Check if workspaces config exists in raw config
-    config_manager = RAGConfigManager()
-    config_path = config_manager._config_path
-
-    if not config_path:
-        return []
-
-    import yaml
-
-    with open(config_path, "r") as f:
-        raw_config = yaml.safe_load(f)
-
-    workspaces = raw_config.get("rag", {}).get("workspaces", {})
-    workspace_config = workspaces.get(workspace_name, {})
-
-    return workspace_config.get("index_paths", [])
-
-
-def execute_index(
-    data_dir: str,
-    workspace_name: str,
-    domain_filter: str,
-    clear_cache: bool,
-    verbose: bool,
-    toon: bool = False,
-    force: bool = False,
-) -> int:
-    """
-    Execute index command.
-
-    Args:
-        data_dir: Directory to index (optional if workspace has index_paths)
-        workspace_name: Workspace identifier for per-workspace RAG isolation
-        domain_filter: Optional domain filter
-        clear_cache: Clear existing index before indexing
-        verbose: Enable verbose output (--verbose flag)
-        toon: Force TOON output (--toon flag)
-        force: Skip .gitignore confirmation and use fallback patterns
-
-    Returns:
-        Exit code (0 for success, 1 for failure)
-    """
-    # Detect output mode
-    mode = detect_output_mode(verbose=verbose, toon=toon)
-
-    if mode == OutputMode.LEGACY:
-        return _execute_index_verbose(
-            data_dir, workspace_name, domain_filter, clear_cache, force
-        )
-    elif mode == OutputMode.TOON:
-        return _execute_index_toon(
-            data_dir, workspace_name, domain_filter, clear_cache, force
-        )
-    else:
-        # MODERN - Rich Live UI
-        return _execute_index_with_ui(
-            data_dir, workspace_name, domain_filter, clear_cache, force
-        )
-
-
-def _execute_index_verbose(
-    data_dir: str,
-    workspace_name: str,
-    domain_filter: str,
-    clear_cache: bool,
-    force: bool = False,
-) -> int:
-    """Execute index with verbose logging."""
-    try:
-        start_time = time.time()
-        config_manager = RAGConfigManager()
-        config = config_manager.load_config()
-
-        # Determine paths to index
-        if data_dir:
-            paths_to_index = [data_dir]
-        elif workspace_name:
-            relative_paths = _get_workspace_index_paths(config, workspace_name)
-            if not relative_paths:
-                logger.error(
-                    f"No index_paths configured for workspace '{workspace_name}' in rag.yaml"
-                )
-                return 1
-
-            # Resolve relative paths to absolute paths using workspace root
-            from scripts.managers.workspace_path_manager import get_workspace_path
-
-            workspace_root = get_workspace_path(workspace_name)
-            if not workspace_root:
-                logger.error(
-                    f"Workspace '{workspace_name}' not found in workspace_paths.yaml"
-                )
-                return 1
-
-            workspace_root_path = Path(workspace_root)
-            paths_to_index = []
-
-            logger.info(
-                f"Resolving {len(relative_paths)} index paths for workspace {workspace_name}"
-            )
-            logger.info(f"Workspace root: {workspace_root_path}")
-
-            for i, rel_path in enumerate(relative_paths, 1):
-                # Clean relative path (remove trailing slashes)
-                clean_rel_path = rel_path.rstrip("/")
-
-                if clean_rel_path.startswith("*"):
-                    # Glob pattern - keep relative to workspace root for later resolution
-                    full_path = str(workspace_root_path / clean_rel_path)
-                    logger.info(f"  {i}. Glob pattern: {rel_path} → {full_path}")
-                else:
-                    # Directory path - resolve relative to workspace root
-                    full_path = str(workspace_root_path / clean_rel_path)
-                    # Verify the resolved path exists
-                    resolved_path = Path(full_path)
-                    if resolved_path.exists():
-                        logger.info(f"  {i}. Directory: {rel_path} → {full_path} ✅")
-                    else:
-                        logger.warning(
-                            f"  {i}. Directory: {rel_path} → {full_path} ❌ (not found)"
-                        )
-
-                paths_to_index.append(full_path)
-
-            logger.info(
-                f"Using configured index_paths for {workspace_name}: {relative_paths}"
-            )
-            logger.info(f"Resolved to absolute paths: {paths_to_index}")
-        else:
-            logger.error(
-                "Either --data-dir or --workspace-name with configured index_paths required"
-            )
-            return 1
-
-        # SIMPLIFIED FIX: Just check if workspace root has .gitignore
-        if workspace_name and workspace_root:
-            workspace_gitignore = Path(workspace_root) / ".gitignore"
-            if not workspace_gitignore.exists():
-                logger.warning(
-                    f"No .gitignore found in workspace root: {workspace_root}"
-                )
-                if not force:
-                    logger.error("Use --force to proceed with config fallback patterns")
-                    return 1
-                logger.info(
-                    "--force flag set, using config/rag.yaml exclusion patterns as fallback"
-                )
-            else:
-                logger.info(
-                    f"✅ Using .gitignore from workspace: {workspace_gitignore}"
-                )
-                # Skip gitignore check for data_dir mode - let the loader handle it
-                if suggestions:
-                    logger.warning(
-                        f"Found {len(suggestions)} potentially excludable directories:"
-                    )
-                    for s in suggestions:
-                        logger.warning(
-                            f"  - {s.path.name}: {s.reason} ({s.size_estimate})"
-                        )
-                if not force:
-                    logger.error("Use --force to proceed with config fallback patterns")
-                    return 1
-                logger.info(
-                    "--force flag set, using config/rag.yaml exclusion patterns as fallback"
-                )
-        else:
-            # Fallback for data_dir mode - check each path individually
-            for path in paths_to_index:
-                has_gitignore, suggestions = check_workspace_gitignore(path)
-                if not has_gitignore:
-                    logger.warning(f"No .gitignore found in {path}")
-                    if suggestions:
-                        logger.warning(
-                            f"Found {len(suggestions)} potentially excludable directories:"
-                        )
-                        for s in suggestions:
-                            logger.warning(
-                                f"  - {s.path.name}: {s.reason} ({s.size_estimate})"
-                            )
-                    if not force:
-                        logger.error(
-                            "Use --force to proceed with config fallback patterns"
-                        )
-                        return 1
-                    logger.info(
-                        "--force flag set, using config/rag.yaml exclusion patterns as fallback"
-                    )
-
-        doc_repo, vector_repo = create_repositories(
-            config,
-            observable=True,
-            workspace=workspace_name,
-            data_dir=paths_to_index[0] if paths_to_index else data_dir,
-            workspace_root=workspace_root,
-        )
-
-        use_case = IndexCodeUseCase(
-            document_repository=doc_repo,
-            vector_store_repository=vector_repo,
-        )
-
-        total_docs = 0
-        total_chunks = 0
-
-        for i, path in enumerate(paths_to_index):
-            should_clear = clear_cache and i == 0
-            logger.info(f"Indexing path {i + 1}/{len(paths_to_index)}: {path}")
-
-            result = use_case.execute(
-                data_path=path,
-                workspace_name=workspace_name,
-                domain_name=domain_filter,
-                clear_existing=should_clear,
-            )
-
-            total_docs += result.get("documents_indexed", 0)
-            total_chunks += result.get("chunks_created", 0)
-
-        elapsed_time = time.time() - start_time
-
-        logger.info("=" * 60)
-        logger.info("INDEXING COMPLETE")
-        logger.info("=" * 60)
-        logger.info(f"Paths indexed: {len(paths_to_index)}")
-        logger.info(f"Documents indexed: {total_docs}")
-        logger.info(f"Chunks created: {total_chunks}")
-        logger.info(f"Workspace: {workspace_name}")
-        logger.info(f"Domain: {domain_filter or 'all'}")
-        logger.info(f"Time: {elapsed_time:.2f}s")
-        logger.info("=" * 60)
-
-        return 0
-
-    except Exception as e:
-        logger.error(f"Indexing failed: {e}")
-        return 1
-
-
-def _execute_index_toon(
-    data_dir: str,
-    workspace_name: str,
-    domain_filter: str,
-    clear_cache: bool,
-    force: bool = False,
-) -> int:
-    """
-    Execute index with TOON output for LLM agents.
-
-    TOON format is token-efficient and easy to parse:
-    - ok:rag:index:workspace:JARVIS:paths:5:files:127:chunks:892:time:45.2s
-    - error:rag:index:reason:connection_timeout
-    - warn:rag:index:no_gitignore:/path/to/project
-
-    When no .gitignore is found and --force is not set, returns error
-    requiring user/agent to explicitly confirm with --force.
-    """
-    import warnings
-
-    try:
-        start_time = time.time()
-        config_manager = RAGConfigManager()
-        config = config_manager.load_config()
-
-        # Determine paths to index
-        if data_dir:
-            paths_to_index = [data_dir]
-        elif workspace_name:
-            paths_to_index = _get_workspace_index_paths(config, workspace_name)
-            if not paths_to_index:
-                toon_error("rag", "index", "no_index_paths", workspace=workspace_name)
-                return 1
-        else:
-            toon_error("rag", "index", "missing_args", hint="need -d or -w")
-            return 1
-
-        # Check for .gitignore in target workspace BEFORE suppressing logs
-        for path in paths_to_index:
-            has_gitignore, suggestions = check_workspace_gitignore(path)
-            if not has_gitignore:
-                should_proceed = show_exclusion_suggestions_toon(
-                    suggestions, path, force
-                )
-                if not should_proceed:
-                    return 1  # Abort - agent needs to use --force or create .gitignore
-
-        # Now suppress logging for clean TOON output during indexing
-        logging.disable(logging.CRITICAL)
-        warnings.filterwarnings("ignore")
-
-        doc_repo, vector_repo = create_repositories(
-            config,
-            observable=False,  # No progress bars for TOON
-            workspace=workspace_name,
-            data_dir=paths_to_index[0] if paths_to_index else data_dir,
-        )
-
-        use_case = IndexCodeUseCase(
-            document_repository=doc_repo,
-            vector_store_repository=vector_repo,
-        )
-
-        total_docs = 0
-        total_chunks = 0
-
-        for i, path in enumerate(paths_to_index):
-            should_clear = clear_cache and i == 0
-
-            result = use_case.execute(
-                data_path=path,
-                workspace_name=workspace_name,
-                domain_name=domain_filter,
-                clear_existing=should_clear,
-            )
-
-            total_docs += result.get("documents_indexed", 0)
-            total_chunks += result.get("chunks_created", 0)
-
-        elapsed_time = time.time() - start_time
-
-        # Single-line TOON output
-        toon_ok(
-            "rag",
-            "index",
-            workspace=workspace_name,
-            paths=len(paths_to_index),
-            files=total_docs,
-            chunks=total_chunks,
-            time=f"{elapsed_time:.1f}s",
-        )
-
-        return 0
-
-    except Exception as e:
-        toon_error("rag", "index", str(e)[:30])
-        return 1
-
-
-def _execute_index_with_ui(
-    data_dir: str,
-    workspace_name: str,
-    domain_filter: str,
-    clear_cache: bool,
-    force: bool = False,
-) -> int:
-    """Execute index with modern Rich UI."""
-    import threading
-    import queue
-    import warnings
-
-    from src.shared.ui.rag_ui import RAGIndexingUI
-
-    ui = RAGIndexingUI()
-
-    try:
-        config_manager = RAGConfigManager()
-        config = config_manager.load_config()
-
-        # Determine paths to index
-        if data_dir:
-            paths_to_index = [data_dir]
-        elif workspace_name:
-            paths_to_index = _get_workspace_index_paths(config, workspace_name)
-            if not paths_to_index:
-                ui.console.print(
-                    f"[red]No index_paths configured for workspace '{workspace_name}'[/red]"
-                )
-                return 1
-        else:
-            ui.console.print(
-                "[red]Either --data-dir or --workspace-name required[/red]"
-            )
-            return 1
-
-        # Check for .gitignore in target workspace BEFORE suppressing logs
-        # In UI mode, user can interactively choose what to do
-        for path in paths_to_index:
-            has_gitignore, suggestions = check_workspace_gitignore(path)
-            if not has_gitignore:
-                proceed, created_gitignore = show_exclusion_suggestions_modern(
-                    suggestions, path, force
-                )
-                if not proceed:
-                    return 1  # User chose to abort
-                if created_gitignore:
-                    # Reload gitignore patterns since we just created the file
-                    pass  # The loader will pick up the new file
-
-        # Now suppress logging for clean UI
-        logging.disable(logging.CRITICAL)
-        warnings.filterwarnings("ignore")
-
-        with ui.live_progress(workspace_name or "default", paths_to_index) as session:
-            for i, path in enumerate(paths_to_index):
-                session.start_path(path)
-                ui.update()
-
-                # Run indexing in a thread
-                result_queue = queue.Queue()
-
-                def index_worker():
-                    # Ensure logging stays disabled in worker thread
-                    logging.disable(logging.CRITICAL)
-                    try:
-                        doc_repo, vector_repo = create_repositories(
-                            config,
-                            observable=True,
-                            workspace=workspace_name,
-                            data_dir=path,
-                        )
-
-                        use_case = IndexCodeUseCase(
-                            document_repository=doc_repo,
-                            vector_store_repository=vector_repo,
-                        )
-
-                        should_clear = clear_cache and i == 0
-
-                        result = use_case.execute(
-                            data_path=path,
-                            workspace_name=workspace_name,
-                            domain_name=domain_filter,
-                            clear_existing=should_clear,
-                        )
-
-                        result_queue.put(
-                            {
-                                "success": True,
-                                "docs": result.get("documents_indexed", 0),
-                                "chunks": result.get("chunks_created", 0),
-                            }
-                        )
-                    except Exception as e:
-                        result_queue.put(
-                            {
-                                "success": False,
-                                "error": str(e)[:30],
-                            }
-                        )
-
-                thread = threading.Thread(target=index_worker, daemon=True)
-                thread.start()
-
-                # Update UI while waiting
-                while thread.is_alive():
-                    ui.update()
-                    time.sleep(0.25)
-
-                thread.join()
-
-                # Get result
-                try:
-                    result = result_queue.get_nowait()
-                except queue.Empty:
-                    result = {"success": False, "error": "No response"}
-
-                if result["success"]:
-                    session.complete_path(path, result["docs"], result["chunks"])
-                else:
-                    session.fail_path(path, result.get("error", "Failed"))
-
-                ui.update()
-
-        # Final summary
-        ui.display_final_summary()
-
-        # TOON output
-        ui.console.print(
-            f"\n[dim]ok:indexed:{session.total_chunks}:paths:{session.completed_count}:"
-            f"time:{session.elapsed:.1f}s[/dim]"
-        )
-
-        return 0 if session.failed_count == 0 else 1
-
-    except Exception as e:
-        ui.console.print(f"[red]Indexing failed: {e}[/red]")
-        return 1
-
-
-def execute_update(
-    file_path: str, verbose: bool, workspace_name: str = None, toon: bool = False
-) -> int:
-    """
-    Update individual file in RAG index.
-
-    Args:
-        file_path: Path to file to update
-        verbose: Enable verbose output (--verbose flag)
-        workspace_name: Workspace identifier (required or auto-detected from path)
-        toon: Force TOON output (--toon flag)
-
-    Returns:
-        Exit code (0 for success, 1 for failure)
-    """
-    mode = detect_output_mode(verbose=verbose, toon=toon)
-
-    if mode == OutputMode.LEGACY:
-        return _execute_update_legacy(file_path, workspace_name)
-    elif mode == OutputMode.TOON:
-        return _execute_update_toon(file_path, workspace_name)
-    else:
-        return _execute_update_modern(file_path, workspace_name)
-
-
-def _execute_update_core(file_path: str, workspace_name: str = None):
-    """
-    Core update logic shared by all modes.
-
-    Returns:
-        Tuple of (success: bool, result: dict, error: str or None)
-    """
-    import warnings
-
-    logging.disable(logging.CRITICAL)
-    warnings.filterwarnings("ignore")
-
-    try:
-        file_path = Path(file_path).resolve()
-
-        if not file_path.exists():
-            return False, {}, f"File not found: {file_path.name}"
-
-        hierarchy_info = HierarchicalDomainInference.parse_path_hierarchy(
-            str(file_path)
-        )
-        workspace = (
-            workspace_name if workspace_name else hierarchy_info["workspace_name"]
-        )
-        domain = hierarchy_info["domain_name"]
-
-        config_manager = RAGConfigManager()
-        config = config_manager.load_config()
-
-        doc_repo, vector_repo = create_repositories(
-            config,
-            observable=False,
-            use_gitignore=False,
-            workspace=workspace,
-            data_dir=str(file_path),
-        )
-
-        vector_repo.load_or_create([])
-
-        file_ext = file_path.suffix
-
-        if file_ext not in doc_repo.FILE_LOADERS:
-            return False, {}, f"Unsupported file type: {file_ext}"
-
-        loader_cls = doc_repo.FILE_LOADERS[file_ext]
-        loader = loader_cls(str(file_path))
-        docs = list(loader.lazy_load())
-
-        if not docs:
-            return (
-                True,
-                {
-                    "deleted": 0,
-                    "added": 0,
-                    "file": file_path.name,
-                    "workspace": workspace,
-                },
-                None,
-            )
-
-        for doc in docs:
-            doc.metadata["file_type"] = file_ext.lstrip(".")
-            doc.metadata["workspace_name"] = workspace
-            doc.metadata["domain_name"] = domain
-            doc.metadata["source"] = str(file_path)
-
-        content = docs[0].page_content if hasattr(docs[0], "page_content") else None
-        text_splitter = doc_repo._get_splitter_for_extension(file_ext, content)
-        chunks = text_splitter.split_documents(docs)
-
-        if hasattr(vector_repo, "update_file"):
-            result = vector_repo.update_file(str(file_path), chunks)
-            deleted = result["deleted"]
-            added = result["added"]
-        else:
-            deleted = vector_repo.delete_by_source(str(file_path))
-            added = 0
-            if chunks:
-                vector_repo.index_chunks(chunks)
-                added = len(chunks)
-
-        return (
-            True,
-            {
-                "deleted": deleted,
-                "added": added,
-                "file": file_path.name,
-                "workspace": workspace,
-            },
-            None,
-        )
-
-    except Exception as e:
-        return False, {}, str(e)[:50]
-
-
-def _execute_update_legacy(file_path: str, workspace_name: str = None) -> int:
-    """Execute update with legacy verbose logging."""
-    logging.disable(logging.NOTSET)
-
-    success, result, error = _execute_update_core(file_path, workspace_name)
-
-    if not success:
-        logger.error(f"Update failed: {error}")
-        return 1
-
-    logger.info(
-        f"Successfully updated {result['file']}: deleted {result['deleted']}, added {result['added']} chunks"
-    )
-    return 0
-
-
-def _execute_update_toon(file_path: str, workspace_name: str = None) -> int:
-    """Execute update with TOON output for LLM agents."""
-    success, result, error = _execute_update_core(file_path, workspace_name)
-
-    if not success:
-        toon_error("rag", "update", error)
-        return 1
-
-    toon_ok(
-        "rag",
-        "update",
-        file=result["file"],
-        deleted=result["deleted"],
-        added=result["added"],
-    )
-    return 0
-
-
-def _execute_update_modern(file_path: str, workspace_name: str = None) -> int:
-    """Execute update with modern Rich UI."""
-    from rich.console import Console
-    from rich.panel import Panel
-
-    console = Console()
-    success, result, error = _execute_update_core(file_path, workspace_name)
-
-    if not success:
-        console.print(
-            Panel(
-                f"[red]Update failed:[/red] {error}",
-                title="[bold red]Error[/bold red]",
-                border_style="red",
-            )
-        )
-        return 1
-
-    console.print(
-        Panel(
-            f"[green]✓[/green] Updated [bold]{result['file']}[/bold]\n\n"
-            f"  [dim]Workspace:[/dim] {result['workspace']}\n"
-            f"  [dim]Deleted:[/dim]   {result['deleted']} chunks\n"
-            f"  [dim]Added:[/dim]     {result['added']} chunks",
-            title="[bold green]File Updated[/bold green]",
-            border_style="green",
-        )
-    )
-    return 0
-
-
-def execute_delete(
-    file_path: str, verbose: bool, workspace_name: str = None, toon: bool = False
-) -> int:
-    """
-    Delete file from RAG index.
-
-    Args:
-        file_path: Path to file to delete
-        verbose: Enable verbose output (--verbose flag)
-        workspace_name: Workspace identifier (required or auto-detected from path)
-        toon: Force TOON output (--toon flag)
-
-    Returns:
-        Exit code (0 for success, 1 for failure)
-    """
-    mode = detect_output_mode(verbose=verbose, toon=toon)
-
-    if mode == OutputMode.LEGACY:
-        return _execute_delete_legacy(file_path, workspace_name)
-    elif mode == OutputMode.TOON:
-        return _execute_delete_toon(file_path, workspace_name)
-    else:
-        return _execute_delete_modern(file_path, workspace_name)
-
-
-def _execute_delete_core(file_path: str, workspace_name: str = None):
-    """
-    Core delete logic shared by all modes.
-
-    Returns:
-        Tuple of (success: bool, result: dict, error: str or None)
-    """
-    import warnings
-
-    logging.disable(logging.CRITICAL)
-    warnings.filterwarnings("ignore")
-
-    try:
-        file_path = Path(file_path).resolve()
-
-        hierarchy_info = HierarchicalDomainInference.parse_path_hierarchy(
-            str(file_path)
-        )
-        workspace = (
-            workspace_name if workspace_name else hierarchy_info["workspace_name"]
-        )
-
-        config_manager = RAGConfigManager()
-        config = config_manager.load_config()
-
-        _, vector_repo = create_repositories(
-            config, observable=False, workspace=workspace
-        )
-        vector_repo.load_or_create([])
-
-        deleted_count = vector_repo.delete_by_source(str(file_path))
-
-        return (
-            True,
-            {"deleted": deleted_count, "file": file_path.name, "workspace": workspace},
-            None,
-        )
-
-    except Exception as e:
-        return False, {}, str(e)[:50]
-
-
-def _execute_delete_legacy(file_path: str, workspace_name: str = None) -> int:
-    """Execute delete with legacy verbose logging."""
-    logging.disable(logging.NOTSET)
-
-    success, result, error = _execute_delete_core(file_path, workspace_name)
-
-    if not success:
-        logger.error(f"Delete failed: {error}")
-        return 1
-
-    if result["deleted"] > 0:
-        logger.info(
-            f"Successfully deleted {result['file']}: removed {result['deleted']} chunks"
-        )
-    else:
-        logger.warning(f"No chunks found for {result['file']}")
-    return 0
-
-
-def _execute_delete_toon(file_path: str, workspace_name: str = None) -> int:
-    """Execute delete with TOON output for LLM agents."""
-    success, result, error = _execute_delete_core(file_path, workspace_name)
-
-    if not success:
-        toon_error("rag", "delete", error)
-        return 1
-
-    toon_ok("rag", "delete", file=result["file"], chunks=result["deleted"])
-    return 0
-
-
-def _execute_delete_modern(file_path: str, workspace_name: str = None) -> int:
-    """Execute delete with modern Rich UI."""
-    from rich.console import Console
-    from rich.panel import Panel
-
-    console = Console()
-    success, result, error = _execute_delete_core(file_path, workspace_name)
-
-    if not success:
-        console.print(
-            Panel(
-                f"[red]Delete failed:[/red] {error}",
-                title="[bold red]Error[/bold red]",
-                border_style="red",
-            )
-        )
-        return 1
-
-    if result["deleted"] > 0:
-        console.print(
-            Panel(
-                f"[green]✓[/green] Deleted [bold]{result['file']}[/bold]\n\n"
-                f"  [dim]Workspace:[/dim] {result['workspace']}\n"
-                f"  [dim]Removed:[/dim]   {result['deleted']} chunks",
-                title="[bold green]File Deleted[/bold green]",
-                border_style="green",
-            )
-        )
-    else:
-        console.print(
-            Panel(
-                f"[yellow]![/yellow] No chunks found for [bold]{result['file']}[/bold]\n\n"
-                f"  [dim]Workspace:[/dim] {result['workspace']}\n"
-                f"  [dim]Note:[/dim] File may not be indexed",
-                title="[bold yellow]Nothing Deleted[/bold yellow]",
-                border_style="yellow",
-            )
-        )
-    return 0
-
-
-def execute_batch_update(
-    patterns: tuple, verbose: bool, workspace_name: str = None, toon: bool = False
-) -> int:
-    """
-    Update multiple files in RAG index.
-
-    Args:
-        patterns: File patterns to match
-        verbose: Enable verbose output (--verbose flag)
-        workspace_name: Workspace identifier for per-workspace RAG isolation.
-                       All files in batch should belong to same workspace.
-        toon: Force TOON output (--toon flag)
-
-    Returns:
-        Exit code (0 for success, 1 for failure)
-    """
-    mode = detect_output_mode(verbose=verbose, toon=toon)
-
-    if mode == OutputMode.LEGACY:
-        return _execute_batch_update_legacy(patterns, workspace_name)
-    elif mode == OutputMode.TOON:
-        return _execute_batch_update_toon(patterns, workspace_name)
-    else:
-        return _execute_batch_update_modern(patterns, workspace_name)
-
-
-def _execute_batch_update_core(
-    patterns: tuple, workspace_name: str = None, on_file_complete=None
-):
-    """
-    Core batch update logic shared by all modes.
-
-    Args:
-        patterns: File patterns to match
-        workspace_name: Workspace identifier
-        on_file_complete: Optional callback(file_name, deleted, added) for progress
-
-    Returns:
-        Tuple of (success: bool, result: dict, error: str or None)
-    """
-    import glob as glob_module
-    import warnings
-
-    logging.disable(logging.CRITICAL)
-    warnings.filterwarnings("ignore")
-
-    try:
-        files = []
-        for pattern in patterns:
-            files.extend(glob_module.glob(pattern, recursive=True))
-
-        if not files:
-            return False, {}, "No files matched the patterns"
-
-        first_file = Path(files[0]).resolve()
-        hierarchy_info = HierarchicalDomainInference.parse_path_hierarchy(
-            str(first_file)
-        )
-        workspace = (
-            workspace_name if workspace_name else hierarchy_info["workspace_name"]
-        )
-
-        config_manager = RAGConfigManager()
-        config = config_manager.load_config()
-
-        doc_repo, vector_repo = create_repositories(
-            config,
-            observable=False,
-            use_gitignore=False,
-            workspace=workspace,
-            data_dir=str(first_file),
-        )
-
-        vector_repo.load_or_create([])
-
-        total_deleted = 0
-        total_added = 0
-        processed_files = []
-
-        for file_path in files:
-            file_path = Path(file_path).resolve()
-
-            if not file_path.exists() or not file_path.is_file():
-                continue
-
-            hierarchy_info = HierarchicalDomainInference.parse_path_hierarchy(
-                str(file_path)
-            )
-            ws = workspace_name if workspace_name else hierarchy_info["workspace_name"]
-
-            deleted = vector_repo.delete_by_source(str(file_path))
-            total_deleted += deleted
-            added = 0
-
-            file_ext = file_path.suffix
-
-            if file_ext in doc_repo.FILE_LOADERS:
-                loader_cls = doc_repo.FILE_LOADERS[file_ext]
-                loader = loader_cls(str(file_path))
-                docs = list(loader.lazy_load())
-
-                if docs:
-                    for doc in docs:
-                        doc.metadata["file_type"] = file_ext.lstrip(".")
-                        doc.metadata["workspace_name"] = ws
-                        doc.metadata["domain_name"] = hierarchy_info["domain_name"]
-                        doc.metadata["source"] = str(file_path)
-
-                    content = (
-                        docs[0].page_content
-                        if hasattr(docs[0], "page_content")
-                        else None
-                    )
-                    text_splitter = doc_repo._get_splitter_for_extension(
-                        file_ext, content
-                    )
-                    chunks = text_splitter.split_documents(docs)
-
-                    if chunks:
-                        vector_repo.index_chunks(chunks)
-                        added = len(chunks)
-                        total_added += added
-
-            processed_files.append(
-                {"file": file_path.name, "deleted": deleted, "added": added}
-            )
-
-            if on_file_complete:
-                on_file_complete(file_path.name, deleted, added)
-
-        return (
-            True,
-            {
-                "files": len(processed_files),
-                "deleted": total_deleted,
-                "added": total_added,
-                "workspace": workspace,
-                "details": processed_files,
-            },
-            None,
-        )
-
-    except Exception as e:
-        return False, {}, str(e)[:50]
-
-
-def _execute_batch_update_legacy(patterns: tuple, workspace_name: str = None) -> int:
-    """Execute batch update with legacy verbose logging."""
-    logging.disable(logging.NOTSET)
-
-    def on_file(name, deleted, added):
-        logger.info(f"  {name}: -{deleted} +{added}")
-
-    logger.info(f"Starting batch update...")
-    success, result, error = _execute_batch_update_core(
-        patterns, workspace_name, on_file
-    )
-
-    if not success:
-        logger.error(f"Batch update failed: {error}")
-        return 1
-
-    logger.info(
-        f"Batch update complete: {result['deleted']} deleted, {result['added']} added"
-    )
-    return 0
-
-
-def _execute_batch_update_toon(patterns: tuple, workspace_name: str = None) -> int:
-    """Execute batch update with TOON output for LLM agents."""
-    success, result, error = _execute_batch_update_core(patterns, workspace_name)
-
-    if not success:
-        toon_error("rag", "batch", error)
-        return 1
-
-    toon_ok(
-        "rag",
-        "batch",
-        files=result["files"],
-        deleted=result["deleted"],
-        added=result["added"],
-        workspace=result["workspace"],
-    )
-    return 0
-
-
-def _execute_batch_update_modern(patterns: tuple, workspace_name: str = None) -> int:
-    """Execute batch update with modern Rich UI."""
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.table import Table
-    from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
-
-    console = Console()
-
-    # First, collect files
-    import glob as glob_module
-
-    files = []
-    for pattern in patterns:
-        files.extend(glob_module.glob(pattern, recursive=True))
-
-    if not files:
-        console.print(
-            Panel(
-                "[yellow]No files matched the patterns[/yellow]",
-                title="[bold yellow]Warning[/bold yellow]",
-                border_style="yellow",
-            )
-        )
-        return 1
-
-    console.print(
-        Panel(
-            f"[cyan]Batch updating [bold]{len(files)}[/bold] files...[/cyan]",
-            border_style="cyan",
-        )
-    )
-
-    # Run the update
-    success, result, error = _execute_batch_update_core(patterns, workspace_name)
-
-    if not success:
-        console.print(
-            Panel(
-                f"[red]Batch update failed:[/red] {error}",
-                title="[bold red]Error[/bold red]",
-                border_style="red",
-            )
-        )
-        return 1
-
-    # Build results table
-    table = Table(
-        show_header=True,
-        header_style="bold cyan",
-        border_style="dim",
-    )
-    table.add_column("File", style="white", max_width=40)
-    table.add_column("Deleted", justify="right", style="red")
-    table.add_column("Added", justify="right", style="green")
-
-    # Show top 10 files + summary
-    details = result.get("details", [])
-    for item in details[:10]:
-        table.add_row(
-            item["file"][:38] + ".." if len(item["file"]) > 40 else item["file"],
-            str(item["deleted"]),
-            str(item["added"]),
-        )
-
-    if len(details) > 10:
-        table.add_row(
-            f"[dim]... and {len(details) - 10} more files[/dim]",
-            "",
-            "",
-        )
-
-    console.print(table)
-    console.print()
-
-    console.print(
-        Panel(
-            f"[green]✓[/green] Batch update complete\n\n"
-            f"  [dim]Workspace:[/dim] {result['workspace']}\n"
-            f"  [dim]Files:[/dim]     {result['files']}\n"
-            f"  [dim]Deleted:[/dim]   {result['deleted']} chunks\n"
-            f"  [dim]Added:[/dim]     {result['added']} chunks",
-            title="[bold green]Summary[/bold green]",
-            border_style="green",
-        )
-    )
-    return 0