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

monoco/core/hooks/context.py

@@ -0,0 +1,131 @@
+"""
+Hook Context - Data passed to hooks during session lifecycle events.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+
+@dataclass
+class IssueInfo:
+    """Information about the issue associated with a session."""
+    id: str
+    status: Optional[str] = None
+    stage: Optional[str] = None
+    title: Optional[str] = None
+    branch_name: Optional[str] = None
+    is_merged: bool = False
+    
+    @classmethod
+    def from_metadata(cls, metadata: Any) -> "IssueInfo":
+        """Create IssueInfo from IssueMetadata."""
+        return cls(
+            id=getattr(metadata, "id", ""),
+            status=getattr(metadata, "status", None),
+            stage=getattr(metadata, "stage", None),
+            title=getattr(metadata, "title", None),
+            branch_name=getattr(metadata, "isolation", {}).get("ref") if hasattr(metadata, "isolation") and metadata.isolation else None,
+            is_merged=False,  # Will be determined by GitCleanupHook
+        )
+
+
+@dataclass
+class GitInfo:
+    """Git repository information."""
+    project_root: Path
+    current_branch: Optional[str] = None
+    has_uncommitted_changes: bool = False
+    default_branch: str = "main"
+    
+    def __post_init__(self):
+        if self.current_branch is None:
+            # Lazy load current branch
+            try:
+                from monoco.core import git
+                self.current_branch = git.get_current_branch(self.project_root)
+            except Exception:
+                self.current_branch = None
+
+
+@dataclass
+class HookContext:
+    """
+    Context object passed to lifecycle hooks.
+    
+    Contains all relevant information about the session, issue, and environment
+    that hooks might need to perform their operations.
+    """
+    
+    # Session Information
+    session_id: str
+    role_name: str
+    session_status: str
+    created_at: datetime
+    
+    # Issue Information
+    issue: Optional[IssueInfo] = None
+    
+    # Git Information
+    git: Optional[GitInfo] = None
+    
+    # Additional Context
+    extra: Dict[str, Any] = field(default_factory=dict)
+    
+    @classmethod
+    def from_runtime_session(
+        cls,
+        runtime_session: Any,
+        project_root: Optional[Path] = None,
+    ) -> "HookContext":
+        """
+        Create a HookContext from a RuntimeSession.
+        
+        Args:
+            runtime_session: The RuntimeSession object
+            project_root: Optional project root path
+            
+        Returns:
+            A populated HookContext
+        """
+        model = runtime_session.model
+        
+        # Build IssueInfo if we have an issue_id
+        issue_info = None
+        if model.issue_id:
+            issue_info = IssueInfo(
+                id=model.issue_id,
+                branch_name=model.branch_name,
+            )
+            
+            # Try to load full issue metadata
+            try:
+                from monoco.features.issue.core import find_issue_path, parse_issue
+                from monoco.core.config import find_monoco_root
+                
+                if project_root is None:
+                    project_root = find_monoco_root()
+                
+                issues_root = project_root / "Issues"
+                issue_path = find_issue_path(issues_root, model.issue_id)
+                if issue_path:
+                    metadata = parse_issue(issue_path)
+                    if metadata:
+                        issue_info = IssueInfo.from_metadata(metadata)
+            except Exception:
+                pass  # Use basic issue info
+        
+        # Build GitInfo
+        git_info = None
+        if project_root:
+            git_info = GitInfo(project_root=project_root)
+        
+        return cls(
+            session_id=model.id,
+            role_name=model.role_name,
+            session_status=model.status,
+            created_at=model.created_at,
+            issue=issue_info,
+            git=git_info,
+        )

monoco/core/hooks/registry.py

@@ -0,0 +1,222 @@
+"""
+Hook Registry - Manages registration and execution of session lifecycle hooks.
+"""
+
+import logging
+from typing import List, Type, Optional, Dict, Any
+from pathlib import Path
+
+from .base import SessionLifecycleHook, HookResult, HookStatus
+from .context import HookContext
+
+logger = logging.getLogger("monoco.core.hooks")
+
+
+class HookRegistry:
+    """
+    Registry for managing session lifecycle hooks.
+    
+    Responsible for:
+    - Registering hooks
+    - Executing hooks in order
+    - Handling hook errors gracefully
+    - Loading hooks from configuration
+    """
+
+    def __init__(self):
+        self._hooks: List[SessionLifecycleHook] = []
+        self._hook_classes: Dict[str, Type[SessionLifecycleHook]] = {}
+
+    def register(self, hook: SessionLifecycleHook) -> None:
+        """
+        Register a hook instance.
+        
+        Args:
+            hook: The hook instance to register
+        """
+        if not isinstance(hook, SessionLifecycleHook):
+            raise TypeError(f"Hook must be a SessionLifecycleHook, got {type(hook)}")
+        
+        self._hooks.append(hook)
+        logger.debug(f"Registered hook: {hook.name}")
+
+    def register_class(
+        self, 
+        hook_class: Type[SessionLifecycleHook], 
+        name: Optional[str] = None,
+        config: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Register a hook class (will be instantiated).
+        
+        Args:
+            hook_class: The hook class to register
+            name: Optional name for the hook instance
+            config: Optional configuration for the hook
+        """
+        if not issubclass(hook_class, SessionLifecycleHook):
+            raise TypeError(f"Hook class must inherit from SessionLifecycleHook")
+        
+        instance = hook_class(name=name, config=config)
+        self.register(instance)
+
+    def unregister(self, name: str) -> bool:
+        """
+        Unregister a hook by name.
+        
+        Args:
+            name: The name of the hook to unregister
+            
+        Returns:
+            True if a hook was removed, False otherwise
+        """
+        for i, hook in enumerate(self._hooks):
+            if hook.name == name:
+                self._hooks.pop(i)
+                logger.debug(f"Unregistered hook: {name}")
+                return True
+        return False
+
+    def get_hooks(self, enabled_only: bool = True) -> List[SessionLifecycleHook]:
+        """
+        Get all registered hooks.
+        
+        Args:
+            enabled_only: If True, only return enabled hooks
+            
+        Returns:
+            List of hook instances
+        """
+        if enabled_only:
+            return [h for h in self._hooks if h.is_enabled()]
+        return self._hooks.copy()
+
+    def clear(self) -> None:
+        """Clear all registered hooks."""
+        self._hooks.clear()
+        logger.debug("Cleared all hooks")
+
+    def execute_on_session_start(self, context: HookContext) -> List[HookResult]:
+        """
+        Execute all registered hooks' on_session_start methods.
+        
+        Args:
+            context: The hook context
+            
+        Returns:
+            List of results from each hook
+        """
+        return self._execute_hooks("on_session_start", context)
+
+    def execute_on_session_end(self, context: HookContext) -> List[HookResult]:
+        """
+        Execute all registered hooks' on_session_end methods.
+        
+        Args:
+            context: The hook context
+            
+        Returns:
+            List of results from each hook
+        """
+        return self._execute_hooks("on_session_end", context)
+
+    def _execute_hooks(
+        self, 
+        method_name: str, 
+        context: HookContext
+    ) -> List[HookResult]:
+        """
+        Execute a hook method on all registered hooks.
+        
+        Errors in individual hooks don't stop execution of other hooks.
+        
+        Args:
+            method_name: The name of the method to call
+            context: The hook context
+            
+        Returns:
+            List of results from each hook
+        """
+        results = []
+        hooks = self.get_hooks(enabled_only=True)
+        
+        for hook in hooks:
+            try:
+                method = getattr(hook, method_name)
+                result = method(context)
+                results.append(result)
+                
+                if result.status == HookStatus.FAILURE:
+                    logger.warning(
+                        f"Hook '{hook.name}' {method_name} failed: {result.message}"
+                    )
+                elif result.status == HookStatus.WARNING:
+                    logger.warning(
+                        f"Hook '{hook.name}' {method_name} warning: {result.message}"
+                    )
+                else:
+                    logger.debug(
+                        f"Hook '{hook.name}' {method_name} succeeded: {result.message}"
+                    )
+                    
+            except Exception as e:
+                logger.error(f"Hook '{hook.name}' {method_name} raised exception: {e}")
+                results.append(HookResult.failure(str(e)))
+        
+        return results
+
+    def load_from_config(self, config: Dict[str, Any], project_root: Path) -> None:
+        """
+        Load and register hooks from configuration.
+        
+        Args:
+            config: The hooks configuration dictionary
+            project_root: The project root path
+        """
+        if not config:
+            return
+        
+        # Import built-in hooks
+        from .builtin.git_cleanup import GitCleanupHook
+        from .builtin.logging_hook import LoggingHook
+        
+        # Map of hook names to classes
+        builtin_hooks = {
+            "git_cleanup": GitCleanupHook,
+            "logging": LoggingHook,
+        }
+        
+        for hook_name, hook_config in config.items():
+            if isinstance(hook_config, bool):
+                # Simple enable/disable: "git_cleanup: true"
+                if hook_config and hook_name in builtin_hooks:
+                    self.register_class(builtin_hooks[hook_name], name=hook_name)
+            elif isinstance(hook_config, dict):
+                # Full configuration: "git_cleanup: { enabled: true, ... }"
+                enabled = hook_config.get("enabled", True)
+                if enabled and hook_name in builtin_hooks:
+                    self.register_class(
+                        builtin_hooks[hook_name], 
+                        name=hook_name, 
+                        config=hook_config
+                    )
+            else:
+                logger.warning(f"Unknown hook config format for '{hook_name}'")
+
+
+# Global registry instance
+_global_registry: Optional[HookRegistry] = None
+
+
+def get_registry() -> HookRegistry:
+    """Get the global hook registry."""
+    global _global_registry
+    if _global_registry is None:
+        _global_registry = HookRegistry()
+    return _global_registry
+
+
+def reset_registry() -> None:
+    """Reset the global registry (mainly for testing)."""
+    global _global_registry
+    _global_registry = HookRegistry()

