@mc1global/opencode-jarvis 0.13.1 → 0.14.0

package/src/domain/workspace/change_detection_vos.py

@@ -1,331 +0,0 @@
-"""
-Value Objects for Change Detection (Phase 2).
-
-Immutable value objects for change detection and impact analysis.
-Separated from main value_objects.py to maintain modularity.
-"""
-
-from dataclasses import dataclass, field
-from datetime import datetime
-from pathlib import Path
-from typing import List, Optional, Dict, Any
-import re
-
-from ..shared import ValueObject, ValidationError
-
-
-@dataclass(frozen=True)
-class FileChange(ValueObject):
-    """
-    Immutable representation of a file change.
-
-    Captures details about a single file modification in a commit.
-    """
-    file_path: str
-    change_type: str  # added, modified, deleted, renamed
-    old_path: Optional[str] = None  # for renames
-    lines_added: int = 0
-    lines_removed: int = 0
-
-    def validate(self) -> bool:
-        """Validate file change."""
-        if not self.file_path or not self.file_path.strip():
-            raise ValidationError("file_path cannot be empty")
-
-        valid_types = {'added', 'modified', 'deleted', 'renamed'}
-        if self.change_type not in valid_types:
-            raise ValidationError(
-                f"change_type must be one of {valid_types}, got {self.change_type}"
-            )
-
-        if self.change_type == 'renamed' and not self.old_path:
-            raise ValidationError("renamed files must have old_path")
-
-        if self.lines_added < 0:
-            raise ValidationError("lines_added cannot be negative")
-
-        if self.lines_removed < 0:
-            raise ValidationError("lines_removed cannot be negative")
-
-        return True
-
-    def is_code_file(self) -> bool:
-        """Check if file is code (not docs/config)."""
-        code_extensions = {
-            '.py', '.js', '.ts', '.tsx', '.jsx',
-            '.kt', '.java', '.go', '.swift',
-            '.cpp', '.c', '.h', '.cs', '.rs'
-        }
-        return Path(self.file_path).suffix in code_extensions
-
-    def is_significant_change(self) -> bool:
-        """Check if change is significant (>10 lines or deleted/added)."""
-        if self.change_type in {'added', 'deleted'}:
-            return True
-
-        total_lines = self.lines_added + self.lines_removed
-        return total_lines > 10
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary."""
-        return {
-            'file_path': self.file_path,
-            'change_type': self.change_type,
-            'old_path': self.old_path,
-            'lines_added': self.lines_added,
-            'lines_removed': self.lines_removed,
-            'is_code': self.is_code_file(),
-            'is_significant': self.is_significant_change()
-        }
-
-
-@dataclass(frozen=True)
-class GitCommit(ValueObject):
-    """
-    Immutable representation of a git commit.
-
-    Contains all relevant information about a commit including
-    metadata and changed files.
-    """
-    hash: str
-    message: str
-    author: str
-    timestamp: datetime
-    changed_files: List[FileChange] = field(default_factory=list)
-
-    def __post_init__(self):
-        """Initialize and validate commit."""
-        if self.changed_files is None:
-            object.__setattr__(self, 'changed_files', [])
-        self.validate()
-
-    def validate(self) -> bool:
-        """Validate git commit."""
-        if not self.hash or not self.hash.strip():
-            raise ValidationError("commit hash cannot be empty")
-
-        # Git commit hashes are 40 characters (SHA-1)
-        if len(self.hash) not in {7, 40}:  # Allow short or full hash
-            raise ValidationError(
-                f"commit hash must be 7 or 40 characters, got {len(self.hash)}"
-            )
-
-        if not self.message or not self.message.strip():
-            raise ValidationError("commit message cannot be empty")
-
-        if not self.author or not self.author.strip():
-            raise ValidationError("commit author cannot be empty")
-
-        return True
-
-    def get_code_changes(self) -> List[FileChange]:
-        """Filter only code file changes."""
-        return [f for f in self.changed_files if f.is_code_file()]
-
-    def get_significant_changes(self) -> List[FileChange]:
-        """Get only significant changes."""
-        return [f for f in self.changed_files if f.is_significant_change()]
-
-    def short_hash(self) -> str:
-        """Get short commit hash (7 chars)."""
-        return self.hash[:7]
-
-    def short_message(self, max_length: int = 50) -> str:
-        """Get short commit message."""
-        if len(self.message) <= max_length:
-            return self.message
-        return self.message[:max_length-3] + "..."
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary."""
-        return {
-            'hash': self.hash,
-            'short_hash': self.short_hash(),
-            'message': self.message,
-            'short_message': self.short_message(),
-            'author': self.author,
-            'timestamp': self.timestamp.isoformat(),
-            'changed_files': [f.to_dict() for f in self.changed_files],
-            'code_changes_count': len(self.get_code_changes()),
-            'significant_changes_count': len(self.get_significant_changes())
-        }
-
-    def to_toon(self) -> str:
-        """
-        Convert to TOON format for token efficiency.
-
-        Returns:
-            Compact string: hash:XXXXX,files:N,code:N,author:X
-        """
-        code_count = len(self.get_code_changes())
-        return (
-            f"hash:{self.short_hash()},files:{len(self.changed_files)},"
-            f"code:{code_count},author:{self.author}"
-        )
-
-
-@dataclass(frozen=True)
-class ImpactReport(ValueObject):
-    """
-    Immutable impact analysis report.
-
-    Result of analyzing how changes in one workspace affect another.
-    """
-    source_workspace: str
-    target_workspace: str
-    change_commit: str
-    impacts: List[Dict[str, Any]]
-    severity: str  # BREAKING, WARNING, INFO
-    recommendations: List[str]
-    analyzed_at: datetime = field(default_factory=datetime.now)
-
-    def __post_init__(self):
-        """Initialize and validate report."""
-        if self.impacts is None:
-            object.__setattr__(self, 'impacts', [])
-        if self.recommendations is None:
-            object.__setattr__(self, 'recommendations', [])
-        self.validate()
-
-    def validate(self) -> bool:
-        """Validate impact report."""
-        if not self.source_workspace or not self.source_workspace.strip():
-            raise ValidationError("source_workspace cannot be empty")
-
-        if not self.target_workspace or not self.target_workspace.strip():
-            raise ValidationError("target_workspace cannot be empty")
-
-        if not self.change_commit or not self.change_commit.strip():
-            raise ValidationError("change_commit cannot be empty")
-
-        valid_severities = {'BREAKING', 'WARNING', 'INFO', 'NONE'}
-        if self.severity not in valid_severities:
-            raise ValidationError(
-                f"severity must be one of {valid_severities}, got {self.severity}"
-            )
-
-        return True
-
-    def has_impacts(self) -> bool:
-        """Check if report has any impacts."""
-        return len(self.impacts) > 0
-
-    def is_breaking(self) -> bool:
-        """Check if impact is breaking."""
-        return self.severity == 'BREAKING'
-
-    def is_warning(self) -> bool:
-        """Check if impact is warning level."""
-        return self.severity == 'WARNING'
-
-    def get_affected_files(self) -> List[str]:
-        """Get list of all affected files in target workspace."""
-        files = []
-        for impact in self.impacts:
-            files.extend(impact.get('affected_files', []))
-        return list(set(files))  # Remove duplicates
-
-    def get_total_usage_count(self) -> int:
-        """Get total usage count across all impacts."""
-        return sum(impact.get('usage_count', 0) for impact in self.impacts)
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary."""
-        return {
-            'source_workspace': self.source_workspace,
-            'target_workspace': self.target_workspace,
-            'change_commit': self.change_commit,
-            'severity': self.severity,
-            'impact_count': len(self.impacts),
-            'impacts': self.impacts,
-            'recommendations': self.recommendations,
-            'analyzed_at': self.analyzed_at.isoformat(),
-            'affected_files': self.get_affected_files(),
-            'total_usage_count': self.get_total_usage_count()
-        }
-
-    def to_toon(self) -> str:
-        """
-        Convert to TOON format for token efficiency.
-
-        Returns:
-            Compact string: ok:impact,src:X,tgt:Y,severity:Z,count:N
-        """
-        return (
-            f"ok:impact,src:{self.source_workspace},"
-            f"tgt:{self.target_workspace},severity:{self.severity},"
-            f"count:{len(self.impacts)},files:{len(self.get_affected_files())}"
-        )
-
-
-@dataclass(frozen=True)
-class WorkspaceContext(ValueObject):
-    """
-    Immutable workspace context for context switching.
-
-    Contains all information needed to work within a specific workspace.
-    """
-    name: str
-    external_path: Optional[Path]
-    tech_stack: List[str]
-    domains: List[str]
-    phase: str
-
-    def __post_init__(self):
-        """Initialize and validate context."""
-        if self.tech_stack is None:
-            object.__setattr__(self, 'tech_stack', [])
-        if self.domains is None:
-            object.__setattr__(self, 'domains', [])
-
-        # Convert string path to Path
-        if isinstance(self.external_path, str):
-            object.__setattr__(self, 'external_path', Path(self.external_path))
-
-        self.validate()
-
-    def validate(self) -> bool:
-        """Validate workspace context."""
-        if not self.name or not self.name.strip():
-            raise ValidationError("workspace name cannot be empty")
-
-        if not self.phase or not self.phase.strip():
-            raise ValidationError("phase cannot be empty")
-
-        return True
-
-    def has_external_path(self) -> bool:
-        """Check if workspace has external path configured."""
-        return self.external_path is not None and self.external_path.exists()
-
-    def is_git_repository(self) -> bool:
-        """Check if external path is a git repository."""
-        if not self.has_external_path():
-            return False
-
-        git_dir = self.external_path / '.git'
-        return git_dir.exists()
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary."""
-        return {
-            'name': self.name,
-            'external_path': str(self.external_path) if self.external_path else None,
-            'tech_stack': self.tech_stack,
-            'domains': self.domains,
-            'phase': self.phase,
-            'has_external_path': self.has_external_path(),
-            'is_git_repository': self.is_git_repository()
-        }
-
-    def to_toon(self) -> str:
-        """
-        Convert to TOON format for token efficiency.
-
-        Returns:
-            Compact string: name:X,path:Y,tech:N,phase:Z
-        """
-        return (
-            f"name:{self.name},path:{'yes' if self.has_external_path() else 'no'},"
-            f"tech:{len(self.tech_stack)},phase:{self.phase}"
-        )

