@mc1global/opencode-jarvis 0.13.1 → 0.14.0

package/scripts/rag/domain_mapper/cli.py

@@ -1,181 +0,0 @@
-#!/usr/bin/env python3
-"""Domain Mapper CLI - DDD Domain Analysis with TOON Output.
-
-Usage:
-    python -m scripts.rag.domain_mapper.cli [DOMAIN] -w WORKSPACE [OPTIONS]
-    python scripts/rag/domain_mapper/cli.py [DOMAIN] -w WORKSPACE [OPTIONS]
-
-Examples:
-    # Map single domain
-    python -m scripts.rag.domain_mapper.cli context_memory -w JARVIS
-
-    # Map entire workspace
-    python -m scripts.rag.domain_mapper.cli -w JARVIS
-
-    # With verbose output
-    python -m scripts.rag.domain_mapper.cli -w JARVIS --verbose
-"""
-
-import argparse
-import logging
-import sys
-import warnings
-from pathlib import Path
-
-# Add project root for imports
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent.parent))
-
-from scripts.rag.domain_mapper.config import load_config
-from scripts.rag.domain_mapper.vectorstore import load_vectorstore
-from scripts.rag.domain_mapper.mapper import map_domain_structure, map_workspace_structure
-from scripts.rag.domain_mapper.persistence import (
-    save_domain_map_atomic,
-    save_workspace_map,
-    persist_to_database,
-)
-from src.infrastructure.rag.workspace_utils import get_workspace_domain_map_path
-
-logger = logging.getLogger(__name__)
-
-
-def setup_logging(verbose: bool = False) -> None:
-    """Configure logging for CLI."""
-    if verbose:
-        logging.basicConfig(
-            level=logging.INFO,
-            format='%(levelname)s: %(message)s'
-        )
-    else:
-        logging.basicConfig(level=logging.ERROR)
-        warnings.filterwarnings('ignore')
-        logging.getLogger('httpx').setLevel(logging.CRITICAL)
-        logging.getLogger('httpcore').setLevel(logging.CRITICAL)
-        logging.getLogger('chromadb').setLevel(logging.CRITICAL)
-
-
-def parse_arguments() -> argparse.Namespace:
-    """Parse CLI arguments."""
-    parser = argparse.ArgumentParser(
-        description="Domain Mapper - DDD Analysis with TOON Output",
-        formatter_class=argparse.RawTextHelpFormatter
-    )
-
-    parser.add_argument(
-        "domain_name",
-        nargs="?",
-        help="DDD domain to analyze. Omit to map entire workspace."
-    )
-
-    parser.add_argument(
-        "-w", "--workspace",
-        required=True,
-        help="Workspace name (e.g., 'JARVIS', 'web-ui-gensynth')"
-    )
-
-    parser.add_argument(
-        "-o", "--output",
-        help="Output file path (default: auto-generated)"
-    )
-
-    parser.add_argument(
-        "--provider",
-        choices=["ollama", "anthropic"],
-        help="LLM provider (default: from config)"
-    )
-
-    parser.add_argument(
-        "--persist",
-        action="store_true",
-        help="Persist results to database after mapping"
-    )
-
-    parser.add_argument(
-        "--verbose", "-v",
-        action="store_true",
-        help="Enable verbose output"
-    )
-
-    parser.add_argument(
-        "--config",
-        help="Path to config file (default: config/domain_mapper.yaml)"
-    )
-
-    return parser.parse_args()
-
-
-def main() -> None:
-    """Execute domain mapping."""
-    args = parse_arguments()
-    setup_logging(args.verbose)
-
-    # Load configuration
-    try:
-        config = load_config(config_path=args.config, verbose=args.verbose)
-    except Exception as e:
-        print(f"error:config_load_failed:{str(e)[:50]}")
-        sys.exit(1)
-
-    # Get provider
-    provider = args.provider or config.provider.default
-
-    # Load vectorstore (per-workspace isolation)
-    vectorstore = load_vectorstore(config=config, verbose=args.verbose, workspace=args.workspace)
-
-    if args.domain_name:
-        # Single domain mapping
-        if args.verbose:
-            logger.info(f"Mapping single domain: {args.domain_name}")
-
-        domain_map = map_domain_structure(
-            vectorstore=vectorstore,
-            domain_name=args.domain_name,
-            workspace_name=args.workspace,
-            config=config,
-            verbose=args.verbose,
-            provider=provider
-        )
-
-        # Output
-        if args.output:
-            save_domain_map_atomic(domain_map, args.output, args.verbose)
-        else:
-            # TOON output
-            print(f"ok:domain:{domain_map.domain}:classes:{len(domain_map.classes)}")
-            if args.verbose:
-                print(domain_map.model_dump_json(indent=2))
-    else:
-        # Full workspace mapping
-        if args.verbose:
-            logger.info(f"Mapping workspace: {args.workspace}")
-
-        workspace_map = map_workspace_structure(
-            vectorstore=vectorstore,
-            workspace_name=args.workspace,
-            config=config,
-            verbose=args.verbose,
-            provider=provider
-        )
-
-        # Output
-        output_path = args.output or get_workspace_domain_map_path(args.workspace)
-        save_workspace_map(workspace_map, output_path, args.verbose)
-
-        # TOON summary
-        print(
-            f"ok:workspace:{args.workspace}:"
-            f"domains:{workspace_map['domain_count']}:"
-            f"failed:{workspace_map['failed_count']}"
-        )
-
-    # Persist to database if requested
-    if args.persist:
-        try:
-            persist_to_database(args.workspace, args.verbose)
-        except Exception as e:
-            if args.verbose:
-                logger.error(f"Database persist failed: {e}")
-            # Don't exit - mapping succeeded
-
-
-if __name__ == "__main__":
-    main()