monoco/core/injection.py

@@ -10,6 +10,8 @@ class PromptInjector:
     """
 
     MANAGED_HEADER = "## Monoco Toolkit"
+    MANAGED_START = "<!-- MONOCO_GENERATED_START -->"
+    MANAGED_END = "<!-- MONOCO_GENERATED_END -->"
 
     def __init__(self, target_file: Path):
         self.target_file = target_file
@@ -52,19 +54,40 @@ class PromptInjector:
             # Sanitize content: remove leading header if it matches the title
             clean_content = content.strip()
             # Regex to match optional leading hash header matching the title (case insensitive)
-            # e.g. "### Issue Management" or "# Issue Management"
             pattern = r"^(#+\s*)" + re.escape(title) + r"\s*\n"
             match = re.match(pattern, clean_content, re.IGNORECASE)
 
             if match:
                 clean_content = clean_content[match.end() :].strip()
-
-            managed_block.append(clean_content)
+            
+            # Demote headers in content to be below ### (so start at ####)
+            # We assume the content headers start at # or ##. 
+            # We map # -> ####, ## -> #####, etc. (+3 offset)
+            demoted_content = []
+            for line in clean_content.splitlines():
+                if line.lstrip().startswith("#"):
+                    demoted_content.append("###" + line)
+                else:
+                    demoted_content.append(line)
+            
+            managed_block.append("\n".join(demoted_content))
             managed_block.append("")  # Blank line after section
 
         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. 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]
+                # Reconstruct
+                return pre + managed_block_str.strip() + post
+            except IndexError:
+                # Fallback to header detection if delimiters malformed
+                pass
+
         lines = original.splitlines()
         start_idx = -1
         end_idx = -1
@@ -74,31 +97,29 @@ class PromptInjector:
             if line.strip() == self.MANAGED_HEADER:
                 start_idx = i
                 break
+        
+        if start_idx == -1:
+             # Check if we have delimiters even if header is missing/changed?
+             # Handled above.
+             pass
 
         if start_idx == -1:
             # Block not found, append to end
             if original and not original.endswith("\n"):
-                return original + "\n\n" + managed_block_str
+                return original + "\n\n" + managed_block_str.strip()
             elif original:
-                return original + "\n" + managed_block_str
+                return original + "\n" + managed_block_str.strip()
             else:
-                return managed_block_str
-
-        # Find end: Look for next header of level 1 (assuming Managed Header is H1)
-        # Or EOF
-        # Note: If MANAGED_HEADER is "# ...", we look for next "# ..."
-        # But allow "## ..." as children.
+                return managed_block_str.strip() + "\n"
 
+        # Find end: Look for next header of level 1 or 2 (siblings or parents)
         header_level_match = re.match(r"^(#+)\s", self.MANAGED_HEADER)
-        header_level_prefix = header_level_match.group(1) if header_level_match else "#"
+        header_level_prefix = header_level_match.group(1) if header_level_match else "##"
 
         for i in range(start_idx + 1, len(lines)):
             line = lines[i]
             # Check if this line is a header of the same level or higher (fewer #s)
-            # e.g. if Managed is "###", then "#" and "##" are higher/parents, "###" is sibling.
-            # We treat siblings as end of block too.
             if line.startswith("#"):
-                # Match regex to get level
                 match = re.match(r"^(#+)\s", line)
                 if match:
                     level = match.group(1)
@@ -146,26 +167,39 @@ class PromptInjector:
 
         # Find start
         for i, line in enumerate(lines):
-            if line.strip() == self.MANAGED_HEADER:
+            if self.MANAGED_START in line:
                 start_idx = i
+                # Look for end from here
+                for j in range(i, len(lines)):
+                    if self.MANAGED_END in lines[j]:
+                        end_idx = j + 1 # Include the end line
+                        break
                 break
+        
+        if start_idx == -1:
+            # Fallback to header logic
+             for i, line in enumerate(lines):
+                if line.strip() == self.MANAGED_HEADER:
+                    start_idx = i
+                    break
 
         if start_idx == -1:
             return False
 
-        # Find end: exact logic as in _merge_content
-        header_level_match = re.match(r"^(#+)\s", self.MANAGED_HEADER)
-        header_level_prefix = header_level_match.group(1) if header_level_match else "#"
-
-        for i in range(start_idx + 1, len(lines)):
-            line = lines[i]
-            if line.startswith("#"):
-                match = re.match(r"^(#+)\s", line)
-                if match:
-                    level = match.group(1)
-                    if len(level) <= len(header_level_prefix):
-                        end_idx = i
-                        break
+        if end_idx == -1:
+            # Find end: exact logic as in _merge_content
+            header_level_match = re.match(r"^(#+)\s", self.MANAGED_HEADER)
+            header_level_prefix = header_level_match.group(1) if header_level_match else "##"
+
+            for i in range(start_idx + 1, len(lines)):
+                line = lines[i]
+                if line.startswith("#"):
+                    match = re.match(r"^(#+)\s", line)
+                    if match:
+                        level = match.group(1)
+                        if len(level) <= len(header_level_prefix):
+                            end_idx = i
+                            break
 
         if end_idx == -1:
             end_idx = len(lines)

monoco/core/integrations.py

@@ -129,11 +129,17 @@ DEFAULT_INTEGRATIONS: Dict[str, AgentIntegration] = {
     "kimi": AgentIntegration(
         key="kimi",
         name="Kimi CLI",
-        system_prompt_file="KIMI.md",
-        skill_root_dir=".kimi/skills/",
+        system_prompt_file="AGENTS.md",
+        skill_root_dir=".agent/skills/",
         bin_name="kimi",
         version_cmd="--version",
     ),
+    "agent": AgentIntegration(
+        key="agent",
+        name="Generic Agent",
+        system_prompt_file="AGENTS.md",
+        skill_root_dir=".agent/skills/",
+    ),
 }
 
 

monoco/core/output.py

@@ -1,7 +1,7 @@
 import os
 import json
 import typer
-from typing import Any, List, Union, Annotated
+from typing import Any, List, Union, Annotated, Optional
 from pydantic import BaseModel
 from rich.console import Console
 from rich.table import Table
@@ -41,7 +41,7 @@ class OutputManager:
 
     @staticmethod
     def print(
-        data: Union[BaseModel, List[BaseModel], dict, list, str], title: str = ""
+        data: Union[BaseModel, List[BaseModel], dict, list, str], title: str = "", style: Optional[str] = None
     ):
         """
         Dual frontend dispatcher.
