monoco-toolkit 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

monoco/core/artifacts/models.py

@@ -0,0 +1,161 @@
+"""
+Artifact data models for Monoco Artifact System.
+
+Defines the metadata structure, enums, and data classes for artifact management.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class ArtifactSourceType(str, Enum):
+    """Source type of the artifact."""
+
+    GENERATED = "generated"  # AI-generated content
+    UPLOADED = "uploaded"  # User-uploaded file
+    IMPORTED = "imported"  # Imported from external source
+    DERIVED = "derived"  # Derived from another artifact
+
+
+class ArtifactStatus(str, Enum):
+    """Lifecycle status of the artifact."""
+
+    ACTIVE = "active"
+    ARCHIVED = "archived"
+    EXPIRED = "expired"
+    DELETED = "deleted"
+
+
+class ArtifactMetadata(BaseModel):
+    """
+    Metadata record for an artifact in the manifest.
+
+    Each artifact is uniquely identified by its content hash (SHA256).
+    The manifest.jsonl contains one JSON line per artifact metadata.
+    """
+
+    artifact_id: str = Field(
+        description="Unique identifier (ULID or UUID) for the artifact instance"
+    )
+    content_hash: str = Field(
+        description="SHA256 hash of the artifact content (CAS address)"
+    )
+    source_type: ArtifactSourceType = Field(description="How the artifact was created")
+    status: ArtifactStatus = Field(
+        default=ArtifactStatus.ACTIVE, description="Current lifecycle status"
+    )
+    created_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc), description="Creation timestamp (UTC)"
+    )
+    updated_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc), description="Last update timestamp (UTC)"
+    )
+    expires_at: Optional[datetime] = Field(
+        default=None, description="Optional expiration timestamp"
+    )
+    content_type: str = Field(
+        default="application/octet-stream", description="MIME type of the content"
+    )
+    size_bytes: int = Field(default=0, description="Size of the artifact in bytes")
+    original_filename: Optional[str] = Field(
+        default=None, description="Original filename if uploaded"
+    )
+    source_url: Optional[str] = Field(
+        default=None, description="Source URL if imported from external"
+    )
+    parent_artifact_id: Optional[str] = Field(
+        default=None, description="Parent artifact ID if this is derived"
+    )
+    tags: list[str] = Field(default_factory=list, description="User-defined tags")
+    metadata: dict[str, Any] = Field(
+        default_factory=dict, description="Additional metadata key-value pairs"
+    )
+
+    @field_validator("content_hash")
+    @classmethod
+    def validate_content_hash(cls, v: str) -> str:
+        """Validate that content_hash is a valid SHA256 hex string."""
+        if len(v) != 64:
+            raise ValueError("content_hash must be a 64-character SHA256 hex string")
+        try:
+            int(v, 16)
+        except ValueError:
+            raise ValueError("content_hash must be a valid hex string")
+        return v
+
+    def to_jsonl_line(self) -> str:
+        """Serialize to a single JSON line for manifest.jsonl."""
+        return json.dumps(self.model_dump(mode="json"), ensure_ascii=False) + "\n"
+
+    @classmethod
+    def from_jsonl_line(cls, line: str) -> ArtifactMetadata:
+        """Deserialize from a JSON line."""
+        data = json.loads(line.strip())
+        return cls.model_validate(data)
+
+    @property
+    def is_expired(self) -> bool:
+        """Check if the artifact has expired."""
+        if self.expires_at is None:
+            return False
+        return datetime.now(timezone.utc) > self.expires_at
+
+    @property
+    def cas_path_components(self) -> tuple[str, str, str]:
+        """
+        Generate CAS storage path components from content_hash.
+
+        Returns (prefix1, prefix2, filename) for tiered directory structure.
+        Example: hash='abc123...' -> ('ab', 'c1', 'abc123...')
+        """
+        if len(self.content_hash) < 4:
+            raise ValueError("content_hash too short for path generation")
+        return (
+            self.content_hash[:2],
+            self.content_hash[2:4],
+            self.content_hash,
+        )
+
+    @property
+    def cas_relative_path(self) -> str:
+        """Get the relative CAS path for this artifact."""
+        p1, p2, filename = self.cas_path_components
+        return f"{p1}/{p2}/{filename}"
+
+
+def compute_content_hash(content: bytes) -> str:
+    """
+    Compute SHA256 hash of content for CAS addressing.
+
+    Args:
+        content: Raw bytes of the artifact content
+
+    Returns:
+        64-character lowercase hex string of the SHA256 hash
+    """
+    return hashlib.sha256(content).hexdigest()
+
+
+def compute_file_hash(file_path: Path) -> str:
+    """
+    Compute SHA256 hash of a file for CAS addressing.
+
+    Args:
+        file_path: Path to the file to hash
+
+    Returns:
+        64-character lowercase hex string of the SHA256 hash
+    """
+    hasher = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            hasher.update(chunk)
+    return hasher.hexdigest()

monoco/core/automation/__init__.py

@@ -0,0 +1,51 @@
+"""
+Automation Module - Event-driven automation framework.
+
+This module provides:
+- YAML/JSON configuration parsing
+- Trigger configuration management
+- Field change detection
+- Independent Event Handlers for Agent collaboration (FEAT-0162)
+
+Architecture: No Workflow or Orchestration. Each handler is an independent,
+stateless microservice that responds to specific events. Workflow emerges
+from the natural interaction of handlers.
+"""
+
+from .config import (
+    TriggerConfig,
+    AutomationConfig,
+    load_automation_config,
+)
+from .field_watcher import (
+    YAMLFrontMatterExtractor,
+    FieldWatcher,
+    FieldCondition,
+)
+from .handlers import (
+    TaskFileHandler,
+    IssueStageHandler,
+    MemoThresholdHandler,
+    PRCreatedHandler,
+    start_all_handlers,
+    stop_all_handlers,
+)
+
+__all__ = [
+    # Config
+    "TriggerConfig",
+    "AutomationConfig",
+    "load_automation_config",
+    # Field watching
+    "YAMLFrontMatterExtractor",
+    "FieldWatcher",
+    "FieldCondition",
+    # Independent Event Handlers (FEAT-0162)
+    "TaskFileHandler",
+    "IssueStageHandler",
+    "MemoThresholdHandler",
+    "PRCreatedHandler",
+    # Convenience functions
+    "start_all_handlers",
+    "stop_all_handlers",
+]

monoco/core/automation/config.py

@@ -0,0 +1,338 @@
+"""
+Automation Configuration - YAML/JSON configuration for triggers.
+
+Part of the Event Automation Framework.
+Provides configuration schema and loading for automation triggers.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field as dataclass_field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import yaml
+
+from monoco.core.scheduler import AgentEventType
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ActionConfig:
+    """Configuration for an action."""
+    type: str
+    params: Dict[str, Any] = dataclass_field(default_factory=dict)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ActionConfig":
+        """Create from dict."""
+        return cls(
+            type=data.get("type", ""),
+            params=data.get("params", {}),
+        )
+
+
+@dataclass
+class TriggerConfig:
+    """
+    Configuration for a trigger.
+    
+    Attributes:
+        name: Unique trigger name
+        watcher: Watcher type (IssueWatcher, MemoWatcher, etc.)
+        event_type: Event type to listen for
+        condition: Optional condition expression
+        field: Optional field to watch (for field-level triggers)
+        actions: List of actions to execute
+        enabled: Whether trigger is enabled
+    """
+    name: str
+    watcher: str
+    event_type: Optional[str] = None
+    condition: Optional[str] = None
+    field: Optional[str] = None
+    actions: List[ActionConfig] = dataclass_field(default_factory=list)
+    enabled: bool = True
+    priority: int = 0
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TriggerConfig":
+        """Create from dict."""
+        actions = [
+            ActionConfig.from_dict(a) if isinstance(a, dict) else ActionConfig(type=a)
+            for a in data.get("actions", [])
+        ]
+        
+        return cls(
+            name=data.get("name", "unnamed"),
+            watcher=data.get("watcher", ""),
+            event_type=data.get("event_type"),
+            condition=data.get("condition"),
+            field=data.get("field"),
+            actions=actions,
+            enabled=data.get("enabled", True),
+            priority=data.get("priority", 0),
+        )
+    
+    def to_agent_event_type(self) -> Optional[AgentEventType]:
+        """Convert event_type string to AgentEventType."""
+        if not self.event_type:
+            return None
+        
+        try:
+            return AgentEventType(self.event_type)
+        except ValueError:
+            # Try to map common patterns
+            mapping = {
+                "issue.created": AgentEventType.ISSUE_CREATED,
+                "issue.updated": AgentEventType.ISSUE_UPDATED,
+                "issue.stage_changed": AgentEventType.ISSUE_STAGE_CHANGED,
+                "issue.status_changed": AgentEventType.ISSUE_STATUS_CHANGED,
+                "memo.created": AgentEventType.MEMO_CREATED,
+                "memo.threshold": AgentEventType.MEMO_THRESHOLD,
+                "session.completed": AgentEventType.SESSION_COMPLETED,
+                "session.failed": AgentEventType.SESSION_FAILED,
+                "pr.created": AgentEventType.PR_CREATED,
+            }
+            return mapping.get(self.event_type)
+
+
+@dataclass
+class AutomationConfig:
+    """
+    Complete automation configuration.
+    
+    Attributes:
+        version: Configuration version
+        triggers: List of trigger configurations
+        settings: Global settings
+    """
+    version: str = "1.0"
+    triggers: List[TriggerConfig] = dataclass_field(default_factory=list)
+    settings: Dict[str, Any] = dataclass_field(default_factory=dict)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AutomationConfig":
+        """Create from dict."""
+        triggers = [
+            TriggerConfig.from_dict(t)
+            for t in data.get("triggers", [])
+        ]
+        
+        return cls(
+            version=data.get("version", "1.0"),
+            triggers=triggers,
+            settings=data.get("settings", {}),
+        )
+    
+    @classmethod
+    def from_yaml(cls, yaml_content: str) -> "AutomationConfig":
+        """Load from YAML string."""
+        data = yaml.safe_load(yaml_content)
+        return cls.from_dict(data or {})
+    
+    @classmethod
+    def from_json(cls, json_content: str) -> "AutomationConfig":
+        """Load from JSON string."""
+        data = json.loads(json_content)
+        return cls.from_dict(data)
+    
+    def to_yaml(self) -> str:
+        """Export to YAML string."""
+        data = {
+            "version": self.version,
+            "triggers": [
+                {
+                    "name": t.name,
+                    "watcher": t.watcher,
+                    "event_type": t.event_type,
+                    "condition": t.condition,
+                    "field": t.field,
+                    "actions": [
+                        {"type": a.type, "params": a.params}
+                        for a in t.actions
+                    ],
+                    "enabled": t.enabled,
+                    "priority": t.priority,
+                }
+                for t in self.triggers
+            ],
+            "settings": self.settings,
+        }
+        return yaml.dump(data, default_flow_style=False, sort_keys=False)
+    
+    def to_json(self) -> str:
+        """Export to JSON string."""
+        data = {
+            "version": self.version,
+            "triggers": [
+                {
+                    "name": t.name,
+                    "watcher": t.watcher,
+                    "event_type": t.event_type,
+                    "condition": t.condition,
+                    "field": t.field,
+                    "actions": [
+                        {"type": a.type, "params": a.params}
+                        for a in t.actions
+                    ],
+                    "enabled": t.enabled,
+                    "priority": t.priority,
+                }
+                for t in self.triggers
+            ],
+            "settings": self.settings,
+        }
+        return json.dumps(data, indent=2)
+    
+    def get_enabled_triggers(self) -> List[TriggerConfig]:
+        """Get all enabled triggers."""
+        return [t for t in self.triggers if t.enabled]
+    
+    def get_trigger(self, name: str) -> Optional[TriggerConfig]:
+        """Get trigger by name."""
+        for trigger in self.triggers:
+            if trigger.name == name:
+                return trigger
+        return None
+    
+    def add_trigger(self, trigger: TriggerConfig) -> None:
+        """Add a trigger."""
+        # Remove existing trigger with same name
+        self.triggers = [t for t in self.triggers if t.name != trigger.name]
+        self.triggers.append(trigger)
+    
+    def remove_trigger(self, name: str) -> bool:
+        """Remove a trigger by name."""
+        original_count = len(self.triggers)
+        self.triggers = [t for t in self.triggers if t.name != name]
+        return len(self.triggers) < original_count
+
+
+def load_automation_config(
+    path: Union[str, Path],
+    create_default: bool = False,
+) -> AutomationConfig:
+    """
+    Load automation configuration from file.
+    
+    Supports .yaml, .yml, and .json files.
+    
+    Args:
+        path: Path to configuration file
+        create_default: If True and file doesn't exist, create default config
+        
+    Returns:
+        AutomationConfig instance
+    """
+    path = Path(path)
+    
+    if not path.exists():
+        if create_default:
+            default_config = create_default_config()
+            path.write_text(default_config.to_yaml())
+            logger.info(f"Created default automation config at {path}")
+            return default_config
+        else:
+            logger.warning(f"Config file not found: {path}")
+            return AutomationConfig()
+    
+    content = path.read_text(encoding="utf-8")
+    
+    if path.suffix in (".yaml", ".yml"):
+        return AutomationConfig.from_yaml(content)
+    elif path.suffix == ".json":
+        return AutomationConfig.from_json(content)
+    else:
+        # Try YAML first, then JSON
+        try:
+            return AutomationConfig.from_yaml(content)
+        except yaml.YAMLError:
+            return AutomationConfig.from_json(content)
+
+
+def create_default_config() -> AutomationConfig:
+    """Create a default automation configuration."""
+    return AutomationConfig(
+        version="1.0",
+        triggers=[
+            TriggerConfig(
+                name="memo_threshold",
+                watcher="MemoWatcher",
+                event_type="memo.threshold",
+                condition="pending_count >= 5",
+                actions=[
+                    ActionConfig(
+                        type="SpawnAgentAction",
+                        params={"role": "Architect"},
+                    ),
+                ],
+            ),
+            TriggerConfig(
+                name="issue_doing",
+                watcher="IssueWatcher",
+                event_type="issue.stage_changed",
+                field="stage",
+                condition="value == 'doing'",
+                actions=[
+                    ActionConfig(
+                        type="SpawnAgentAction",
+                        params={"role": "Engineer"},
+                    ),
+                ],
+            ),
+            TriggerConfig(
+                name="issue_completed",
+                watcher="IssueWatcher",
+                event_type="issue.stage_changed",
+                field="stage",
+                condition="value == 'done'",
+                actions=[
+                    ActionConfig(
+                        type="SendIMAction",
+                        params={
+                            "channel": "console",
+                            "message_template": "Issue {issue_id} completed!",
+                        },
+                    ),
+                ],
+            ),
+        ],
+        settings={
+            "default_poll_interval": 5.0,
+            "max_concurrent_actions": 10,
+            "action_timeout": 300,
+        },
+    )
+
+
+def save_automation_config(
+    config: AutomationConfig,
+    path: Union[str, Path],
+    format: str = "yaml",
+) -> None:
+    """
+    Save automation configuration to file.
+    
+    Args:
+        config: Configuration to save
+        path: Path to save to
+        format: "yaml" or "json"
+    """
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    
+    if format == "yaml":
+        content = config.to_yaml()
+        if path.suffix not in (".yaml", ".yml"):
+            path = path.with_suffix(".yaml")
+    else:
+        content = config.to_json()
+        if path.suffix != ".json":
+            path = path.with_suffix(".json")
+    
+    path.write_text(content, encoding="utf-8")
+    logger.info(f"Saved automation config to {path}")