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

monoco/core/injection.py

@@ -1,6 +1,6 @@
 import re
 from pathlib import Path
-from typing import Dict
+from typing import Dict, Optional
 
 
 class PromptInjector:
@@ -13,8 +13,52 @@ class PromptInjector:
     MANAGED_START = "<!-- MONOCO_GENERATED_START -->"
     MANAGED_END = "<!-- MONOCO_GENERATED_END -->"
 
-    def __init__(self, target_file: Path):
+    FILE_HEADER_COMMENT = """<!--
+⚠️ IMPORTANT: This file is partially managed by Monoco.
+- Content between MONOCO_GENERATED_START and MONOCO_GENERATED_END is auto-generated.
+- Do NOT manually edit the managed block.
+- Do NOT add content after MONOCO_GENERATED_END (use separate files instead).
+-->
+
+"""
+
+    def __init__(self, target_file: Path, verbose: bool = True):
         self.target_file = target_file
+        self.verbose = verbose
+
+    def _detect_external_content(self, content: str) -> Optional[str]:
+        """
+        Detects content outside the managed block.
+
+        Returns:
+            The external content string if found, None otherwise.
+        """
+        if not content or self.MANAGED_END not in content:
+            return None
+
+        # Split by MANAGED_END and check if there's non-empty content after
+        parts = content.split(self.MANAGED_END)
+        if len(parts) < 2:
+            return None
+
+        post_content = parts[-1].strip()
+        # Check if there's meaningful content (not just whitespace or newlines)
+        if post_content and len(post_content) > 10:  # Threshold to avoid false positives
+            return post_content
+        return None
+
+    def _warn_external_content(self, external_content: str):
+        """Outputs warning about external content."""
+        if not self.verbose:
+            return
+
+        # Truncate long content for warning message
+        preview = external_content[:200].replace("\n", " ")
+        if len(external_content) > 200:
+            preview += "..."
+
+        print(f"⚠️  Warning: Manual content detected after Managed Block in {self.target_file}")
+        print(f"   Consider moving to a separate file. Found content starting with: {preview}")
 
     def inject(self, prompts: Dict[str, str]) -> bool:
         """
@@ -30,6 +74,11 @@ class PromptInjector:
         if self.target_file.exists():
             current_content = self.target_file.read_text(encoding="utf-8")
 
+        # Check for external content and warn
+        external_content = self._detect_external_content(current_content)
+        if external_content:
+            self._warn_external_content(external_content)
+
         new_content = self._merge_content(current_content, prompts)
 
         if new_content != current_content:
@@ -76,12 +125,18 @@ class PromptInjector:
         managed_block_str = "\n".join(managed_block).strip() + "\n"
         managed_block_str = f"{self.MANAGED_START}\n{managed_block_str}\n{self.MANAGED_END}\n"
 
+        # 2. Add file header comment if not present
+        has_header = original.strip().startswith("<!--") and "IMPORTANT: This file is partially managed by Monoco" in original
+
         # 2. Find and replace/append in the original content
         # Check for delimiters first
         if self.MANAGED_START in original and self.MANAGED_END in original:
             try:
                 pre = original.split(self.MANAGED_START)[0]
                 post = original.split(self.MANAGED_END)[1]
+                # Add header comment if not present
+                if not has_header and not pre.strip().startswith("<!--"):
+                    pre = self.FILE_HEADER_COMMENT + pre
                 # Reconstruct
                 return pre + managed_block_str.strip() + post
             except IndexError:
@@ -105,12 +160,16 @@ class PromptInjector:
 
         if start_idx == -1:
             # Block not found, append to end
+            result = ""
+            if not has_header:
+                result = self.FILE_HEADER_COMMENT
             if original and not original.endswith("\n"):
-                return original + "\n\n" + managed_block_str.strip()
+                result += original + "\n\n" + managed_block_str.strip()
             elif original:
-                return original + "\n" + managed_block_str.strip()
+                result += original + "\n" + managed_block_str.strip()
             else:
-                return managed_block_str.strip() + "\n"
+                result += managed_block_str.strip() + "\n"
+            return result
 
         # Find end: Look for next header of level 1 or 2 (siblings or parents)
         header_level_match = re.match(r"^(#+)\s", self.MANAGED_HEADER)
@@ -134,9 +193,13 @@ class PromptInjector:
         pre_block = "\n".join(lines[:start_idx])
         post_block = "\n".join(lines[end_idx:])
 
-        result = pre_block
-        if result:
-            result += "\n\n"
+        result = ""
+        # Add header comment if not present
+        if not has_header and not pre_block.strip().startswith("<!--"):
+            result = self.FILE_HEADER_COMMENT
+
+        if pre_block:
+            result += pre_block + "\n\n"
 
         result += managed_block_str
 
@@ -218,6 +281,21 @@ class PromptInjector:
         pre_block = lines[:start_idx]
         post_block = lines[end_idx:]
 
+        # Check if pre_block contains only the file header comment
+        pre_text = "\n".join(pre_block)
+        if pre_text.strip() and "This file is partially managed by Monoco" in pre_text:
+            # Check if pre_block is just the header comment
+            is_only_header = all(
+                line.strip().startswith("<!--") or
+                line.strip().startswith("⚠️ IMPORTANT") or
+                line.strip().startswith("-") or
+                line.strip().startswith("-->") or
+                not line.strip()
+                for line in pre_block
+            )
+            if is_only_header and not post_block:
+                pre_block = []
+
         # If we removed everything, the file might become empty or just newlines
 
         new_lines = pre_block + post_block

monoco/core/integrations.py

@@ -94,14 +94,6 @@ class AgentProviderHealth(BaseModel):
 
 # Default Integration Registry
 DEFAULT_INTEGRATIONS: Dict[str, AgentIntegration] = {
-    "cursor": AgentIntegration(
-        key="cursor",
-        name="Cursor",
-        system_prompt_file=".cursorrules",
-        skill_root_dir=".cursor/skills/",
-        bin_name="cursor",
-        version_cmd="--version",
-    ),
     "claude": AgentIntegration(
         key="claude",
         name="Claude Code",
@@ -118,22 +110,6 @@ DEFAULT_INTEGRATIONS: Dict[str, AgentIntegration] = {
         bin_name="gemini",
         version_cmd="--version",
     ),
-    "qwen": AgentIntegration(
-        key="qwen",
-        name="Qwen Code",
-        system_prompt_file="QWEN.md",
-        skill_root_dir=".qwen/skills/",
-        bin_name="qwen",
-        version_cmd="--version",
-    ),
-    "kimi": AgentIntegration(
-        key="kimi",
-        name="Kimi CLI",
-        system_prompt_file="AGENTS.md",
-        skill_root_dir=".agent/skills/",
-        bin_name="kimi",
-        version_cmd="--version",
-    ),
     "agent": AgentIntegration(
         key="agent",
         name="Generic Agent",

monoco/core/router/__init__.py

@@ -1,55 +1,17 @@
 """
 Router Module - Layer 2 of the Event Automation Framework.
 
