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

monoco/features/memo/core.py

@@ -1,9 +1,10 @@
 import re
 from pathlib import Path
-from datetime import datetime
-from typing import List, Dict, Optional
+from typing import List, Optional, Any
 import secrets
+from datetime import datetime
 
+from .models import Memo
 
 def is_chinese(text: str) -> bool:
     """Check if the text contains at least one Chinese character."""
@@ -18,7 +19,6 @@ def validate_content_language(content: str, source_lang: str) -> bool:
     if source_lang == "zh":
         return is_chinese(content)
     # For 'en', we generally allow everything but could be more strict.
-    # Requirement is mainly about enforcing 'zh' when configured.
     return True
 
 
@@ -27,120 +27,206 @@ def get_memos_dir(issues_root: Path) -> Path:
     Get the directory for memos.
     Convention: Sibling of Issues directory.
     """
-    # issues_root is usually ".../Issues"
     return issues_root.parent / "Memos"
 
-
 def get_inbox_path(issues_root: Path) -> Path:
     return get_memos_dir(issues_root) / "inbox.md"
 
-
 def generate_memo_id() -> str:
     """Generate a short 6-char ID."""
     return secrets.token_hex(3)
 
-
-def format_memo(uid: str, content: str, context: Optional[str] = None) -> str:
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    header = f"## [{uid}] {timestamp}"
-
-    body = content.strip()
-
-    if context:
-        body = f"> **Context**: `{context}`\n\n{body}"
-
-    return f"\n{header}\n{body}\n"
-
-
-def add_memo(issues_root: Path, content: str, context: Optional[str] = None) -> str:
+def parse_memo_block(block: str) -> Optional[Memo]:
     """
-    Append a memo to the inbox.
-    Returns the generated UID.
+    Parse a text block into a Memo object.
+    Block format:
+    ## [uid] YYYY-MM-DD HH:MM:SS
+    - **Key**: Value
+    ...
+    Content
     """
-    inbox_path = get_inbox_path(issues_root)
-
-    if not inbox_path.exists():
-        inbox_path.parent.mkdir(parents=True, exist_ok=True)
-        inbox_path.write_text("# Monoco Memos Inbox\n", encoding="utf-8")
-
-    uid = generate_memo_id()
-    entry = format_memo(uid, content, context)
-
-    with inbox_path.open("a", encoding="utf-8") as f:
-        f.write(entry)
-
-    return uid
-
-
-def list_memos(issues_root: Path) -> List[Dict[str, str]]:
+    lines = block.strip().split("\n")
+    if not lines:
+        return None
+        
+    header = lines[0]
+    match = re.match(r"^## \[([a-f0-9]+)\] (.*?)$", header)
+    if not match:
+        return None
+        
+    uid = match.group(1)
+    ts_str = match.group(2)
+    try:
+        timestamp = datetime.strptime(ts_str, "%Y-%m-%d %H:%M:%S")
+    except ValueError:
+        timestamp = datetime.now() # Fallback
+
+    content_lines = []
+    metadata = {}
+    
+    # Simple state machine
+    # 0: Header (done)
+    # 1: Metadata
+    # 2: Content
+    
+    state = 1
+    
+    for line in lines[1:]:
+        stripped = line.strip()
+        if state == 1:
+            if not stripped:
+                continue
+            # Check for metadata line: - **Key**: Value
+            meta_match = re.match(r"^\- \*\*([a-zA-Z]+)\*\*: (.*)$", stripped)
+            if meta_match:
+                key = meta_match.group(1).lower()
+                val = meta_match.group(2).strip()
+                metadata[key] = val
+            else:
+                # First non-metadata line marks start of content
+                state = 2
+                content_lines.append(line)
+        elif state == 2:
+            content_lines.append(line)
+            
+    content = "\n".join(content_lines).strip()
+    
+    # Map metadata to model fields
+    # Status map reverse
+    status_raw = metadata.get("status", "[ ] Pending")
+    status = "pending"
+    if "[x] Tracked" in status_raw:
+        status = "tracked"
+    elif "[x] Resolved" in status_raw:
+        status = "resolved"
+    elif "[-] Dismissed" in status_raw:
+        status = "dismissed"
+        
+    return Memo(
+        uid=uid,
+        timestamp=timestamp,
+        content=content,
+        author=metadata.get("from", "User"),
+        source=metadata.get("source", "cli"),
+        type=metadata.get("type", "insight"),
+        status=status,
+        ref=metadata.get("ref"),
+        context=metadata.get("context") # Note: context might need cleanup if it was wrapped in code blocks
+    )
+
+def load_memos(issues_root: Path) -> List[Memo]:
     """
