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

monoco/core/automation/config.py

@@ -1,338 +0,0 @@
-"""
-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}")

monoco/core/execution.py

@@ -1,67 +0,0 @@
-from pathlib import Path
-from typing import List, Optional
-from pydantic import BaseModel
-
-
-class ExecutionProfile(BaseModel):
-    name: str
-    source: str  # "Global" or "Project"
-    path: str
-    content: Optional[str] = None
-
-
-def scan_execution_profiles(
-    project_root: Optional[Path] = None,
-) -> List[ExecutionProfile]:
-    """
-    Scan for execution profiles (SOPs) in global and project scopes.
-    """
-    profiles = []
-
-    # 1. Global Scope
-    global_path = Path.home() / ".monoco" / "execution"
-    if global_path.exists():
-        profiles.extend(_scan_dir(global_path, "Global"))
-
-    # 2. Project Scope
-    if project_root:
-        project_path = project_root / ".monoco" / "execution"
-        if project_path.exists():
-            profiles.extend(_scan_dir(project_path, "Project"))
-
-    return profiles
-
-
-def _scan_dir(base_path: Path, source: str) -> List[ExecutionProfile]:
-    profiles = []
-    if not base_path.is_dir():
-        return profiles
-
-    for item in base_path.iterdir():
-        if item.is_dir():
-            sop_path = item / "SOP.md"
-            if sop_path.exists():
-                profiles.append(
-                    ExecutionProfile(
-                        name=item.name, source=source, path=str(sop_path.absolute())
-                    )
-                )
-    return profiles
-
-
-def get_profile_detail(profile_path: str) -> Optional[ExecutionProfile]:
-    path = Path(profile_path)
-    if not path.exists():
-        return None
-
-    # Determine source (rough heuristic)
-    source = "Project"
-    if str(path).startswith(str(Path.home() / ".monoco")):
-        source = "Global"
-
-    return ExecutionProfile(
-        name=path.parent.name,
-        source=source,
-        path=str(path.absolute()),
-        content=path.read_text(encoding="utf-8"),
-    )

monoco/core/executor/__init__.py

@@ -1,38 +0,0 @@
-"""
-Executor Module - Layer 3 of the Event Automation Framework.
-
-This module provides concrete Action implementations for various execution types.
-It is part of the three-layer architecture:
-- Layer 1: File Watcher
-- Layer 2: Action Router
-- Layer 3: Action Executor (this module)
-
-Available Actions:
-- SpawnAgentAction: Spawn agent sessions
-- RunPytestAction: Execute pytest tests
-- GitCommitAction: Perform git commits
-- GitPushAction: Push to remote
-- SendIMAction: Send notifications
-
-Example Usage:
-    >>> from monoco.core.executor import SpawnAgentAction
-    >>> from monoco.core.scheduler import AgentEventType
-    >>> from monoco.core.router import ActionRouter
-    >>> 
-    >>> action = SpawnAgentAction(role="Engineer")
-    >>> router = ActionRouter()
-    >>> router.register(AgentEventType.ISSUE_STAGE_CHANGED, action)
-"""
-
-from .agent_action import SpawnAgentAction
-from .pytest_action import RunPytestAction
-from .git_action import GitCommitAction, GitPushAction
-from .im_action import SendIMAction
-
-__all__ = [
-    "SpawnAgentAction",
-    "RunPytestAction",
-    "GitCommitAction",
-    "GitPushAction",
-    "SendIMAction",
-]

monoco/core/executor/agent_action.py

@@ -1,254 +0,0 @@
-"""
-SpawnAgentAction - Action for spawning agent sessions.
-
-Part of Layer 3 (Action Executor) in the event automation framework.
-Uses AgentScheduler to spawn and manage agent sessions.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Dict, List, Optional
-
-from monoco.core.scheduler import AgentEvent, AgentEventType, AgentScheduler, AgentTask
-from monoco.core.router import Action, ActionResult
-from monoco.features.agent.models import RoleTemplate
-
-logger = logging.getLogger(__name__)
-
-
-class SpawnAgentAction(Action):
-    """
-    Action that spawns an agent session.
-    
-    This action creates and starts a new agent session based on the event.
-    It supports different roles (Architect, Engineer, Reviewer, etc.)
-    and integrates with the AgentScheduler for lifecycle management.
-    
-    Example:
-        >>> action = SpawnAgentAction(
-        ...     role="Engineer",
-        ...     scheduler=scheduler,
-        ... )
-        >>> result = await action(event)
-    """
-    
-    ROLE_TEMPLATES = {
-        "Architect": {
-            "description": "System Architect",
-            "trigger": "memo.accumulation",
-            "goal": "Process memo inbox and create issues.",
-            "system_prompt": "You are the Architect. Process the Memo inbox.",
-            "engine": "gemini",
-        },
-        "Engineer": {
-            "description": "Software Engineer",
-            "trigger": "issue.stage_changed",
-            "goal": "Implement feature requirements.",
-            "system_prompt": "You are a Software Engineer. Read the issue and implement requirements.",
-            "engine": "gemini",
-        },
-        "Reviewer": {
-            "description": "Code Reviewer",
-            "trigger": "pr.created",
-            "goal": "Review code changes thoroughly.",
-            "system_prompt": "You are a Code Reviewer. Review the code changes thoroughly.",
-            "engine": "gemini",
-        },
-        "Coroner": {
-            "description": "Session Autopsy",
-            "trigger": "session.failed",
-            "goal": "Analyze failed session and create incident report.",
-            "system_prompt": "You are the Coroner. Analyze the failed session.",
-            "engine": "gemini",
-        },
-    }
-    
-    def __init__(
-        self,
-        role: str,
-        scheduler: AgentScheduler,
-        config: Optional[Dict[str, Any]] = None,
-        custom_role_template: Optional[Dict[str, str]] = None,
-    ):
-        super().__init__(config)
-        self.role = role
-        self.scheduler = scheduler
-        self.custom_role_template = custom_role_template
-        self._spawned_sessions: List[str] = []
-    
-    @property
-    def name(self) -> str:
-        return f"SpawnAgentAction({self.role})"
-    
-    async def can_execute(self, event: AgentEvent) -> bool:
-        """
-        Check if we should spawn an agent.
-        
-        Conditions:
-        - Scheduler has capacity for new tasks
-        """
-        # Check scheduler capacity
-        stats = self.scheduler.get_stats()
-        active_tasks = stats.get("active_tasks", 0)
-        max_concurrent = stats.get("max_concurrent", 5)
-        
-        if active_tasks >= max_concurrent:
-            logger.warning(f"Scheduler at capacity ({active_tasks}/{max_concurrent}), skipping")
-            return False
-        
-        return True
-    
-    async def execute(self, event: AgentEvent) -> ActionResult:
-        """Spawn an agent session."""
-        issue_id = event.payload.get("issue_id", "unknown")
-        issue_title = event.payload.get("issue_title", "Unknown")
-        
-        logger.info(f"Spawning {self.role} agent for {issue_id}")
-        
-        try:
-            # Create AgentTask
-            task = AgentTask(
-                task_id=f"{self.role.lower()}-{issue_id}-{event.timestamp.timestamp()}",
-                role_name=self.role,
-                issue_id=issue_id,
-                prompt=self._build_prompt(issue_id, issue_title),
-                engine=self._get_engine(),
-                timeout=self.config.get("timeout", 1800),
-                metadata={
-                    "trigger": event.type.value,
-                    "issue_title": issue_title,
-                },
-            )
-            
-            # Schedule task
-            session_id = await self.scheduler.schedule(task)
-            
-            # Track spawned session
-            self._spawned_sessions.append(session_id)
-            
-            logger.info(f"{self.role} scheduled: session={session_id}")
-            
-            return ActionResult.success_result(
-                output={
-                    "session_id": session_id,
-                    "issue_id": issue_id,
-                    "role": self.role,
-                },
-                metadata={
-                    "task_id": task.task_id,
-                },
-            )
-        
-        except Exception as e:
-            logger.error(f"Failed to spawn {self.role} for {issue_id}: {e}")
-            return ActionResult.failure_result(
-                error=str(e),
-                metadata={
-                    "issue_id": issue_id,
-                    "role": self.role,
-                },
-            )
-    
-    def _build_prompt(self, issue_id: str, issue_title: str) -> str:
-        """Build the prompt for the agent."""
-        template = self.ROLE_TEMPLATES.get(self.role, self.ROLE_TEMPLATES["Engineer"])
-        
-        return f"""You are a {template['description']}. 
-
-Issue: {issue_id} - {issue_title}
-
-Goal: {template['goal']}
-
-{template['system_prompt']}
-"""
-    
-    def _get_engine(self) -> str:
-        """Get the engine for this role."""
-        if self.custom_role_template:
-            return self.custom_role_template.get("engine", "gemini")
-        template = self.ROLE_TEMPLATES.get(self.role, self.ROLE_TEMPLATES["Engineer"])
-        return template["engine"]
-    
-    def get_spawned_sessions(self) -> List[str]:
-        """Get list of session IDs spawned by this action."""
-        return self._spawned_sessions.copy()
-    
-    def get_stats(self) -> Dict[str, Any]:
-        """Get action statistics."""
-        stats = super().get_stats()
-        stats.update({
-            "role": self.role,
-            "spawned_sessions": len(self._spawned_sessions),
-        })
-        return stats
-
-
-class SpawnArchitectAction(SpawnAgentAction):
-    """Convenience action for spawning Architect agents."""
-    
-    def __init__(
-        self,
-        scheduler: AgentScheduler,
-        config: Optional[Dict[str, Any]] = None,
-    ):
-        super().__init__(
-            role="Architect",
-            scheduler=scheduler,
-            config=config,
-        )
-    
-    async def can_execute(self, event: AgentEvent) -> bool:
-        """Only execute for MEMO_THRESHOLD events."""
-        if event.type != AgentEventType.MEMO_THRESHOLD:
-            return False
-        return await super().can_execute(event)
-
-
-class SpawnEngineerAction(SpawnAgentAction):
-    """Convenience action for spawning Engineer agents."""
-    
-    def __init__(
-        self,
-        scheduler: AgentScheduler,
-        config: Optional[Dict[str, Any]] = None,
-    ):
-        super().__init__(
-            role="Engineer",
-            scheduler=scheduler,
-            config=config,
-        )
-    
-    async def can_execute(self, event: AgentEvent) -> bool:
-        """Only execute for ISSUE_STAGE_CHANGED to 'doing' events."""
-        if event.type != AgentEventType.ISSUE_STAGE_CHANGED:
-            return False
-        
-        new_stage = event.payload.get("new_stage")
-        issue_status = event.payload.get("issue_status")
-        
-        if new_stage != "doing" or issue_status != "open":
-            return False
-        
-        return await super().can_execute(event)
-
-
-class SpawnReviewerAction(SpawnAgentAction):
-    """Convenience action for spawning Reviewer agents."""
-    
-    def __init__(
-        self,
-        scheduler: AgentScheduler,
-        config: Optional[Dict[str, Any]] = None,
-    ):
-        super().__init__(
-            role="Reviewer",
-            scheduler=scheduler,
-            config=config,
-        )
-    
-    async def can_execute(self, event: AgentEvent) -> bool:
-        """Only execute for PR_CREATED events."""
-        if event.type != AgentEventType.PR_CREATED:
-            return False
-        return await super().can_execute(event)