-This module provides event routing capabilities that map events to actions.
-It is part of the three-layer architecture:
-- Layer 1: File Watcher
-- Layer 2: Action Router (this module)
-- Layer 3: Action Executor
-
-Example Usage:
-    >>> from monoco.core.router import ActionRouter, Action, ActionResult
-    >>> from monoco.core.scheduler import AgentEventType
-    >>> 
-    >>> router = ActionRouter()
-    >>> 
-    >>> # Register action for issue creation
-    >>> router.register(AgentEventType.ISSUE_CREATED, my_action)
-    >>> 
-    >>> # Register with condition
-    >>> router.register(
-    ...     AgentEventType.ISSUE_STAGE_CHANGED,
-    ...     engineer_action,
-    ...     condition=lambda e: e.payload.get("new_stage") == "doing"
-    ... )
-    >>> 
-    >>> await router.start()
+This module provides Action ABC and ActionResult for handlers.
 """
 
 from .action import (
     Action,
-    ActionChain,
-    ActionRegistry,
     ActionResult,
     ActionStatus,
-    ConditionalAction,
-)
-from .router import (
-    ActionRouter,
-    ConditionalRouter,
-    RoutingRule,
 )
 
 __all__ = [
-    # Actions
     "Action",
-    "ActionChain",
-    "ActionRegistry",
     "ActionResult",
     "ActionStatus",
-    "ConditionalAction",
-    # Router
-    "ActionRouter",
-    "ConditionalRouter",
-    "RoutingRule",
 ]

monoco/core/router/action.py

@@ -1,8 +1,7 @@
 """
 Action Abstractions - Layer 2 & 3 of the Event Automation Framework.
 