-    Parse memos from inbox.
+    Parse all memos from inbox.
     """
     inbox_path = get_inbox_path(issues_root)
     if not inbox_path.exists():
         return []
 
     content = inbox_path.read_text(encoding="utf-8")
-
-    # Regex to find headers: ## [uid] timestamp
-    # We split by headers
-
-    pattern = re.compile(r"^## \[([a-f0-9]+)\] (.*?)$", re.MULTILINE)
-
+    
+    # Split by headers: ## [uid]
+    # We use a lookahead or just standard split carefully
+    parts = re.split(r"(^## \[)", content, flags=re.MULTILINE)[1:] # Skip preamble
+    
+    # parts will be like: ['## [', 'abc] 2023...\n...', '## [', 'def] ...']
+    # Reassemble pairs
+    blocks = []
+    for i in range(0, len(parts), 2):
+        if i+1 < len(parts):
+            blocks.append(parts[i] + parts[i+1])
+            
     memos = []
-    matches = list(pattern.finditer(content))
-
-    for i, match in enumerate(matches):
-        uid = match.group(1)
-        timestamp = match.group(2)
-
-        start = match.end()
-        end = matches[i + 1].start() if i + 1 < len(matches) else len(content)
-
-        body = content[start:end].strip()
-
-        memos.append({"id": uid, "timestamp": timestamp, "content": body})
-
+    for block in blocks:
+        memo = parse_memo_block(block)
+        if memo:
+            memos.append(memo)
+            
+    # Sort by timestamp desc? Or keep file order? File order is usually append (time asc).
     return memos
 
-
-def delete_memo(issues_root: Path, memo_id: str) -> bool:
+def save_memos(issues_root: Path, memos: List[Memo]) -> None:
     """