package/src/domain/workspace/entities.py

@@ -1,184 +0,0 @@
-"""
-Entities for Workspace bounded context.
-
-Domain entities representing workspace dependencies and relationships.
-"""
-
-from typing import Optional, List, Dict
-from datetime import datetime
-from enum import Enum
-
-from ..shared import Entity, ValidationError
-
-
-class DependencyType(Enum):
-    """Types of workspace dependencies."""
-    CODE = "code"  # Source code library dependency
-    DATA = "data"  # Data schema or database dependency
-    API = "api"  # API/service dependency
-    BUILD = "build"  # Build system dependency
-    CONFIG = "config"  # Configuration dependency
-
-
-class WorkspaceDependency(Entity):
-    """
-    Entity representing a dependency relationship between workspaces.
-
-    A dependency indicates that one workspace (source) depends on another (target).
-    For example, an Android app workspace depends on a Kotlin library workspace.
-    """
-
-    def __init__(
-        self,
-        source_workspace: str,
-        target_workspace: str,
-        dependency_type: DependencyType,
-        version_constraint: Optional[str] = None,
-        is_active: bool = True,
-        metadata: Optional[Dict] = None,
-        id: Optional[str] = None
-    ):
-        """
-        Initialize workspace dependency.
-
-        Args:
-            source_workspace: Name of workspace that depends (consumer)
-            target_workspace: Name of workspace providing the dependency (provider)
-            dependency_type: Type of dependency (code, data, api, build, config)
-            version_constraint: Optional version requirement (e.g., ">=1.2.0")
-            is_active: Whether dependency is currently active
-            metadata: Additional metadata (paths, integration points, etc.)
-            id: Optional entity ID
-        """
-        super().__init__(id)
-        self.source_workspace = source_workspace
-        self.target_workspace = target_workspace
-        self.dependency_type = dependency_type
-        self.version_constraint = version_constraint
-        self.is_active = is_active
-        self.metadata = metadata or {}
-
-        # Validate on creation
-        self.validate()
-
-    def validate(self) -> bool:
-        """Validate dependency integrity."""
-        if not self.source_workspace or not self.source_workspace.strip():
-            raise ValidationError("Source workspace cannot be empty")
-
-        if not self.target_workspace or not self.target_workspace.strip():
-            raise ValidationError("Target workspace cannot be empty")
-
-        if self.source_workspace == self.target_workspace:
-            raise ValidationError(
-                f"Self-dependency not allowed: {self.source_workspace}"
-            )
-
-        if not isinstance(self.dependency_type, DependencyType):
-            raise ValidationError(
-                f"Invalid dependency type: {self.dependency_type}"
-            )
-
-        return True
-
-    def deactivate(self, reason: Optional[str] = None) -> None:
-        """Deactivate this dependency."""
-        if not self.is_active:
-            raise ValidationError("Dependency is already inactive")
-
-        self.is_active = False
-        self.update_timestamp()
-
-        if reason:
-            self.metadata["deactivation_reason"] = reason
-            self.metadata["deactivated_at"] = datetime.now().isoformat()
-
-    def activate(self) -> None:
-        """Activate this dependency."""
-        if self.is_active:
-            raise ValidationError("Dependency is already active")
-
-        self.is_active = True
-        self.update_timestamp()
-
-        # Clear deactivation metadata
-        self.metadata.pop("deactivation_reason", None)
-        self.metadata.pop("deactivated_at", None)
-
-    def update_version(self, new_version: str) -> None:
-        """Update version constraint."""
-        old_version = self.version_constraint
-        self.version_constraint = new_version
-        self.update_timestamp()
-
-        # Track version history
-        if "version_history" not in self.metadata:
-            self.metadata["version_history"] = []
-
-        self.metadata["version_history"].append({
-            "from": old_version,
-            "to": new_version,
-            "updated_at": datetime.now().isoformat()
-        })
-
-    def add_integration_point(self, file_path: str, description: Optional[str] = None) -> None:
-        """
-        Add an integration point (file that uses the dependency).
-
-        Args:
-            file_path: Path to file that uses the dependency
-            description: Optional description of how it's used
-        """
-        if "integration_points" not in self.metadata:
-            self.metadata["integration_points"] = []
-
-        self.metadata["integration_points"].append({
-            "file_path": file_path,
-            "description": description,
-            "added_at": datetime.now().isoformat()
-        })
-        self.update_timestamp()
-
-    def remove_integration_point(self, file_path: str) -> None:
-        """Remove an integration point."""
-        if "integration_points" not in self.metadata:
-            return
-
-        self.metadata["integration_points"] = [
-            point for point in self.metadata["integration_points"]
-            if point["file_path"] != file_path
-        ]
-        self.update_timestamp()
-
-    def get_integration_points(self) -> List[str]:
-        """Get list of files that use this dependency."""
-        if "integration_points" not in self.metadata:
-            return []
-
-        return [
-            point["file_path"]
-            for point in self.metadata["integration_points"]
-        ]
-
-    def to_dict(self) -> Dict:
-        """Convert to dictionary for serialization."""
-        return {
-            "id": self.id,
-            "source_workspace": self.source_workspace,
-            "target_workspace": self.target_workspace,
-            "dependency_type": self.dependency_type.value,
-            "version_constraint": self.version_constraint,
-            "is_active": self.is_active,
-            "metadata": self.metadata,
-            "created_at": self.created_at.isoformat(),
-            "updated_at": self.updated_at.isoformat()
-        }
-
-    def __repr__(self) -> str:
-        return (
-            f"WorkspaceDependency("
-            f"source={self.source_workspace}, "
-            f"target={self.target_workspace}, "
-            f"type={self.dependency_type.value}, "
-            f"active={self.is_active})"
-        )