-This module defines the Action ABC and related classes for the execution layer.
-Actions are the units of work that respond to events.
+This module defines the Action ABC and ActionResult for handler return types.
 """
 
 from __future__ import annotations
@@ -12,7 +11,7 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Dict, Optional
 
 from monoco.core.scheduler import AgentEvent, AgentEventType
 
@@ -101,7 +100,7 @@ class Action(ABC):
     Abstract base class for Actions (Layer 3).
     
     Actions are the units of work that respond to events.
-    They are executed by the ActionRouter when events match their conditions.
+    They are executed by handlers when events match their conditions.
     
     Responsibilities:
     - Define execution conditions (can_execute)
@@ -201,141 +200,3 @@ class Action(ABC):
             "execution_count": self._execution_count,
             "last_execution": self._last_execution.isoformat() if self._last_execution else None,
         }
-
-
-class ConditionalAction(Action):
-    """
-    Action with configurable conditions.
-    
-    Allows defining conditions declaratively without subclassing.
-    """
-    
-    def __init__(
-        self,
-        name: str,
-        execute_fn: Callable[[AgentEvent], Any],
-        condition_fn: Optional[Callable[[AgentEvent], bool]] = None,
-        config: Optional[Dict[str, Any]] = None,
-    ):
-        super().__init__(config)
-        self._name = name
-        self._execute_fn = execute_fn
-        self._condition_fn = condition_fn
-    
-    @property
-    def name(self) -> str:
-        return self._name
-    
-    async def can_execute(self, event: AgentEvent) -> bool:
-        if self._condition_fn is None:
-            return True
-        
-        if hasattr(self._condition_fn, '__await__'):
-            return await self._condition_fn(event)
-        return self._condition_fn(event)
-    
-    async def execute(self, event: AgentEvent) -> ActionResult:
-        try:
-            if hasattr(self._execute_fn, '__await__'):
-                result = await self._execute_fn(event)
-            else:
-                result = self._execute_fn(event)
-            
-            if isinstance(result, ActionResult):
-                return result
-            return ActionResult.success_result(output=result)
-        
-        except Exception as e:
-            return ActionResult.failure_result(error=str(e))
-
-
-class ActionChain:
-    """
-    Chain of actions that execute sequentially.
-    
-    Each action in the chain receives the output of the previous action.
-    If any action fails, the chain stops.
-    """
-    
-    def __init__(self, name: str, actions: Optional[List[Action]] = None):
-        self.name = name
-        self.actions = actions or []
-        self._results: List[ActionResult] = []
-    
-    def add(self, action: Action) -> "ActionChain":
-        """Add an action to the chain."""
-        self.actions.append(action)
-        return self
-    
-    async def execute(self, event: AgentEvent) -> List[ActionResult]:
-        """
-        Execute all actions in the chain.
-        
-        Args:
-            event: The triggering event
-            
-        Returns:
-            List of ActionResults for each action
-        """
-        self._results = []
-        context = {"event": event, "chain_name": self.name}
-        
-        for action in self.actions:
-            # Check if previous action failed
-            if self._results and not self._results[-1].success:
-                self._results.append(ActionResult.skipped_result(
-                    reason="Previous action in chain failed"
-                ))
-                continue
-            
-            # Execute action with context
-            result = await action(event)
-            result.metadata["chain_context"] = context.copy()
-            self._results.append(result)
-            
-            # Update context with output
-            if result.success and result.output is not None:
-                context[f"{action.name}_output"] = result.output
-        
-        return self._results
-    
-    def get_stats(self) -> Dict[str, Any]:
-        """Get chain statistics."""
-        return {
-            "name": self.name,
-            "actions": len(self.actions),
-            "action_names": [a.name for a in self.actions],
-            "last_results": len(self._results),
-        }
-
-
-class ActionRegistry:
-    """
-    Registry for managing actions.
-    
-    Provides action lookup and management.
-    """
-    
-    def __init__(self):
-        self._actions: Dict[str, Action] = {}
-    
-    def register(self, action: Action) -> None:
-        """Register an action."""
-        self._actions[action.name] = action
-        logger.debug(f"Registered action: {action.name}")
-    
-    def unregister(self, name: str) -> Optional[Action]:
-        """Unregister an action."""
-        return self._actions.pop(name, None)
-    
-    def get(self, name: str) -> Optional[Action]:
-        """Get an action by name."""
-        return self._actions.get(name)
-    
-    def list_actions(self) -> List[str]:
-        """List all registered action names."""
-        return list(self._actions.keys())
-    
-    def clear(self) -> None:
-        """Clear all registered actions."""
-        self._actions.clear()

monoco/core/scheduler/events.py

@@ -9,10 +9,27 @@ import asyncio
 import inspect
 import logging
 from enum import Enum, auto
-from typing import Dict, List, Callable, Any, Optional
+from typing import Dict, List, Callable, Any, Optional, Union
 from dataclasses import dataclass, field
 from datetime import datetime
 
+
+def _is_async_handler(handler: Callable) -> bool:
+    """
+    Check if a handler is async (coroutine function or has async __call__).
+    
+    Handles both:
+    - Regular async functions: async def func(): ...
+    - Callable objects with async __call__: class Handler: async def __call__(self, ...): ...
+    """
+    # Direct check for coroutine function
+    if inspect.iscoroutinefunction(handler):
+        return True
+    # Check for callable object with async __call__ method
+    if hasattr(handler, "__call__") and inspect.iscoroutinefunction(handler.__call__):
+        return True
+    return False
+
 logger = logging.getLogger("monoco.core.scheduler.events")
 
 
@@ -38,6 +55,15 @@ class AgentEventType(Enum):
     # PR events (for Reviewer trigger)
     PR_CREATED = "pr.created"
     PR_UPDATED = "pr.updated"
+    
+    # IM events (FEAT-0167)
+    IM_MESSAGE_RECEIVED = "im.message.received"
+    IM_MESSAGE_REPLIED = "im.message.replied"
+    IM_AGENT_TRIGGER = "im.agent.trigger"
+    IM_SESSION_STARTED = "im.session.started"
+    IM_SESSION_CLOSED = "im.session.closed"
+    IM_CHANNEL_CREATED = "im.channel.created"
+    IM_CHANNEL_UPDATED = "im.channel.updated"
 
 
 @dataclass
@@ -122,7 +148,7 @@ class EventBus:
         tasks = []
         for handler in handlers:
             try:
-                if inspect.iscoroutinefunction(handler):
+                if _is_async_handler(handler):
                     tasks.append(asyncio.create_task(handler(event)))
                 else:
                     handler(event)

monoco/core/setup.py

@@ -211,6 +211,8 @@ def init_cli(
     project_config_path = project_config_dir / "project.yaml"
 
     project_initialized = False
+    workspace_config = {}
+    project_key = "MON"
 
     # Check if we should init project
     if workspace_config_path.exists() or project_config_path.exists():
@@ -323,6 +325,13 @@ def init_cli(
     try:
         from monoco.core.githooks import install_hooks
 
+        # Check if git initialized, if not, do it
+        if not (cwd / ".git").exists():
+            console.print("[dim]Git repository not found. Initializing...[/dim]")
+            # Set global default branch to main
+            subprocess.run(["git", "config", "--global", "init.defaultBranch", "main"], check=False)
+            subprocess.run(["git", "init"], cwd=cwd, check=False)
+
         # Re-load config to get the just-written hooks (or default ones)
         # Actually we have the dict right here in workspace_config['hooks']
         hooks_config = workspace_config.get("hooks", {})