@mc1global/opencode-jarvis 0.13.1 → 0.14.0

package/src/domain/entities/entity_extractor.py

@@ -1,556 +0,0 @@
-"""
-Domain Entity Extractor for Domain Map V2
-Combines LSP accuracy with LLM understanding for multi-language entity extraction
-"""
-
-import json
-import logging
-from pathlib import Path
-from typing import List, Dict, Any, Optional
-from dataclasses import dataclass, asdict
-from enum import Enum
-
-logger = logging.getLogger(__name__)
-
-
-class EntityType(Enum):
-    """Types of domain entities"""
-
-    ENTITY = "entity"
-    VALUE_OBJECT = "value_object"
-    SERVICE = "service"
-    REPOSITORY = "repository"
-    CONTROLLER = "controller"
-    USE_CASE = "use_case"
-    VIEW_MODEL = "view_model"
-    AGGREGATE = "aggregate"
-    FACTORY = "factory"
-    EVENT = "event"
-    COMMAND = "command"
-    QUERY = "query"
-
-
-@dataclass
-class DomainEntity:
-    """Represents a domain entity extracted from code"""
-
-    name: str
-    type: EntityType
-    file: str
-    lines: List[int]  # [start_line, end_line]
-    language: str
-    methods: List[str]
-    properties: List[str]
-    dependencies: List[str]
-    annotations: List[str]  # Decorators, attributes, etc.
-    description: Optional[str] = None
-    visibility: str = "public"  # public, private, protected
-    is_abstract: bool = False
-    implements: List[str] = None
-    extends: Optional[str] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization"""
-        data = asdict(self)
-        data["type"] = self.type.value
-        return data
-
-
-class DomainEntityExtractor:
-    """
-    Extracts domain entities from code using LSP + LLM
-    Supports multiple languages and architectural patterns
-    """
-
-    # Language-specific entity markers
-    ENTITY_MARKERS = {
-        "python": {
-            EntityType.ENTITY: [
-                r"class\s+\w*Entity",
-                r"class\s+\w*Model",
-                r"@dataclass",
-            ],
-            EntityType.SERVICE: [
-                r"class\s+\w*Service",
-                r"class\s+\w*Manager",
-                r"class\s+\w*Handler",
-            ],
-            EntityType.REPOSITORY: [
-                r"class\s+\w*Repository",
-                r"class\s+\w*Store",
-                r"class\s+\w*DAO",
-            ],
-            EntityType.CONTROLLER: [
-                r"class\s+\w*Controller",
-                r"class\s+\w*View",
-                r"class\s+\w*Resource",
-            ],
-            EntityType.USE_CASE: [r"class\s+\w*UseCase", r"class\s+\w*Interactor"],
-        },
-        "kotlin": {
-            EntityType.ENTITY: [r"data\s+class", r"@Entity", r"class\s+\w*Entity"],
-            EntityType.SERVICE: [r"class\s+\w*Service", r"interface\s+\w*Service"],
-            EntityType.REPOSITORY: [
-                r"interface\s+\w*Repository",
-                r"class\s+\w*Repository",
-            ],
-            EntityType.CONTROLLER: [
-                r"class\s+\w*Activity",
-                r"class\s+\w*Fragment",
-                r"class\s+\w*Controller",
-            ],
-            EntityType.VIEW_MODEL: [r"class\s+\w*ViewModel", r":\s*ViewModel\(\)"],
-            EntityType.USE_CASE: [r"class\s+\w*UseCase", r"class\s+\w*Interactor"],
-        },
-        "swift": {
-            EntityType.ENTITY: [
-                r"struct\s+\w*Model",
-                r"class\s+\w*Model",
-                r"struct\s+\w*Entity",
-            ],
-            EntityType.SERVICE: [r"class\s+\w*Service", r"protocol\s+\w*Service"],
-            EntityType.REPOSITORY: [
-                r"protocol\s+\w*Repository",
-                r"class\s+\w*Repository",
-            ],
-            EntityType.CONTROLLER: [
-                r"class\s+\w*ViewController",
-                r"class\s+\w*Controller",
-            ],
-            EntityType.VIEW_MODEL: [r"class\s+\w*ViewModel", r"@ObservableObject"],
-        },
-        "typescript": {
-            EntityType.ENTITY: [
-                r"interface\s+\w*Model",
-                r"class\s+\w*Entity",
-                r"type\s+\w*Model",
-            ],
-            EntityType.SERVICE: [r"class\s+\w*Service", r"@Injectable"],
-            EntityType.REPOSITORY: [
-                r"class\s+\w*Repository",
-                r"interface\s+\w*Repository",
-            ],
-            EntityType.CONTROLLER: [r"class\s+\w*Controller", r"@Controller"],
-            EntityType.USE_CASE: [r"class\s+\w*UseCase", r"class\s+\w*Handler"],
-        },
-        "go": {
-            EntityType.ENTITY: [r"type\s+\w*\s+struct", r"type\s+\w*Model\s+struct"],
-            EntityType.SERVICE: [
-                r"type\s+\w*Service\s+struct",
-                r"func\s+New\w*Service",
-            ],
-            EntityType.REPOSITORY: [
-                r"type\s+\w*Repository\s+interface",
-                r"type\s+\w*Store\s+struct",
-            ],
-            EntityType.CONTROLLER: [
-                r"type\s+\w*Handler\s+struct",
-                r"type\s+\w*Controller\s+struct",
-            ],
-            EntityType.USE_CASE: [r"type\s+\w*UseCase\s+struct"],
-        },
-        "rust": {
-            EntityType.ENTITY: [r"struct\s+\w*Model", r"#\[derive\(.*Entity.*\)\]"],
-            EntityType.SERVICE: [r"impl\s+\w*Service", r"struct\s+\w*Service"],
-            EntityType.REPOSITORY: [
-                r"trait\s+\w*Repository",
-                r"struct\s+\w*Repository",
-            ],
-            EntityType.CONTROLLER: [r"struct\s+\w*Handler", r"#\[.*route.*\]"],
-        },
-    }
-
-    def __init__(self, lsp_manager, llm_client=None):
-        """
-        Initialize the entity extractor
-
-        Args:
-            lsp_manager: LanguageServerManager instance
-            llm_client: Optional LLM client for enhanced extraction
-        """
-        self.lsp = lsp_manager
-        self.llm = llm_client
-        self.prompts = self._load_prompts()
-
-    def _load_prompts(self) -> Dict[str, str]:
-        """Load LLM prompts for entity detection"""
-        return {
-            "entity_detection": """Analyze this {language} code and identify domain entities:
-
-{code}
-
-Identify the following types of components:
-1. Domain Entities (core business objects)
-2. Value Objects (immutable domain objects)
-3. Services (business logic)
-4. Repositories (data access)
-5. Controllers/Handlers (entry points)
-6. Use Cases/Interactors (application logic)
-7. ViewModels (presentation logic)
-
-For each component found, provide:
-- Name: The class/interface/struct name
-- Type: One of [entity, value_object, service, repository, controller, use_case, view_model]
-- Line: Starting line number
-- Description: Brief purpose of the component
-- Is Abstract: Whether it's an abstract class/interface
-- Extends: Parent class if any
-- Implements: Interfaces/protocols implemented
-
-Output as JSON:
-{{
-  "entities": [
-    {{
-      "name": "User",
-      "type": "entity",
-      "line": 10,
-      "description": "User domain entity",
-      "is_abstract": false,
-      "extends": null,
-      "implements": ["Validatable"]
-    }}
-  ]
-}}"""
-        }
-
-    def extract_entities(
-        self, file_path: Path, file_analysis=None
-    ) -> List[DomainEntity]:
-        """
-        Extract domain entities from a file
-
-        Args:
-            file_path: Path to the file to analyze
-            file_analysis: Optional pre-computed LSP analysis
-
-        Returns:
-            List of extracted domain entities
-        """
-        try:
-            # Get LSP analysis if not provided
-            if file_analysis is None:
-                file_analysis = self.lsp.analyze_file(file_path)
-
-            # Extract entities using LSP
-            lsp_entities = self._extract_from_lsp(file_analysis)
-
-            # Enhance with LLM if available
-            if self.llm:
-                llm_entities = self._extract_from_llm(file_path, file_analysis)
-                entities = self._merge_entities(lsp_entities, llm_entities)
-            else:
-                entities = lsp_entities
-
-            # Post-process entities
-            entities = self._post_process_entities(entities, file_analysis)
-
-            return entities
-
-        except Exception as e:
-            logger.error(f"Error extracting entities from {file_path}: {e}")
-            return []
-
-    def _extract_from_lsp(self, file_analysis) -> List[DomainEntity]:
-        """Extract entities using LSP symbol information"""
-        entities = []
-
-        for symbol in file_analysis.symbols:
-            entity_type = self._classify_symbol(symbol, file_analysis.language)
-            if entity_type:
-                entity = DomainEntity(
-                    name=symbol.name,
-                    type=entity_type,
-                    file=str(file_analysis.file_path),
-                    lines=[symbol.start_line, symbol.end_line],
-                    language=file_analysis.language,
-                    methods=[m.name for m in symbol.children if m.kind == "method"],
-                    properties=[
-                        p.name
-                        for p in symbol.children
-                        if p.kind in ["property", "field"]
-                    ],
-                    dependencies=self._extract_dependencies(symbol, file_analysis),
-                    annotations=symbol.decorators
-                    if hasattr(symbol, "decorators")
-                    else [],
-                    visibility=symbol.visibility
-                    if hasattr(symbol, "visibility")
-                    else "public",
-                    is_abstract=symbol.is_abstract
-                    if hasattr(symbol, "is_abstract")
-                    else False,
-                    implements=symbol.implements
-                    if hasattr(symbol, "implements")
-                    else [],
-                    extends=symbol.extends if hasattr(symbol, "extends") else None,
-                )
-                entities.append(entity)
-
-        return entities
-
-    def _extract_from_llm(self, file_path: Path, file_analysis) -> List[DomainEntity]:
-        """Extract entities using LLM analysis"""
-        try:
-            # Read file content
-            with open(file_path, "r", encoding="utf-8") as f:
-                code = f.read()
-
-            # Limit code size for LLM
-            if len(code) > 10000:
-                code = self._truncate_code(code, 10000)
-
-            # Generate prompt
-            prompt = self.prompts["entity_detection"].format(
-                language=file_analysis.language, code=code
-            )
-
-            # Get LLM response
-            response = self.llm.generate(prompt, temperature=0.2, max_tokens=4096)
-
-            # Parse response
-            entities_data = json.loads(response)
-
-            # Convert to DomainEntity objects
-            entities = []
-            for entity_data in entities_data.get("entities", []):
-                entity = DomainEntity(
-                    name=entity_data["name"],
-                    type=EntityType[entity_data["type"].upper()],
-                    file=str(file_path),
-                    lines=[
-                        entity_data["line"],
-                        entity_data.get("end_line", entity_data["line"] + 50),
-                    ],
-                    language=file_analysis.language,
-                    methods=[],  # Will be filled by merging with LSP
-                    properties=[],  # Will be filled by merging with LSP
-                    dependencies=[],  # Will be filled by merging with LSP
-                    annotations=[],
-                    description=entity_data.get("description"),
-                    is_abstract=entity_data.get("is_abstract", False),
-                    implements=entity_data.get("implements", []),
-                    extends=entity_data.get("extends"),
-                )
-                entities.append(entity)
-
-            return entities
-
-        except Exception as e:
-            logger.error(f"LLM extraction failed: {e}")
-            return []
-
-    def _classify_symbol(self, symbol, language: str) -> Optional[EntityType]:
-        """Classify a symbol into an entity type based on patterns"""
-        import re
-
-        # Get language-specific markers
-        markers = self.ENTITY_MARKERS.get(language, {})
-
-        # Check symbol name and context against patterns
-        symbol_context = f"{symbol.kind} {symbol.name}"
-        if hasattr(symbol, "signature"):
-            symbol_context += f" {symbol.signature}"
-
-        for entity_type, patterns in markers.items():
-            for pattern in patterns:
-                if re.search(pattern, symbol_context, re.IGNORECASE):
-                    return entity_type
-
-        # Fallback classification based on symbol kind
-        kind_mapping = {
-            "class": EntityType.ENTITY,
-            "interface": EntityType.REPOSITORY,
-            "function": EntityType.SERVICE,
-            "method": None,  # Methods are part of entities, not entities themselves
-            "struct": EntityType.ENTITY,
-            "enum": EntityType.VALUE_OBJECT,
-            "trait": EntityType.REPOSITORY,
-        }
-
-        return kind_mapping.get(symbol.kind)
-
-    def _extract_dependencies(self, symbol, file_analysis) -> List[str]:
-        """Extract dependencies for a symbol"""
-        dependencies = []
-
-        # Get imports used by this symbol
-        for ref in file_analysis.references:
-            if ref.from_symbol == symbol.name:
-                dependencies.append(ref.to_symbol)
-
-        # Add parent class and interfaces
-        if hasattr(symbol, "extends") and symbol.extends:
-            dependencies.append(symbol.extends)
-        if hasattr(symbol, "implements") and symbol.implements:
-            dependencies.extend(symbol.implements)
-
-        return list(set(dependencies))
-
-    def _merge_entities(
-        self, lsp_entities: List[DomainEntity], llm_entities: List[DomainEntity]
-    ) -> List[DomainEntity]:
-        """Merge LSP and LLM entities, preferring LSP for accuracy"""
-        merged = {}
-
-        # Start with LSP entities (more accurate)
-        for entity in lsp_entities:
-            merged[entity.name] = entity
-
-        # Enhance with LLM insights
-        for llm_entity in llm_entities:
-            if llm_entity.name in merged:
-                # Enhance existing entity
-                lsp_entity = merged[llm_entity.name]
-                if llm_entity.description and not lsp_entity.description:
-                    lsp_entity.description = llm_entity.description
-                if llm_entity.type != lsp_entity.type:
-                    # LLM might have better semantic understanding
-                    logger.debug(
-                        f"Type mismatch for {llm_entity.name}: "
-                        f"LSP={lsp_entity.type}, LLM={llm_entity.type}"
-                    )
-                    # Trust LLM for semantic classification
-                    lsp_entity.type = llm_entity.type
-            else:
-                # New entity found by LLM
-                merged[llm_entity.name] = llm_entity
-
-        return list(merged.values())
-
-    def _post_process_entities(
-        self, entities: List[DomainEntity], file_analysis
-    ) -> List[DomainEntity]:
-        """Post-process entities for consistency and completeness"""
-        processed = []
-
-        for entity in entities:
-            # Skip certain types of symbols
-            if entity.name.startswith("_"):  # Private implementation details
-                continue
-            if entity.name in ["__init__", "__main__", "main"]:  # Common non-entities
-                continue
-
-            # Ensure line numbers are valid
-            if entity.lines[0] <= 0:
-                entity.lines[0] = 1
-            if entity.lines[1] < entity.lines[0]:
-                entity.lines[1] = entity.lines[0] + 10
-
-            # Clean up dependencies
-            entity.dependencies = [
-                dep
-                for dep in entity.dependencies
-                if dep != entity.name and not dep.startswith("_")
-            ]
-
-            processed.append(entity)
-
-        return processed
-
-    def _truncate_code(self, code: str, max_length: int) -> str:
-        """Truncate code intelligently to fit within token limits"""
-        if len(code) <= max_length:
-            return code
-
-        # Try to truncate at a reasonable boundary
-        truncated = code[:max_length]
-
-        # Find last complete line
-        last_newline = truncated.rfind("\n")
-        if last_newline > max_length * 0.8:  # If we're not losing too much
-            truncated = truncated[:last_newline]
-
-        return truncated + "\n... (truncated)"
-
-    def extract_from_workspace(
-        self, workspace_path: Path, pattern: str = "**/*.{py,kt,swift,ts,js,go,rs}"
-    ) -> Dict[str, List[DomainEntity]]:
-        """
-        Extract entities from all files in a workspace
-
-        Args:
-            workspace_path: Root path of the workspace
-            pattern: Glob pattern for files to analyze
-
-        Returns:
-            Dictionary mapping file paths to their entities
-        """
-        from pathlib import Path
-        import glob
-
-        entities_by_file = {}
-
-        # Find all matching files
-        for file_pattern in pattern.split(","):
-            file_pattern = file_pattern.strip()
-            for file_path in workspace_path.glob(file_pattern):
-                if file_path.is_file():
-                    # Skip test files and generated files
-                    if any(
-                        skip in str(file_path)
-                        for skip in ["test", "spec", "build", "dist", "node_modules"]
-                    ):
-                        continue
-
-                    entities = self.extract_entities(file_path)
-                    if entities:
-                        entities_by_file[str(file_path)] = entities
-
-        return entities_by_file
-
-
-def main():
-    """Test the entity extractor"""
-    import sys
-    from pathlib import Path
-
-    if len(sys.argv) < 2:
-        print("Usage: python entity_extractor.py <file_or_directory>")
-        sys.exit(1)
-
-    target = Path(sys.argv[1])
-
-    # Initialize components (mock for testing)
-    class MockLSPManager:
-        def analyze_file(self, file_path):
-            # Mock implementation
-            class MockAnalysis:
-                def __init__(self):
-                    self.file_path = file_path
-                    self.language = self._detect_language(file_path)
-                    self.symbols = []
-                    self.references = []
-
-                def _detect_language(self, path):
-                    ext_map = {
-                        ".py": "python",
-                        ".kt": "kotlin",
-                        ".swift": "swift",
-                        ".ts": "typescript",
-                        ".js": "javascript",
-                        ".go": "go",
-                        ".rs": "rust",
-                    }
-                    return ext_map.get(path.suffix, "unknown")
-
-            return MockAnalysis()
-
-    lsp = MockLSPManager()
-    extractor = DomainEntityExtractor(lsp)
-
-    if target.is_file():
-        entities = extractor.extract_entities(target)
-        print(f"\nEntities found in {target}:")
-        for entity in entities:
-            print(f"  - {entity.name} ({entity.type.value})")
-    else:
-        entities_by_file = extractor.extract_from_workspace(target)
-        print(f"\nEntities found in workspace {target}:")
-        for file_path, entities in entities_by_file.items():
-            print(f"\n{file_path}:")
-            for entity in entities:
-                print(f"  - {entity.name} ({entity.type.value})")
-
-
-if __name__ == "__main__":
-    main()

package/src/domain/file_governance/README.md

@@ -1,70 +0,0 @@
-🤖 Using: llama3.2:3b (temp=0.3)
-✅ Completed in 23.0s
-# Domain: file_governance
-
-## Overview
-
-The `file_governance` domain is responsible for managing file access control and governance policies. It provides a set of services that enforce rules and policies to ensure secure and compliant file handling.
-
-## Architecture
-
-The `file_governance` domain follows the Clean Architecture pattern, with the following layers:
-
-1. **Domain Layer**: This layer contains the core business logic, including services, value objects, and entities.
-2. **Application Layer**: This layer provides a higher-level abstraction of the domain logic, using use cases to encapsulate complex operations.
-3. **Infrastructure Layer**: This layer is responsible for providing infrastructure-specific implementations, such as database connections.
-
-## Components
-
-### Entities
-
-* `FileRule`: Represents a file governance rule with attributes like pattern, rule type, scope, and priority.
-* `FilePolicy`: Represents a file governance policy with attributes like name, description, workspace, and enabled status.
-* `FileOperation`: Represents a file operation with attributes like file path, operation type, and workspace.
-
-### Services
-
-* `RuleEvaluatorService`: Evaluates file operations against rules and policies.
-* `FileGovernanceService`: Orchestrates file rule and policy repositories with domain services for file access control.
-
-### Use Cases
-
-* `ValidateFileAccessUseCase`: Validates a file operation against governance policies.
-* `ListViolationsUseCase`: Retrieves rule violations for monitoring and auditing.
-
-## Usage
-
-To use the `file_governance` domain, follow these steps:
-
-1. Create an instance of `RuleEvaluatorService` and configure it with your rules and policies.
-2. Use `FileGovernanceService` to validate file operations against governance policies.
-3. Execute `ValidateFileAccessUseCase` to validate a specific file operation.
-4. Execute `ListViolationsUseCase` to retrieve rule violations.
-
-## API Reference
-
-### Public Methods
-
-* `RuleEvaluatorService.evaluate_operation(file_path: Path, operation: str, policy: FilePolicy) -> EvaluationResult`
-* `FileGovernanceService.validate_file_access(file_path: Path, operation: str, workspace: Optional[str] = None) -> Tuple[bool, Optional[str]>`
-
-## Testing
-
-To test the `file_governance` domain, follow these steps:
-
-1. Create a test database with sample data.
-2. Use a testing framework to execute use cases and verify results.
-
-## Dependencies
-
-* `sqlite3`: For interacting with the SQLite database.
-* `pathlib`: For working with file paths.
-* `datetime`: For handling timestamps.
-
-## Roadmap
-
-Future improvements include:
-
-* Adding support for additional file systems and storage solutions.
-* Enhancing the rule evaluation logic to account for more complex scenarios.
-* Implementing a web interface for users to manage governance policies.

package/src/domain/file_governance/__init__.py

@@ -1,9 +0,0 @@
-"""
-File Governance Bounded Context - Domain layer.
-
-This context handles:
-- File access rules and policies
-- Path validation and normalization
-- Workspace vs core file separation
-- File operation permissions
-"""

package/src/domain/file_governance/entities/__init__.py

@@ -1,15 +0,0 @@
-"""
-File Governance entities module.
-
-This module exports all entities for the File Governance bounded context.
-"""
-
-from .file_rule import FileRule
-from .file_policy import FilePolicy
-from .file_operation import FileOperation
-
-__all__ = [
-    "FileRule",
-    "FilePolicy",
-    "FileOperation",
-]