package/scripts/rag/domain_mapper/config.py

@@ -1,185 +0,0 @@
-#!/usr/bin/env python3
-"""
-Domain Mapper Configuration Loader.
-
-Loads and validates configuration from config/domain_mapper.yaml.
-
-Type Hints: Required (mypy compliant)
-Docstring: Google format
-Max Lines: 150
-"""
-
-import logging
-import os
-import sys
-from pathlib import Path
-from typing import Dict, Any, Optional
-
-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.paths import PathRegistry
-from src.domain.governance.path_keys import PathKey
-
-logger = logging.getLogger(__name__)
-
-
-class OllamaConfig(BaseModel):
-    """Ollama configuration settings."""
-
-    host_url: str = Field(default="http://localhost:11434")
-    embedding_model: str = Field(default="embeddinggemma")
-    llm_model: str = Field(default="llama3.2:3b")
-
-
-class AnthropicConfig(BaseModel):
-    """Anthropic configuration settings."""
-
-    model: str = Field(default="claude-3-5-haiku-20241022")
-    max_tokens: int = Field(default=4096, ge=1024, le=8192)
-
-
-class VectorStoreConfig(BaseModel):
-    """Vector store configuration."""
-
-    directory: str = Field(default_factory=lambda: str(PathRegistry.get(PathKey.RAG_CHROMA_DB)))
-    search_k: int = Field(default=15, ge=1, le=100)
-
-
-class ProviderConfig(BaseModel):
-    """Provider configuration."""
-
-    default: str = Field(default="ollama")
-    options: list[str] = Field(default=["ollama", "anthropic"])
-
-    @field_validator("default")
-    @classmethod
-    def validate_default(cls, v: str, info) -> str:
-        """Validate default provider is in options."""
-        # Note: info.data not available in validator, will validate in post_init
-        return v
-
-
-class ParallelConfig(BaseModel):
-    """Parallel processing configuration."""
-
-    max_workers: int = Field(default=5, ge=1, le=20)
-
-
-class PromptsConfig(BaseModel):
-    """LLM prompts configuration."""
-
-    system: str
-    human: str
-    extraction_query: str
-
-
-class SchemaLimitsConfig(BaseModel):
-    """TOON schema constraints."""
-
-    domain_name_max: int = Field(default=40)
-    description_max: int = Field(default=300)
-    class_description_max: int = Field(default=200)
-    method_usage_max: int = Field(default=300)
-    method_name_max: int = Field(default=40)
-    max_dependencies: int = Field(default=3)
-    max_classes: int = Field(default=10)
-    max_methods: int = Field(default=10)
-
-
-class SchemaConfig(BaseModel):
-    """Schema configuration."""
-
-    limits: SchemaLimitsConfig
-
-
-class DomainMapperConfig(BaseModel):
-    """Complete domain mapper configuration."""
-
-    ollama: OllamaConfig
-    anthropic: AnthropicConfig
-    vectorstore: VectorStoreConfig
-    provider: ProviderConfig
-    parallel: ParallelConfig
-    prompts: PromptsConfig
-    toon_schema: SchemaConfig
-
-
-def load_config(config_path: Optional[str] = None, verbose: bool = False) -> DomainMapperConfig:
-    """
-    Load domain mapper configuration from YAML.
-
-    Args:
-        config_path: Path to config file (default: config/domain_mapper.yaml)
-        verbose: Enable verbose logging
-
-    Returns:
-        Validated DomainMapperConfig instance
-
-    Raises:
-        FileNotFoundError: If config file not found
-        ValueError: If config validation fails
-    """
-    if not config_path:
-        # Use PathRegistry for governance-compliant path resolution
-        config_dir = PathRegistry.get(PathKey.PROJECT_CONFIG)
-        config_path = config_dir / "domain_mapper.yaml"
-
-    config_file = Path(config_path)
-    if not config_file.exists():
-        error_msg = f"Config file not found: {config_path}"
-        if verbose:
-            logger.error(error_msg)
-        else:
-            print(f"error:config_not_found:{config_path}")
-        raise FileNotFoundError(error_msg)
-
-    try:
-        with open(config_file, "r") as f:
-            yaml_data = yaml.safe_load(f)
-
-        config = DomainMapperConfig.model_validate(yaml_data)
-
-        # Validate provider default is in options
-        if config.provider.default not in config.provider.options:
-            raise ValueError(
-                f"Invalid default provider '{config.provider.default}'. "
-                f"Must be one of: {config.provider.options}"
-            )
-
-        if verbose:
-            logger.info(f"Configuration loaded from {config_path}")
-
-        return config
-
-    except yaml.YAMLError as e:
-        error_msg = f"Invalid YAML in config file: {e}"
-        if verbose:
-            logger.error(error_msg)
-        else:
-            print(f"error:yaml_invalid:{str(e)[:50]}")
-        raise ValueError(error_msg)
-    except Exception as e:
-        error_msg = f"Failed to load config: {e}"
-        if verbose:
-            logger.error(error_msg)
-        else:
-            print(f"error:config_load_failed:{str(e)[:50]}")
-        raise
-
-
-def get_ollama_url(config: Optional[DomainMapperConfig] = None) -> str:
-    """Get Ollama host URL from config."""
-    if not config:
-        config = load_config()
-    return config.ollama.host_url
-
-
-def get_default_provider(config: Optional[DomainMapperConfig] = None) -> str:
-    """Get default LLM provider from config."""
-    if not config:
-        config = load_config()
-    return config.provider.default

