@mc1global/opencode-jarvis 0.13.1 → 0.14.0

package/scripts/rag/rag_config_v2.py

@@ -1,377 +0,0 @@
-#!/usr/bin/env python3
-"""
-RAG Configuration Manager V2 - Workspace-Aware
-
-Loads and validates RAG configuration from workspace-local YAML files.
-Supports the new config|db|obsidian workspace structure.
-
-Type Hints: Required (mypy compliant)
-Docstring: Google format
-Max Lines: 400
-"""
-
-import logging
-import sys
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
-
-import yaml
-from pydantic import BaseModel, Field, field_validator
-
-# Add project root to path for imports
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-from src.shared.workspace_paths import WorkspacePathRegistry
-from src.shared.workspace_ollama_config import (
-    load_workspace_rag_config,
-    get_workspace_chroma_settings,
-)
-
-logger = logging.getLogger(__name__)
-
-
-# ===== Pydantic Models for Configuration Validation =====
-
-
-class OllamaConfig(BaseModel):
-    """Ollama service configuration (global)."""
-
-    host_url: str = Field(default="http://localhost:11434")
-    llm_model: str = Field(default="llama3.2:3b")
-    embedding_model: str = Field(default="embeddinggemma")
-    temperature: float = Field(default=0.0, ge=0.0, le=2.0)
-    timeout: int = Field(default=30, ge=1)
-
-
-class IndexingConfig(BaseModel):
-    """Workspace-specific indexing configuration."""
-
-    base_path: str = Field(default=".")
-    include_paths: List[str] = Field(
-        default_factory=lambda: ["src/", "docs/", "scripts/"]
-    )
-    exclude_patterns: List[str] = Field(
-        default_factory=lambda: [
-            "*.pyc",
-            "__pycache__/",
-            ".git/",
-            "node_modules/",
-            ".venv/",
-            "*.log",
-        ]
-    )
-
-
-class ChunkingConfig(BaseModel):
-    """Text chunking configuration."""
-
-    chunk_size: int = Field(default=1000, ge=100, le=4000)
-    chunk_overlap: int = Field(default=200, ge=0, le=1000)
-
-
-class VectorstoreConfig(BaseModel):
-    """Vector store configuration (workspace-specific)."""
-
-    type: str = Field(default="chroma")
-    path: str = Field(default="db/chroma_db")
-    collection_name: str = Field(default="workspace_docs")
-
-
-class WorkspaceRAGConfig(BaseModel):
-    """Complete RAG configuration for a workspace."""
-
-    enabled: bool = Field(default=True)
-    indexing: IndexingConfig = Field(default_factory=IndexingConfig)
-    chunking: ChunkingConfig = Field(default_factory=ChunkingConfig)
-    vectorstore: VectorstoreConfig = Field(default_factory=VectorstoreConfig)
-
-
-class RAGConfigManagerV2:
-    """
-    Workspace-aware RAG configuration manager.
-
-    Loads configuration from workspace-local config files and provides
-    validated configuration objects for RAG operations.
-    """
-
-    def __init__(self):
-        """Initialize RAG configuration manager."""
-        self._config_cache: Dict[str, WorkspaceRAGConfig] = {}
-
-    def load_workspace_config(self, workspace: str) -> WorkspaceRAGConfig:
-        """
-        Load and validate RAG configuration for a workspace.
-
-        Args:
-            workspace: Workspace name
-
-        Returns:
-            Validated WorkspaceRAGConfig object
-
-        Raises:
-            FileNotFoundError: If config file not found
-            ValueError: If configuration is invalid
-        """
-        if workspace in self._config_cache:
-            return self._config_cache[workspace]
-
-        try:
-            # Load raw configuration
-            raw_config = load_workspace_rag_config(workspace)
-
-            # Create and validate configuration object
-            config = WorkspaceRAGConfig(**raw_config)
-
-            # Update vectorstore path to be absolute
-            if not Path(config.vectorstore.path).is_absolute():
-                chroma_dir = WorkspacePathRegistry.get_workspace_chroma_db_dir(
-                    workspace
-                )
-                config.vectorstore.path = str(chroma_dir)
-
-            # Update collection name to include workspace
-            if config.vectorstore.collection_name == "workspace_docs":
-                config.vectorstore.collection_name = f"{workspace.lower()}_docs"
-
-            self._config_cache[workspace] = config
-            return config
-
-        except Exception as e:
-            logger.error(f"Failed to load RAG config for workspace {workspace}: {e}")
-            raise ValueError(
-                f"Invalid RAG configuration for workspace {workspace}: {e}"
-            )
-
-    def get_indexing_config(self, workspace: str) -> IndexingConfig:
-        """
-        Get indexing configuration for workspace.
-
-        Args:
-            workspace: Workspace name
-
-        Returns:
-            IndexingConfig object
-        """
-        config = self.load_workspace_config(workspace)
-        return config.indexing
-
-    def get_chunking_config(self, workspace: str) -> ChunkingConfig:
-        """
-        Get chunking configuration for workspace.
-
-        Args:
-            workspace: Workspace name
-
-        Returns:
-            ChunkingConfig object
-        """
-        config = self.load_workspace_config(workspace)
-        return config.chunking
-
-    def get_vectorstore_config(self, workspace: str) -> VectorstoreConfig:
-        """
-        Get vectorstore configuration for workspace.
-
-        Args:
-            workspace: Workspace name
-
-        Returns:
-            VectorstoreConfig object
-        """
-        config = self.load_workspace_config(workspace)
-        return config.vectorstore
-
-    def get_workspace_base_path(self, workspace: str) -> Path:
-        """
-        Get base path for indexing operations.
-
-        Args:
-            workspace: Workspace name
-
-        Returns:
-            Absolute path to workspace base directory
-        """
-        from scripts.managers.workspace_path_manager_v2 import WorkspacePathManagerV2
-
-        path_manager = WorkspacePathManagerV2()
-        workspace_path = path_manager.get_workspace_path(workspace)
-
-        if workspace_path:
-            return workspace_path
-        else:
-            # Fallback to workspace directory
-            return WorkspacePathRegistry.get_workspace_base_path(workspace)
-
-    def get_include_paths(self, workspace: str) -> List[Path]:
-        """
-        Get absolute include paths for workspace indexing.
-
-        Args:
-            workspace: Workspace name
-
-        Returns:
-            List of absolute paths to include in indexing
-        """
-        config = self.get_indexing_config(workspace)
-        base_path = self.get_workspace_base_path(workspace)
-
-        include_paths = []
-        for path_str in config.include_paths:
-            path = Path(path_str)
-            if path.is_absolute():
-                include_paths.append(path)
-            else:
-                include_paths.append(base_path / path)
-
-        return include_paths
-
-    def get_chroma_db_path(self, workspace: str) -> Path:
-        """
-        Get ChromaDB database path for workspace.
-
-        Args:
-            workspace: Workspace name
-
-        Returns:
-            Absolute path to ChromaDB directory
-        """
-        config = self.get_vectorstore_config(workspace)
-        return Path(config.path)
-
-    def is_workspace_indexing_enabled(self, workspace: str) -> bool:
-        """
-        Check if RAG indexing is enabled for workspace.
-
-        Args:
-            workspace: Workspace name
-
-        Returns:
-            True if indexing is enabled
-        """
-        try:
-            config = self.load_workspace_config(workspace)
-            return config.enabled
-        except Exception:
-            return False
-
-    def validate_workspace_config(self, workspace: str) -> Dict[str, Any]:
-        """
-        Validate workspace RAG configuration and return status.
-
-        Args:
-            workspace: Workspace name
-
-        Returns:
-            Validation status dict
-        """
-        status = {"workspace": workspace, "valid": False, "errors": [], "warnings": []}
-
-        try:
-            # Check if workspace exists
-            if not WorkspacePathRegistry.is_migrated_workspace(workspace):
-                status["errors"].append(
-                    f"Workspace {workspace} not migrated to new structure"
-                )
-                return status
-
-            # Load and validate configuration
-            config = self.load_workspace_config(workspace)
-
-            # Check paths exist
-            base_path = self.get_workspace_base_path(workspace)
-            if not base_path.exists():
-                status["errors"].append(f"Base path does not exist: {base_path}")
-
-            # Check include paths
-            include_paths = self.get_include_paths(workspace)
-            missing_paths = [p for p in include_paths if not p.exists()]
-            if missing_paths:
-                status["warnings"].extend(
-                    [f"Include path missing: {p}" for p in missing_paths]
-                )
-
-            # Check ChromaDB directory
-            chroma_path = self.get_chroma_db_path(workspace)
-            chroma_path.parent.mkdir(parents=True, exist_ok=True)
-
-            if not status["errors"]:
-                status["valid"] = True
-                status["config"] = config.model_dump()
-
-        except Exception as e:
-            status["errors"].append(str(e))
-
-        return status
-
-    def clear_cache(self, workspace: str = None):
-        """
-        Clear configuration cache.
-
-        Args:
-            workspace: Specific workspace to clear, or None for all
-        """
-        if workspace:
-            self._config_cache.pop(workspace, None)
-        else:
-            self._config_cache.clear()
-
-
-# Singleton instance for global access
-_rag_config_manager = RAGConfigManagerV2()
-
-
-# Convenience functions for backward compatibility
-def load_workspace_rag_config_validated(workspace: str) -> WorkspaceRAGConfig:
-    """Load workspace RAG config (backward compatibility)."""
-    return _rag_config_manager.load_workspace_config(workspace)
-
-
-def get_workspace_indexing_config(workspace: str) -> IndexingConfig:
-    """Get indexing config (backward compatibility)."""
-    return _rag_config_manager.get_indexing_config(workspace)
-
-
-def get_workspace_vectorstore_config(workspace: str) -> VectorstoreConfig:
-    """Get vectorstore config (backward compatibility)."""
-    return _rag_config_manager.get_vectorstore_config(workspace)
-
-
-if __name__ == "__main__":
-    """Command-line interface for testing."""
-    import argparse
-    import json
-
-    parser = argparse.ArgumentParser(description="RAG Configuration Manager V2")
-    parser.add_argument(
-        "command", choices=["validate", "config", "paths"], help="Command to execute"
-    )
-    parser.add_argument("--workspace", "-w", required=True, help="Workspace name")
-
-    args = parser.parse_args()
-
-    manager = RAGConfigManagerV2()
-
-    if args.command == "validate":
-        status = manager.validate_workspace_config(args.workspace)
-        print(json.dumps(status, indent=2, default=str))
-
-    elif args.command == "config":
-        try:
-            config = manager.load_workspace_config(args.workspace)
-            print(config.model_dump_json(indent=2))
-        except Exception as e:
-            print(f"Error: {e}")
-
-    elif args.command == "paths":
-        try:
-            base_path = manager.get_workspace_base_path(args.workspace)
-            include_paths = manager.get_include_paths(args.workspace)
-            chroma_path = manager.get_chroma_db_path(args.workspace)
-
-            print(f"Base path: {base_path}")
-            print(f"Include paths:")
-            for path in include_paths:
-                print(f"  - {path}")
-            print(f"ChromaDB path: {chroma_path}")
-        except Exception as e:
-            print(f"Error: {e}")