-    Delete a memo by its ID.
-    Returns True if deleted, False if not found.
+    Rewrite the inbox file with the given list of memos.
+    """
+    inbox_path = get_inbox_path(issues_root)
+    
+    # Header
+    lines = ["# Monoco Memos Inbox", ""]
+    
+    for memo in memos:
+        lines.append(memo.to_markdown().strip())
+        lines.append("") # Spacer
+        
+    inbox_path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def add_memo(
+    issues_root: Path, 
+    content: str, 
+    context: Optional[str] = None,
+    author: str = "User",
+    source: str = "cli",
+    memo_type: str = "insight"
+) -> str:
+    """
+    Append a memo to the inbox.
+    Returns the generated UID.
     """
+    uid = generate_memo_id()
+    memo = Memo(
+        uid=uid,
+        content=content,
+        context=context,
+        author=author,
+        source=source,
+        type=memo_type
+    )
+    
+    # Append mode is more robust against concurrent reads than rewrite, 
+    # but for consistent formatting we might want to just append string.
     inbox_path = get_inbox_path(issues_root)
+    
     if not inbox_path.exists():
-        return False
-
-    content = inbox_path.read_text(encoding="utf-8")
-    pattern = re.compile(r"^## \[([a-f0-9]+)\] (.*?)$", re.MULTILINE)
+        inbox_path.parent.mkdir(parents=True, exist_ok=True)
+        inbox_path.write_text("# Monoco Memos Inbox\n\n", encoding="utf-8")
+        
+    with inbox_path.open("a", encoding="utf-8") as f:
+        f.write("\n" + memo.to_markdown().strip() + "\n")
+        
+    return uid
 
-    matches = list(pattern.finditer(content))
-    target_idx = -1
-    for i, m in enumerate(matches):
-        if m.group(1) == memo_id:
-            target_idx = i
+def update_memo(issues_root: Path, memo_id: str, updates: dict) -> bool:
+    """
+    Update a memo's fields.
+    """
+    memos = load_memos(issues_root)
+    found = False
+    for i, m in enumerate(memos):
+        if m.uid == memo_id:
+            # Apply updates
+            updated_data = m.model_dump()
+            updated_data.update(updates)
+            memos[i] = Memo(**updated_data) # Re-validate
+            found = True
             break
+            
+    if found:
+        save_memos(issues_root, memos)
+        
+    return found
 
-    if target_idx == -1:
-        return False
-
-    # Find boundaries
-    start = matches[target_idx].start()
-    # Include the potential newline before the header if it exists
-    if start > 0 and content[start - 1] == "\n":
-        start -= 1
-
-    if target_idx + 1 < len(matches):
-        end = matches[target_idx + 1].start()
-        # Back up if there's a newline before the next header that we should keep?
-        # Actually, if we delete a memo, we should probably remove one "entry block".
-        # Entry blocks are format_memo: \n## header\nbody\n
-        # So we want to remove the leading \n and the trailing parts.
-    else:
-        end = len(content)
-
-    new_content = content[:start] + content[end:]
-    inbox_path.write_text(new_content, encoding="utf-8")
-    return True
+def delete_memo(issues_root: Path, memo_id: str) -> bool:
+    """
+    Delete a memo by its ID.
+    """
+    memos = load_memos(issues_root)
+    initial_count = len(memos)
+    memos = [m for m in memos if m.uid != memo_id]
+    
+    if len(memos) < initial_count:
+        save_memos(issues_root, memos)
+        return True
+    return False
+
+# Compatibility shim
+list_memos = load_memos

monoco/features/memo/models.py

@@ -0,0 +1,53 @@
+from datetime import datetime
+from typing import Optional, Literal
+from pydantic import BaseModel, Field
+
+class Memo(BaseModel):
+    uid: str
+    content: str
+    timestamp: datetime = Field(default_factory=datetime.now)
+    
+    # Optional Context
+    context: Optional[str] = None
+    
+    # New Metadata Fields
+    author: str = "User"  # User, Assistant, or specific Agent Name
+    source: str = "cli"   # cli, agent, mailroom, etc.
+    status: Literal["pending", "tracked", "resolved", "dismissed"] = "pending"
+    ref: Optional[str] = None  # Linked Issue ID or other reference
+    type: Literal["insight", "bug", "feature", "task"] = "insight"
+    
+    def to_markdown(self) -> str:
+        """
+        Render the memo to Markdown format.
+        """
+        ts_str = self.timestamp.strftime("%Y-%m-%d %H:%M:%S")
+        header = f"## [{self.uid}] {ts_str}"
+        
+        # Metadata block
+        meta = []
+        if self.author != "User":
+            meta.append(f"- **From**: {self.author}")
+        if self.source != "cli":
+            meta.append(f"- **Source**: {self.source}")
+        if self.type != "insight":
+             meta.append(f"- **Type**: {self.type}")
+        
+        # Status line with checkbox simulation
+        status_map = {
+            "pending": "[ ] Pending",
+            "tracked": "[x] Tracked",
+            "resolved": "[x] Resolved",
+            "dismissed": "[-] Dismissed"
+        }
+        meta.append(f"- **Status**: {status_map.get(self.status, '[ ] Pending')}")
+        
+        if self.ref:
+            meta.append(f"- **Ref**: {self.ref}")
+            
+        if self.context:
+            meta.append(f"- **Context**: `{self.context}`")
+            
+        meta_block = "\n".join(meta)
+        
+        return f"\n{header}\n{meta_block}\n\n{self.content.strip()}\n"

monoco/features/memo/resources/en/skills/{monoco_memo → monoco_atom_memo}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: monoco-memo
+name: monoco_atom_memo
 description: Lightweight memo system for quickly recording ideas, inspirations, and temporary notes. Distinguished from the formal Issue system.
-type: standard
+type: atom
 version: 1.0.0
 ---
 

monoco/features/memo/resources/en/skills/{note_processing_workflow → monoco_workflow_note_processing}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: note-processing-workflow
+name: monoco_workflow_note_processing
 description: Memo Note Processing Workflow (Flow Skill). Defines the standard operational process from capturing fleeting notes to organizing and archiving, ensuring effective management of ideas.
-type: flow
+type: workflow
 domain: memo
 version: 1.0.0
 ---

monoco/features/memo/resources/zh/skills/{monoco_memo → monoco_atom_memo}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: monoco-memo
+name: monoco_atom_memo
 description: 轻量级备忘录系统，用于快速记录想法、灵感和临时笔记。与正式的 Issue 系统区分开来。
-type: standard
+type: atom
 version: 1.0.0
 ---
 

monoco/features/memo/resources/zh/skills/{note_processing_workflow → monoco_workflow_note_processing}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: note-processing-workflow
+name: monoco_workflow_note_processing
 description: Memo 笔记处理工作流 (Flow Skill)。定义从捕获 fleeting notes 到组织归档的标准操作流程，确保想法有效管理。
-type: flow
+type: workflow
 domain: memo
 version: 1.0.0
 ---

monoco/features/spike/adapter.py

@@ -1,19 +1,32 @@
 from pathlib import Path
 from typing import Dict
-from monoco.core.feature import MonocoFeature, IntegrationData
+from monoco.core.loader import FeatureModule, FeatureMetadata
+from monoco.core.feature import IntegrationData
 from monoco.features.spike import core
 
 
-class SpikeFeature(MonocoFeature):
+class SpikeFeature(FeatureModule):
+    """Spike (research) feature module with unified lifecycle support."""
+
     @property
-    def name(self) -> str:
-        return "spike"
+    def metadata(self) -> FeatureMetadata:
+        return FeatureMetadata(
+            name="spike",
+            version="1.0.0",
+            description="Research spike management for external references",
+            dependencies=["core"],
+            priority=30,
+        )
 
-    def initialize(self, root: Path, config: Dict) -> None:
+    def _on_mount(self, context: "FeatureContext") -> None:  # type: ignore
+        """Initialize spike feature with workspace context."""
+        root = context.root
+        config = context.config
         spikes_name = config.get("paths", {}).get("spikes", ".references")
         core.init(root, spikes_name)
 
     def integrate(self, root: Path, config: Dict) -> IntegrationData:
+        """Provide integration data for agent environment."""
         # Determine language from config, default to 'en'
         lang = config.get("i18n", {}).get("source_lang", "en")
         base_dir = Path(__file__).parent / "resources"

monoco/features/spike/commands.py

@@ -81,13 +81,15 @@ def remove_repo(
     target_path = spikes_dir / name
     deleted = False
     if target_path.exists():
-        if force or typer.confirm(
-            f"Do you want to delete the directory {target_path}?", default=False
-        ):
+        if force:
             core.remove_repo_dir(spikes_dir, name)
             deleted = True
         else:
             deleted = False
+            if not OutputManager.is_agent_mode():
+                from rich.console import Console
+                console = Console()
+                console.print(f"[yellow]Skipping physical deletion of {target_path}. Use --force to delete.[/yellow]")
 
     OutputManager.print(
         {"status": "removed", "name": name, "directory_deleted": deleted}

monoco/features/spike/resources/en/skills/{monoco_spike → monoco_atom_spike}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: monoco-spike
+name: monoco_atom_spike
 description: Manage external reference repositories for research and learning. Provides read-only access to curated codebases.
-type: standard
+type: atom
 version: 1.0.0
 ---
 

monoco/features/spike/resources/en/skills/{research_workflow → monoco_workflow_research}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: research-workflow
+name: monoco_workflow_research
 description: Spike Research Workflow (Flow Skill). Defines the standard operational process from adding external repositories to knowledge extraction and archiving, ensuring effective management of external knowledge.
-type: flow
+type: workflow
 domain: spike
 version: 1.0.0
 ---

monoco/features/spike/resources/zh/skills/{monoco_spike → monoco_atom_spike}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: monoco-spike
+name: monoco_atom_spike
 description: 管理用于研究和学习的外部参考仓库。提供对精选代码库的只读访问。
-type: standard
+type: atom
 version: 1.0.0
 ---
 

monoco/features/spike/resources/zh/skills/{research_workflow → monoco_workflow_research}/SKILL.md

@@ -1,7 +1,7 @@
 ---
-name: research-workflow
+name: monoco_workflow_research
 description: Spike 研究工作流 (Flow Skill)。定义从添加外部仓库到知识提取和归档的标准操作流程，确保外部知识有效管理。
-type: flow
+type: workflow
 domain: spike
 version: 1.0.0
 ---

monoco/main.py

@@ -1,7 +1,23 @@
 import os
 import typer
 from typing import Optional
+from pathlib import Path
 from monoco.core.output import print_output
+from monoco.core.loader import FeatureLoader, FeatureContext
+
+# Global feature loader for CLI lifecycle management
+_feature_loader: Optional[FeatureLoader] = None
+
+
+def get_feature_loader() -> FeatureLoader:
+    """Get or initialize the global feature loader."""
+    global _feature_loader
+    if _feature_loader is None:
+        _feature_loader = FeatureLoader()
+        # Discover features but defer loading until needed
+        _feature_loader.discover()
+    return _feature_loader
+
 
 app = typer.Typer(
     name="monoco",
@@ -89,7 +105,26 @@ def main(
             if (discovered / ".monoco").exists():
                 config_root = str(discovered)
 
-        get_config(project_root=config_root, require_project=require_workspace)
+        config = get_config(project_root=config_root, require_project=require_workspace)
+        
+        # Initialize FeatureLoader and mount features when workspace is available
+        if require_workspace and config_root:
+            loader = get_feature_loader()
+            # Load all features (with lazy loading for non-critical features)
+            loader.load_all(lazy=True)
+            # Create feature context and mount all features
+            feature_context = FeatureContext(
+                root=Path(config_root),
+                config=config.model_dump(),
+                registry=loader.registry,
+            )
+            errors = loader.mount_all(feature_context)
+            if errors:
+                from rich.console import Console
+                console = Console()
+                for name, error in errors.items():
+                    console.print(f"[yellow]Warning: Failed to mount feature '{name}': {error}[/yellow]")
+                    
     except FileNotFoundError as e:
         # Graceful exit for workspace errors
         from rich.console import Console
@@ -156,6 +191,7 @@ from monoco.features.issue import commands as issue_cmd
 from monoco.features.spike import commands as spike_cmd
 from monoco.features.i18n import commands as i18n_cmd
 from monoco.features.config import commands as config_cmd
+from monoco.features.hooks import commands as hooks_cmd
 from monoco.cli import project as project_cmd
 from monoco.cli import workspace as workspace_cmd
 
@@ -163,6 +199,7 @@ app.add_typer(issue_cmd.app, name="issue", help="Manage development issues")
 app.add_typer(spike_cmd.app, name="spike", help="Manage research spikes")
 app.add_typer(i18n_cmd.app, name="i18n", help="Manage documentation i18n")
 app.add_typer(config_cmd.app, name="config", help="Manage configuration")
+app.add_typer(hooks_cmd.app, name="hooks", help="Manage git hooks for development workflow")
 app.add_typer(project_cmd.app, name="project", help="Manage projects")
 app.add_typer(workspace_cmd.app, name="workspace", help="Manage workspace")
 

{monoco_toolkit-0.3.10.dist-info → monoco_toolkit-0.3.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monoco-toolkit
-Version: 0.3.10
+Version: 0.3.12
 Summary: Agent Native Toolkit for Monoco - Task Management & Kanban for AI Agents
 Project-URL: Homepage, https://monoco.io
 Project-URL: Repository, https://github.com/IndenScale/Monoco
@@ -115,6 +115,12 @@ monoco session start
 - **Protocols**: LSP / ACP (for IDE integration)
 - **Storage**: Local Filesystem (Markdown/YAML)
 
+## 📁 Project Structure
+
+Monoco follows a "Distro" architecture that separates **State** (`Issues/`), **Config** (`.monoco/`), and **Logic** (`monoco/`).
+
+For a detailed breakdown of the directory structure, see **[TREE.md](./TREE.md)**.
+
 ## 🤝 Contributing
 
 Monoco is open-source. We are building the standard distribution for the Agentic era.