@@ -49,7 +49,7 @@ class OutputManager:
         if OutputManager.is_agent_mode():
             OutputManager._render_agent(data)
         else:
-            OutputManager._render_human(data, title)
+            OutputManager._render_human(data, title, style=style)
 
     @staticmethod
     def error(message: str):
@@ -94,7 +94,7 @@ class OutputManager:
                 print(str(data))
 
     @staticmethod
-    def _render_human(data: Any, title: str):
+    def _render_human(data: Any, title: str, style: Optional[str] = None):
         """
         Human channel: Visual priority.
         """
@@ -104,7 +104,7 @@ class OutputManager:
             console.rule(f"[bold blue]{title}[/bold blue]")
 
         if isinstance(data, str):
-            console.print(data)
+            console.print(data, style=style)
             return
 
         # Special handling for Lists of Pydantic Models -> Table

monoco/core/registry.py

@@ -30,8 +30,16 @@ class FeatureRegistry:
         from monoco.features.issue.adapter import IssueFeature
         from monoco.features.spike.adapter import SpikeFeature
         from monoco.features.i18n.adapter import I18nFeature
+        from monoco.features.memo.adapter import MemoFeature
 
         cls.register(IssueFeature())
         cls.register(SpikeFeature())
         cls.register(I18nFeature())