package/scripts/rag/rag_hook.py

@@ -1,46 +0,0 @@
-#!/usr/bin/env python3
-"""
-RAG Auto-Update Hook for Claude Code PostToolUse.
-
-Reads tool input from stdin (JSON) and updates RAG index for the modified file.
-"""
-
-import json
-import sys
-import subprocess
-from pathlib import Path
-
-def main():
-    """Process PostToolUse hook and update RAG."""
-    try:
-        # Read tool input from stdin
-        hook_data = json.load(sys.stdin)
-
-        # Extract file path from tool_input
-        tool_input = hook_data.get('tool_input', {})
-        file_path = tool_input.get('file_path')
-
-        if not file_path:
-            # No file path, skip update
-            sys.exit(0)
-
-        # Convert to absolute path
-        file_path = Path(file_path).resolve()
-
-        # Update RAG index for this file
-        result = subprocess.run(
-            ['python', 'scripts/rag/rag_update_file.py', str(file_path)],
-            capture_output=True,
-            text=True,
-            timeout=30
-        )
-
-        # Silent success (don't pollute output)
-        sys.exit(0)
-
-    except Exception:
-        # Silent failure (don't break Claude's flow)
-        sys.exit(0)
-
-if __name__ == "__main__":
-    main()

package/scripts/rag/rag_update_file.py

