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

monoco/core/config.py

@@ -91,6 +91,7 @@ class TransitionConfig(BaseModel):
     required_solution: Optional[str] = None
     description: str = ""
     command_template: Optional[str] = None
+    post_actions: List[str] = Field(default_factory=list)
 
 
 class CriticalityRuleConfig(BaseModel):
@@ -135,6 +136,11 @@ class CriticalityConfig(BaseModel):
         return self
 
 
+class AgentConfig(BaseModel):
+    """Configuration for AI Agents."""
+    timeout_seconds: int = Field(default=900, description="Global timeout for agent sessions")
+
+
 class IssueSchemaConfig(BaseModel):
     types: List[IssueTypeConfig] = Field(default_factory=list)
     statuses: List[str] = Field(default_factory=list)
@@ -241,6 +247,7 @@ class MonocoConfig(BaseModel):
 
     issue: IssueSchemaConfig = Field(default_factory=IssueSchemaConfig)
     domains: DomainConfig = Field(default_factory=DomainConfig)
+    agent: AgentConfig = Field(default_factory=AgentConfig)
 
     @staticmethod
     def _deep_merge(base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:

monoco/core/hooks/builtin/git_cleanup.py

@@ -31,7 +31,7 @@ class GitCleanupHook(SessionLifecycleHook):
         
         # Configuration with defaults
         self.auto_switch_to_main = self.config.get("auto_switch_to_main", True)
-        self.auto_delete_merged_branches = self.config.get("auto_delete_merged_branches", True)
+        self.auto_delete_merged_branches = self.config.get("auto_delete_merged_branches", False)
         self.main_branch = self.config.get("main_branch", "main")
         self.require_clean_worktree = self.config.get("require_clean_worktree", True)
 

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,8 +129,8 @@ 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",
     ),

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

@@ -36,4 +36,10 @@ class FeatureRegistry:
         cls.register(SpikeFeature())
         cls.register(I18nFeature())
         cls.register(MemoFeature())
-        pass
+
+        
+        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

monoco/core/resource/manager.py

@@ -0,0 +1,91 @@
+from typing import List, Optional, Dict
+from pathlib import Path
+import shutil
+import os
+
+from .models import ResourceNode, ResourceType
+from .finder import ResourceFinder
+
+class ResourceManager:
+    def __init__(self, source_lang: str = "en"):
+        self.finder = ResourceFinder()
+        self.source_lang = source_lang
+
+    def list_resources(self, package: str, type: Optional[ResourceType] = None, lang: Optional[str] = None) -> List[ResourceNode]:
+        """
+        Low-level listing of resources with optional exact filtering.
+        """
+        all_nodes = self.finder.scan_package(package)
+        filtered = []
+        for node in all_nodes:
+            if type and node.type != type:
+                continue
+            if lang and node.language != lang:
+                continue
+            filtered.append(node)
+        return filtered
+
+    def get_merged_resources(self, package: str, type: ResourceType, target_lang: str) -> List[ResourceNode]:
+        """
+        Get resources of a specific type, merging source language defaults with target language overrides.
+        Returns a list of unique resources (by name), prioritizing target_lang.
+        """
+        all_nodes = self.finder.scan_package(package)
+        type_nodes = [n for n in all_nodes if n.type == type]
+        
+        # Dictionary to hold the best match for each filename: name -> ResourceNode
+        best_matches: Dict[str, ResourceNode] = {}
+        
+        # 1. Populate with source language (Default Base)
+        for node in type_nodes:
+            if node.language == self.source_lang:
+                best_matches[node.name] = node
+                
+        # 2. Override with target language if different
+        if target_lang != self.source_lang:
+            for node in type_nodes:
+                if node.language == target_lang:
+                    best_matches[node.name] = node
+                    
+        return list(best_matches.values())
+
+    def extract_to(self, nodes: List[ResourceNode], destination: Path, symlink: bool = False, force: bool = True) -> int:
+        """
+        Extracts (copy or symlink) resources to the destination directory.
+        Returns count of extracted items.
+        
+        Args:
+            nodes: List of resources to extract
+            destination: Target directory
+            symlink: If True, create symbolic links instead of copying
+            force: If True, overwrite existing files/symlinks
+        """
+        destination.mkdir(parents=True, exist_ok=True)
+        count = 0
+        
+        for node in nodes:
+            dest_path = destination / node.name
+            
+            if dest_path.exists():
+                if not force:
+                    continue
+                # Remove existing
+                if dest_path.is_symlink() or dest_path.is_file():
+                    dest_path.unlink()
+                elif dest_path.is_dir():
+                    shutil.rmtree(dest_path)
+            
+            try:
+                if symlink:
+                    # Symlink target must be absolute
+                    dest_path.symlink_to(node.path)
+                else:
+                    if node.path.is_dir():
+                        shutil.copytree(node.path, dest_path)
+                    else:
+                        shutil.copy2(node.path, dest_path)
+                count += 1
+            except Exception as e:
+                print(f"Error extracting {node.name}: {e}")
+                
+        return count

monoco/core/resource/models.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, List
+from enum import Enum
+
+class ResourceType(str, Enum):
+    PROMPTS = "prompts"
+    RULES = "rules"
+    SKILLS = "skills"
+    ROLES = "roles"
+    GLOSSARY = "glossary"
+    TEMPLATES = "templates"
+    DOCS = "docs"
+    OTHER = "other"
+
+@dataclass
+class ResourceNode:
+    """
+    Represents a discovered resource file in a Python package.
+    """
+    name: str
+    path: Path  # Absolute path to the source file
+    type: ResourceType
+    language: str  # "en", "zh", etc.
+    content: Optional[str] = None  # Lazy loaded content
+    
+    @property
+    def key(self) -> str:
+        """Unique identifier for the resource (e.g. 'agent.prompts.system')"""
+        return f"{self.type.value}.{self.name}"
+
+    def read_text(self) -> str:
+        if self.content:
+            return self.content
+        return self.path.read_text(encoding="utf-8")

monoco/core/resources/en/{SKILL.md → skills/monoco_core/SKILL.md}

@@ -1,6 +1,8 @@
 ---
 name: monoco-core
 description: Core skill for Monoco Toolkit. Provides essential commands for project initialization, configuration, and workspace management.
+type: standard
+version: 1.0.0
 ---
 
 # Monoco Core

monoco/core/resources/zh/{SKILL.md → skills/monoco_core/SKILL.md}

@@ -1,6 +1,8 @@
 ---
 name: monoco-core
 description: Monoco Toolkit 的核心技能。提供项目初始化、配置管理和工作空间管理的基础命令。
+type: standard
+version: 1.0.0
 ---
 
 # Monoco 核心