package/scripts/rag/domain_mapper/discovery.py

@@ -1,284 +0,0 @@
-"""Domain Discovery for Domain Mapper.
-
-Discovers DDD bounded contexts in workspace directory structure.
-Supports both DDD projects and non-DDD projects (Android, iOS, etc.).
-"""
-
-import logging
-import sys
-from pathlib import Path
-from typing import List, Optional
-
-from langchain_chroma import Chroma
-
-# Add project root for workspace utils
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent.parent))
-from src.infrastructure.rag.workspace_utils import get_workspace_dir
-from src.infrastructure.rag.project_structure_detector import ProjectStructureDetector
-
-logger = logging.getLogger(__name__)
-
-
-def _discover_non_ddd_domains(workspace_dir: Path, verbose: bool = False) -> List[str]:
-    """
-    Discover domains from non-DDD projects (Android, iOS, etc.).
-
-    For Android projects: infers domains from package structure
-    For other projects: uses top-level directories as domains
-
-    Args:
-        workspace_dir: Workspace root directory
-        verbose: Enable verbose logging
-
-    Returns:
-        List of inferred domain names (empty if cannot infer)
-    """
-    if verbose:
-        logger.info("Attempting to infer domains from non-DDD structure...")
-
-    # Detect project type
-    detector = ProjectStructureDetector(workspace_dir)
-    detected_type = detector._detect_project_type()
-
-    if not detected_type:
-        if verbose:
-            logger.warning("Could not detect project type")
-        return []
-
-    if verbose:
-        logger.info(f"Detected project type: {detected_type}")
-
-    # Android: infer domains from package structure
-    if detected_type == "android":
-        domains = _infer_android_domains(workspace_dir, verbose)
-        if domains:
-            return domains
-
-    # iOS: infer domains from source structure
-    if detected_type == "ios":
-        domains = _infer_ios_domains(workspace_dir, verbose)
-        if domains:
-            return domains
-
-    # Fallback: use top-level directories as domains
-    if verbose:
-        logger.info("Using top-level directories as domains (fallback)")
-
-    domains = []
-    common_non_domains = {
-        'build', 'dist', 'node_modules', '.gradle', '.idea',
-        'target', 'bin', 'obj', '.venv', 'venv', '__pycache__',
-        '.git', '.github', 'docs', 'test', 'tests'
-    }
-
-    for item in workspace_dir.iterdir():
-        if (item.is_dir() and
-            not item.name.startswith('.') and
-            not item.name.startswith('_') and
-            item.name not in common_non_domains):
-            domains.append(item.name)
-
-    return sorted([d.lower() for d in domains]) if domains else []
-
-
-def _infer_android_domains(workspace_dir: Path, verbose: bool = False) -> List[str]:
-    """
-    Infer domains from Android package structure.
-
-    Looks for packages in: app/src/main/kotlin/ or app/src/main/java/
-
-    Returns:
-        List of package-based domains
-    """
-    domains = set()
-
-    # Check both Kotlin and Java source directories
-    source_roots = [
-        workspace_dir / "app" / "src" / "main" / "kotlin",
-        workspace_dir / "app" / "src" / "main" / "java",
-    ]
-
-    for source_root in source_roots:
-        if not source_root.exists():
-            continue
-
-        # Navigate through package structure (e.g., com/company/app/)
-        # Get to the actual app package level
-        current = source_root
-        depth = 0
-        max_depth = 10  # Prevent infinite loops
-
-        # Traverse down until we find directories that look like features/domains
-        while depth < max_depth:
-            subdirs = [d for d in current.iterdir() if d.is_dir() and not d.name.startswith('_')]
-
-            if len(subdirs) == 1:
-                # Single subdirectory - keep traversing (likely package path)
-                current = subdirs[0]
-                depth += 1
-            elif len(subdirs) > 1:
-                # Multiple subdirectories - these are likely feature/domain packages
-                for subdir in subdirs:
-                    if not subdir.name in {'test', 'tests', 'androidTest', 'util', 'utils', 'common'}:
-                        domains.add(subdir.name)
-                break
-            else:
-                break
-
-    if verbose and domains:
-        logger.info(f"Inferred Android domains from package structure: {sorted(domains)}")
-
-    return sorted(domains)
-
-
-def _infer_ios_domains(workspace_dir: Path, verbose: bool = False) -> List[str]:
-    """
-    Infer domains from iOS project structure.
-
-    Looks for feature directories in common iOS structures.
-
-    Returns:
-        List of inferred domains
-    """
-    domains = set()
-
-    # Common iOS source directories
-    source_patterns = [
-        "Sources",
-        "*/Sources",
-    ]
-
-    for pattern in source_patterns:
-        for source_dir in workspace_dir.glob(pattern):
-            if not source_dir.is_dir():
-                continue
-
-            # Top-level directories in Sources/ are usually features/domains
-            for item in source_dir.iterdir():
-                if item.is_dir() and not item.name.startswith('.') and not item.name.startswith('_'):
-                    domains.add(item.name)
-
-    if verbose and domains:
-        logger.info(f"Inferred iOS domains from source structure: {sorted(domains)}")
-
-    return sorted(domains)
-
-
-def discover_workspace_domains(
-    vectorstore: Chroma,
-    workspace_name: str,
-    verbose: bool = False
-) -> List[str]:
-    """
-    Discover all unique domains in a workspace.
-
-    Searches for domain directories in multiple common patterns:
-    - src/domain/
-    - local_agent/domain/
-    - domain/
-    - app/domain/
-
-    Args:
-        vectorstore: Chroma instance with indexed code
-        workspace_name: Workspace to analyze
-        verbose: Enable verbose logging
-
-    Returns:
-        List of unique domain names
-
-    Raises:
-        SystemExit: If no domains found
-    """
-    if verbose:
-        logger.info(f"Discovering DDD bounded contexts in workspace '{workspace_name}'...")
-
-    # Get workspace directory
-    if workspace_name.upper() == "JARVIS":
-        workspace_dir = Path(".")
-    else:
-        try:
-            workspace_dir = get_workspace_dir(workspace_name)
-        except Exception:
-            workspace_dir = Path(f"workspace/{workspace_name}")
-
-    # Common domain directory patterns
-    domain_patterns = [
-        "src/domain",
-        "local_agent/domain",
-        "domain",
-        "app/domain",
-        "lib/domain",
-    ]
-
-    domain_path = None
-    for pattern in domain_patterns:
-        candidate = Path(workspace_dir) / pattern
-        if candidate.exists() and candidate.is_dir():
-            domain_path = candidate
-            if verbose:
-                logger.info(f"Found domain directory: {domain_path}")
-            break
-
-    if not domain_path:
-        if verbose:
-            logger.warning(f"No domain directory found in {workspace_dir}")
-            logger.warning(f"Searched patterns: {domain_patterns}")
-
-        # Try alternative detection for non-DDD projects
-        domains = _discover_non_ddd_domains(workspace_dir, verbose)
-
-        if not domains:
-            if verbose:
-                logger.error(f"ERROR: No domain directory found in {workspace_dir}")
-                logger.error(f"ERROR: Searched patterns: {domain_patterns}")
-                logger.info("")
-                logger.info("Situação:")
-                logger.info(f"- {workspace_name} usa estrutura Android padrão (não DDD explícito)")
-                logger.info("- Domain mapper foi projetado para projetos que seguem DDD (como o próprio JARVIS Framework)")
-                logger.info("")
-                logger.info("Opções:")
-                logger.info("")
-                logger.info("1. Pular o domain map (recomendado para Android):")
-                logger.info(f"   O RAG do {workspace_name} já está indexado e funcional. O domain map é opcional - você pode fazer buscas semânticas normalmente sem ele.")
-                logger.info("")
-                logger.info("2. Verificar estrutura do projeto:")
-                logger.info(f"   Podemos ver como o {workspace_name} está organizado e criar um domain map manual se necessário.")
-                logger.info("")
-                logger.info("3. Adaptar o domain mapper:")
-                logger.info("   Modificar o domain mapper para entender estruturas Android.")
-                logger.info("")
-                logger.info(f"Qual opção você prefere? Para projetos Android, geralmente opção 1 é suficiente, já que o RAG consegue encontrar código por funcionalidade mesmo sem domain map explícito.")
-            print(f"error:no_domain_dir:{workspace_dir}")
-            return []
-
-        if verbose:
-            logger.info(f"✓ Inferred {len(domains)} domains from project structure: {', '.join(domains)}")
-        return domains
-
-    # Each subdirectory in domain/ = 1 bounded context
-    domains = []
-    for item in domain_path.iterdir():
-        if item.is_dir() and not item.name.startswith('_') and item.name != '__pycache__':
-            domains.append(item.name)
-
-    if not domains:
-        if verbose:
-            logger.warning(f"No DDD domains found in {domain_path}")
-
-        # Try alternative detection
-        domains = _discover_non_ddd_domains(workspace_dir, verbose)
-
-        if not domains:
-            if verbose:
-                logger.error(f"No domains found in {domain_path}")
-            print(f"error:no_ddd_domains:{domain_path}")
-            return []
-
-    domains = sorted(domains)
-
-    if verbose:
-        logger.info(f"Found {len(domains)} DDD bounded contexts: {', '.join(domains)}")
-    else:
-        print(f"ok:ddd_domains:{len(domains)}:{','.join(domains)}")
-
-    return domains