-        pass
+        cls.register(MemoFeature())
+
+        
+        from monoco.features.glossary.adapter import GlossaryFeature
+        cls.register(GlossaryFeature())
+
+        from monoco.features.agent.adapter import AgentFeature
+        cls.register(AgentFeature())

monoco/core/resource/__init__.py

@@ -0,0 +1,5 @@
+from .models import ResourceNode, ResourceType
+from .finder import ResourceFinder
+from .manager import ResourceManager
+
+__all__ = ["ResourceNode", "ResourceType", "ResourceFinder", "ResourceManager"]

monoco/core/resource/finder.py

@@ -0,0 +1,98 @@
+import sys
+from pathlib import Path
+from typing import List, Generator, Union
+import importlib.util
+
+# Use standard importlib.resources for Python 3.9+
+if sys.version_info < (3, 9):
+    # Fallback or error - for now assume 3.9+ as this is a modern toolkit
+    raise RuntimeError("Monoco requires Python 3.9+")
+from importlib.resources import files, as_file
+
+from .models import ResourceNode, ResourceType
+
+class ResourceFinder:
+    """
+    Scans Python packages for Monoco standard resources.
+    Standard Layout: <package>/resources/<lang>/<type>/<file>
+    """
+
+    def scan_package(self, package_name: str) -> List[ResourceNode]:
+        """
+        Traverses the 'resources' directory of a given package.
+        Returns a flat list of ResourceNode objects.
+        """
+        nodes = []
+        
+        # Check if package exists
+        if not importlib.util.find_spec(package_name):
+            return []
+
+        try:
+            pkg_root = files(package_name)
+            resources_root = pkg_root.joinpath("resources")
+            
+            if not resources_root.is_dir():
+                return []
+                
+            # Iterate over languages (direct children of resources/)
+            for lang_dir in resources_root.iterdir():
+                if not lang_dir.is_dir() or lang_dir.name.startswith("_"):
+                    continue
+                
+                lang = lang_dir.name
+                
+                # Iterate over resource types (children of lang/)
+                for type_dir in lang_dir.iterdir():
+                    if not type_dir.is_dir() or type_dir.name.startswith("_"):
+                        continue
+                        
+                    try:
+                        res_type = ResourceType(type_dir.name)
+                    except ValueError:
+                        res_type = ResourceType.OTHER
+
+                    # Iterate over files (children of type/)
+                    # Note: This effectively supports shallow structure. 
+                    # For recursive (like skills folders), we might need recursion.
+                    # For now, let's assume flat files or folders treated as units (like flow skill dirs).
+                    
+                    for item in type_dir.iterdir():
+                         # For skills, the item might be a directory (Flow Skill)
+                         # We treat the directory path as the resource path in that case?
+                         # Or we recursively scan?
+                         # ResourceNode expects a path.
+                         
+                         # Use as_file to ensure we have a filesystem path (needed for symlinks/copy)
+                         with as_file(item) as item_path:
+                             # Note: as_file context manager keeps the temporary file alive if extracted from zip.
+                             # But here we probably want the path to persist?
+                             # if it's a real file system, item_path is the real path.
+                             
+                             if item.is_dir():
+                                 # Flow skills are directories
+                                 # We add the directory itself as a node?
+                                 if res_type == ResourceType.SKILLS:
+                                     nodes.append(ResourceNode(
+                                         name=item.name,
+                                         path=item_path,
+                                         type=res_type,
+                                         language=lang
+                                     ))
+                             elif item.is_file():
+                                 if item.name.startswith("."):
+                                     continue
+                                     
+                                 nodes.append(ResourceNode(
+                                     name=item.name,
+                                     path=item_path,
+                                     type=res_type,
+                                     language=lang
+                                 ))
+
+        except Exception as e:
+            # gracefully handle errors, maybe log?
+            print(f"Warning: Error scanning resources in {package_name}: {e}")
+            return []
+
+        return nodes