package/src/domain/workspace/event_handlers.py

@@ -1,140 +0,0 @@
-"""
-Event Handler interfaces for Workspace bounded context.
-
-Abstract handlers following the Strategy pattern for processing
-workspace domain events.
-"""
-
-from abc import ABC, abstractmethod
-from typing import List, Type
-from .events import WorkspaceEvent
-
-
-class WorkspaceEventHandler(ABC):
-    """
-    Abstract event handler for workspace domain events.
-
-    Implements Strategy pattern allowing different handling strategies
-    for different event types while maintaining Open/Closed Principle.
-    """
-
-    @abstractmethod
-    def can_handle(self, event: WorkspaceEvent) -> bool:
-        """
-        Check if this handler can process the given event.
-
-        Args:
-            event: WorkspaceEvent to evaluate
-
-        Returns:
-            True if handler can process this event type
-        """
-        pass
-
-    @abstractmethod
-    def handle(self, event: WorkspaceEvent) -> None:
-        """
-        Handle the workspace event.
-
-        Args:
-            event: WorkspaceEvent to process
-
-        Raises:
-            Exception: If event handling fails
-        """
-        pass
-
-    def get_supported_event_types(self) -> List[Type[WorkspaceEvent]]:
-        """
-        Get list of event types this handler supports.
-
-        Returns:
-            List of WorkspaceEvent subclasses this handler can process
-        """
-        return []
-
-
-class CompositeEventHandler(WorkspaceEventHandler):
-    """
-    Composite handler that delegates to multiple child handlers.
-
-    Implements Composite pattern for complex event handling scenarios
-    where multiple handlers need to process the same event.
-    """
-
-    def __init__(self, handlers: List[WorkspaceEventHandler]):
-        """
-        Initialize composite handler.
-
-        Args:
-            handlers: List of child handlers to delegate to
-        """
-        self.handlers = handlers
-
-    def can_handle(self, event: WorkspaceEvent) -> bool:
-        """Check if any child handler can process the event."""
-        return any(handler.can_handle(event) for handler in self.handlers)
-
-    def handle(self, event: WorkspaceEvent) -> None:
-        """
-        Delegate event to all capable child handlers.
-
-        Handlers execute in registration order. If any handler fails,
-        subsequent handlers are still attempted to ensure all
-        side effects are processed.
-        """
-        errors = []
-        for handler in self.handlers:
-            if handler.can_handle(event):
-                try:
-                    handler.handle(event)
-                except Exception as e:
-                    errors.append((handler.__class__.__name__, str(e)))
-
-        if errors:
-            error_summary = "; ".join(
-                f"{handler}: {error}" for handler, error in errors
-            )
-            raise Exception(f"Composite handler errors: {error_summary}")
-
-    def get_supported_event_types(self) -> List[Type[WorkspaceEvent]]:
-        """Get union of all supported event types from child handlers."""
-        types = set()
-        for handler in self.handlers:
-            types.update(handler.get_supported_event_types())
-        return list(types)
-
-
-class AsyncEventHandler(WorkspaceEventHandler):
-    """
-    Base class for asynchronous event handlers.
-
-    Provides foundation for handlers that need to perform
-    non-blocking operations like external API calls or
-    long-running background tasks.
-    """
-
-    @abstractmethod
-    async def handle_async(self, event: WorkspaceEvent) -> None:
-        """
-        Handle event asynchronously.
-
-        Args:
-            event: WorkspaceEvent to process
-
-        Raises:
-            Exception: If async event handling fails
-        """
-        pass
-
-    def handle(self, event: WorkspaceEvent) -> None:
-        """
-        Synchronous wrapper for async handling.
-
-        For synchronous contexts, this method can be implemented
-        to queue the event for async processing or execute
-        synchronously using asyncio.run().
-        """
-        raise NotImplementedError(
-            "AsyncEventHandler requires async context or custom sync wrapper"
-        )