@@ -1,271 +0,0 @@
-#!/usr/bin/env python3
-"""
-RAG Update File - Atualização incremental de arquivo específico no RAG.
-
-Permite que agentes atualizem um único arquivo no índice RAG
-sem precisar reindexar todo o projeto.
-
-Usage:
-    python scripts/rag_update_file.py <filepath>
-    python scripts/rag_update_file.py src/domain/rag/services.py
-    python scripts/rag_update_file.py --delete src/old_file.py
-    
-Type Hints: Required (mypy compliant)
-Docstring: Google format
-Max Lines: 400
-"""
-
-import argparse
-import logging
-import os
-import sys
-from pathlib import Path
-from typing import Dict, List, Optional, Any
-
-# Add src to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from scripts.rag.rag_config import RAGConfigManager
-from src.infrastructure.rag.document_loader_repository import DocumentLoaderRepository
-from src.infrastructure.rag.vector_store_repository import VectorStoreRepository
-from src.domain.rag.services import ChunkingStrategy
-
-# Configure logging (will be adjusted based on verbose flag)
-logger = logging.getLogger(__name__)
-
-
-class FileRAGUpdater:
-    """Updates single files in the RAG vector store."""
-    
-    def __init__(self):
-        """Initialize the updater with repositories."""
-        # Load config
-        config_manager = RAGConfigManager()
-        self.config = config_manager.load_config()
-        
-        # Extract chunk sizes from config
-        # Initialize repositories with dynamic chunk sizing
-        self.doc_repo = DocumentLoaderRepository()
-        
-        self.vector_repo = VectorStoreRepository(
-            store_path=self.config.vectorstore.persist_dir,
-            ollama_host=self.config.ollama.host_url,
-            embedding_model=self.config.ollama.embedding_model
-        )
-        
-        # Ensure vector store is loaded
-        if os.path.exists(self.config.vectorstore.persist_dir):
-            self.vector_repo.load_or_create([])
-        else:
-            logger.warning("Vector store does not exist. Run full indexing first.")
-    
-    def update_file(self, filepath: str) -> Dict[str, int]:
-        """
-        Update a single file in the RAG index.
-        
-        Args:
-            filepath: Path to the file to update
-            
-        Returns:
-            Dictionary with update statistics
-            
-        Raises:
-            FileNotFoundError: If file doesn't exist
-            RuntimeError: If update fails
-        """
-        filepath = Path(filepath).resolve()
-        
-        if not filepath.exists():
-            raise FileNotFoundError(f"File not found: {filepath}")
-        
-        if not filepath.is_file():
-            raise ValueError(f"Path is not a file: {filepath}")
-        
-        logger.info(f"Updating file in RAG: {filepath}")
-        
-        try:
-            # Load and process the file
-            file_ext = filepath.suffix
-            
-            # Check if file type is supported
-            if file_ext not in self.doc_repo.FILE_LOADERS:
-                raise ValueError(f"Unsupported file type: {file_ext}")
-            
-            # Load the file
-            loader_cls = self.doc_repo.FILE_LOADERS[file_ext]
-            loader = loader_cls(str(filepath))
-            docs = list(loader.lazy_load())
-            
-            if not docs:
-                logger.warning(f"No content loaded from {filepath}")
-                return {'deleted': 0, 'added': 0}
-            
-            # Inject metadata
-            workspace_name = self._infer_workspace(filepath)
-            domain_name = self.doc_repo._infer_domain(str(filepath))
-            
-            for doc in docs:
-                doc.metadata['file_type'] = file_ext.lstrip('.')
-                doc.metadata['workspace_name'] = workspace_name
-                doc.metadata['domain_name'] = domain_name
-                doc.metadata['source'] = str(filepath)  # Ensure absolute path
-            
-            # Chunk the document
-            # Get content for minification detection
-            content = docs[0].page_content if hasattr(docs[0], 'page_content') else None
-            
-            text_splitter = self.doc_repo._get_splitter_for_extension(file_ext, content)
-            chunks = text_splitter.split_documents(docs)
-            
-            logger.info(f"Created {len(chunks)} chunks from {filepath.name}")
-            
-            # Update in vector store (atomic delete + add)
-            result = self.vector_repo.update_file(
-                source_path=str(filepath),
-                new_chunks=chunks
-            )
-            
-            logger.info(
-                f"✅ Successfully updated {filepath.name}: "
-                f"deleted {result['deleted']}, added {result['added']} chunks"
-            )
-            
-            return result
-            
-        except Exception as e:
-            logger.error(f"Failed to update file: {e}")
-            raise RuntimeError(f"Update failed: {e}")
-    
-    def delete_file(self, filepath: str) -> int:
-        """
-        Delete a file from the RAG index.
-        
-        Args:
-            filepath: Path to the file to delete
-            
-        Returns:
-            Number of chunks deleted
-        """
-        filepath = Path(filepath).resolve()
-        
-        logger.info(f"Deleting file from RAG: {filepath}")
-        
-        try:
-            deleted_count = self.vector_repo.delete_by_source(str(filepath))
-            
-            if deleted_count > 0:
-                logger.info(f"✅ Deleted {deleted_count} chunks from {filepath.name}")
-            else:
-                logger.warning(f"No chunks found for {filepath}")
-            
-            return deleted_count
-            
-        except Exception as e:
-            logger.error(f"Failed to delete file: {e}")
-            raise RuntimeError(f"Deletion failed: {e}")
-    
-    def _infer_workspace(self, filepath: Path) -> str:
-        """
-        Infer workspace name from file path.
-        
-        Args:
-            filepath: Path to the file
-            
-        Returns:
-            Inferred workspace name
-        """
-        # Try to find project root (where .git or pyproject.toml exists)
-        current = filepath.parent
-        while current != current.parent:
-            if (current / '.git').exists() or (current / 'pyproject.toml').exists():
-                return current.name
-            current = current.parent
-        
-        # Default to parent directory name
-        return filepath.parent.name
-
-
-def main():
-    """Main entry point."""
-    parser = argparse.ArgumentParser(
-        description="Update or delete single files in RAG index"
-    )
-    
-    parser.add_argument(
-        "filepath",
-        help="Path to the file to update or delete"
-    )
-    
-    parser.add_argument(
-        "--delete",
-        action="store_true",
-        help="Delete the file from index instead of updating"
-    )
-    
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Enable verbose logging"
-    )
-    
-    args = parser.parse_args()
-    
-    # Configure logging based on verbose flag
-    if args.verbose:
-        logging.basicConfig(
-            level=logging.INFO,
-            format='%(asctime)s - %(levelname)s - %(message)s'
-        )
-        logging.getLogger('langchain_ollama').setLevel(logging.INFO)
-        logging.getLogger('chromadb').setLevel(logging.INFO)
-    else:
-        # Minimal logging - only errors
-        logging.basicConfig(
-            level=logging.ERROR,
-            format='%(message)s'
-        )
-        # Suppress all sub-module logs
-        logging.getLogger('src').setLevel(logging.ERROR)
-        logging.getLogger('scripts').setLevel(logging.ERROR)
-        logging.getLogger('langchain').setLevel(logging.ERROR)
-        logging.getLogger('langchain_ollama').setLevel(logging.ERROR)
-        logging.getLogger('chromadb').setLevel(logging.ERROR)
-        logging.getLogger('httpx').setLevel(logging.ERROR)
-        logging.getLogger('httpcore').setLevel(logging.ERROR)
-    
-    try:
-        updater = FileRAGUpdater()
-        
-        if args.delete:
-            # Delete file from index
-            deleted = updater.delete_file(args.filepath)
-            print(f"Deleted {deleted} chunks")
-        else:
-            # Update file in index
-            result = updater.update_file(args.filepath)
-            print(f"Updated: {result['deleted']} deleted, {result['added']} added")
-        
-        sys.exit(0)
-        
-    except FileNotFoundError as e:
-        print(f"❌ Error: {e}")
-        sys.exit(1)
-        
-    except ValueError as e:
-        print(f"❌ Invalid input: {e}")
-        sys.exit(1)
-        
-    except RuntimeError as e:
-        print(f"❌ Operation failed: {e}")
-        sys.exit(1)
-        
-    except Exception as e:
-        print(f"❌ Unexpected error: {e}")
-        if args.verbose:
-            import traceback
-            traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()