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

monoco/features/issue/validator.py

@@ -28,9 +28,19 @@ class IssueValidator:
         current_project: Optional[str] = None,
         workspace_root: Optional[str] = None,
         valid_domains: Set[str] = set(),
+        all_issues: List[IssueMetadata] = None,
     ) -> List[Diagnostic]:
         """
         Validate an issue and return diagnostics.
+        
+        Args:
+            meta: Issue metadata to validate
+            content: Full content of the issue file
+            all_issue_ids: Set of all issue IDs in the project (for reference validation)
+            current_project: Current project name
+            workspace_root: Workspace root project name
+            valid_domains: Set of valid domain names
+            all_issues: List of all IssueMetadata objects (for domain governance checks, FEAT-0136)
         """
         diagnostics = []
         self._current_project = current_project
@@ -65,6 +75,9 @@ class IssueValidator:
         # 1. State Matrix Validation
         diagnostics.extend(self._validate_state_matrix(meta, content))
 
+        # 1.5 Directory Consistency (FEAT-0144)
+        diagnostics.extend(self._validate_directory_consistency(meta, content))
+
         # 2. State Requirements (Strict Verification)
         diagnostics.extend(self._validate_state_requirements(meta, blocks))
 
@@ -80,7 +93,7 @@ class IssueValidator:
         # 5.5 Domain Integrity
         diagnostics.extend(
             self._validate_domains(
-                meta, content, all_issue_ids, valid_domains=valid_domains
+                meta, content, all_issue_ids, valid_domains=valid_domains, all_issues=all_issues
             )
         )
 
@@ -151,6 +164,62 @@ class IssueValidator:
                     return i
         return 0
 
+    def _validate_directory_consistency(
+        self, meta: IssueMetadata, content: str
+    ) -> List[Diagnostic]:
+        """
+        Check if the issue status matches its physical directory.
+        Checks for illegal directory names (like 'done' or 'freezed').
+        """
+        diagnostics = []
+        if not meta.path:
+            return diagnostics
+
+        path = Path(meta.path)
+        parent_dir_name = path.parent.name.lower()
+
+        # 1. Status/Directory Mismatch
+        if meta.status == "open" and parent_dir_name == "closed":
+            diagnostics.append(
+                self._create_diagnostic(
+                    f"Status/Directory Mismatch: Issue '{meta.id}' has status 'open' but is in 'closed/' directory.",
+                    DiagnosticSeverity.Error,
+                )
+            )
+        elif meta.status == "closed" and parent_dir_name == "open":
+            diagnostics.append(
+                self._create_diagnostic(
+                    f"Status/Directory Mismatch: Issue '{meta.id}' has status 'closed' but is in 'open/' directory.",
+                    DiagnosticSeverity.Error,
+                )
+            )
+
+        # 2. Illegal Directory Names
+        if parent_dir_name == "done":
+            diagnostics.append(
+                self._create_diagnostic(
+                    "Illegal Directory: Issues should be in 'closed/' directory, not 'done/'.",
+                    DiagnosticSeverity.Error,
+                )
+            )
+        elif parent_dir_name == "freezed":
+            diagnostics.append(
+                self._create_diagnostic(
+                    "Illegal Directory: Issues should be in 'backlog/' directory, not 'freezed/'.",
+                    DiagnosticSeverity.Error,
+                )
+            )
+
+        return diagnostics
+
+    def _validate_status_enum(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+        """Legacy helper for enum validation (mostly handled by Pydantic now)."""
+        return []
+
+    def _validate_stage_enum(self, meta: IssueMetadata, content: str) -> List[Diagnostic]:
+        """Legacy helper for enum validation (mostly handled by Pydantic now)."""
+        return []
+
     def _validate_state_matrix(
         self, meta: IssueMetadata, content: str
     ) -> List[Diagnostic]:
@@ -629,6 +698,7 @@ class IssueValidator:
         content: str,
         all_ids: Set[str] = set(),
         valid_domains: Set[str] = set(),
+        all_issues: List[IssueMetadata] = None,
     ) -> List[Diagnostic]:
         diagnostics = []
         # Check if 'domains' field exists in frontmatter text
@@ -674,6 +744,36 @@ class IssueValidator:
                     )
                 )
 
+        # FEAT-0136: Scale-Aware Domain Governance
+        # Rule: If Total Issues > 128 or Total Epics > 32, enforce strict Domain coverage
+        is_large_scale = num_issues > 128 or num_epics > 32
+        
+        # FEAT-0136: Domain Auto-Inheritance Logic
+        # If child issue has no domains but parent has, treat as inherited (logical inheritance)
+        if meta.type != "epic" and not meta.domains and meta.parent and all_issues and is_large_scale:
+            parent_issue = None
+            for issue in all_issues:
+                if issue.id == meta.parent:
+                    parent_issue = issue
+                    break
+            
+            if parent_issue and parent_issue.domains:
+                # Parent has domains, child inherits them logically
+                # This is not an error - it's valid inheritance
+                pass
+            elif parent_issue and not parent_issue.domains:
+                # Parent also has no domains in large scale mode - this is an error
+                line = self._get_field_line(content, "domains")
+                diagnostics.append(
+                    self._create_diagnostic(
+                        f"Domain Governance: Issue '{meta.id}' has no domains assigned. "
+                        f"Parent '{meta.parent}' also has no domains. In large-scale projects, "
+                        f"at least 75% of Epics must have domains for children to inherit.",
+                        DiagnosticSeverity.Error,
+                        line=line if line > 0 else field_line,
+                    )
+                )
+
         # Domain Content Validation
         # If valid_domains is provided (from file scan), use it as strict source of truth
         if hasattr(meta, "domains") and meta.domains:

monoco/features/memo/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
 
 
-class MemoFeature(MonocoFeature):
-    @property
-    def name(self) -> str:
-        return "memo"
+class MemoFeature(FeatureModule):
+    """Memo (fleeting notes) feature module with unified lifecycle support."""
 
-    def initialize(self, root: Path, config: Dict) -> None:
-        # Memo feature doesn't require explicit initialization
-        # The inbox is created on first use
+    @property
+    def metadata(self) -> FeatureMetadata:
+        return FeatureMetadata(
+            name="memo",
+            version="1.0.0",
+            description="Fleeting notes and quick idea capture",
+            dependencies=["core"],
+            priority=40,
+            lazy=True,  # Can be lazy loaded
+        )
+
+    def _on_mount(self, context: "FeatureContext") -> None:  # type: ignore
+        """Memo feature doesn't require explicit initialization.
+
+        The inbox is created on first use.
+        """
         pass
 
     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")
 

monoco/features/memo/cli.py

@@ -4,7 +4,7 @@ from typing import Optional
 from rich.console import Console
 from rich.table import Table
 from monoco.core.config import get_config
-from .core import add_memo, list_memos, delete_memo, get_inbox_path, validate_content_language
+from .core import add_memo, load_memos, delete_memo, update_memo, get_inbox_path, validate_content_language
 
 app = typer.Typer(help="Manage memos (fleeting notes).")
 console = Console()
@@ -26,6 +26,12 @@ def add_command(
     context: Optional[str] = typer.Option(
         None, "--context", "-c", help="Context reference (e.g. file:line)."
     ),
+    type: str = typer.Option(
+        "insight", "--type", "-t", help="Type of memo (insight, bug, feature, task)."
+    ),
+    source: str = typer.Option(
+        "cli", "--source", "-s", help="Source of the memo."
+    ),
     force: bool = typer.Option(
         False, "--force", "-f", help="Bypass i18n language validation."
     ),
@@ -47,36 +53,75 @@ def add_command(
         )
         raise typer.Exit(code=1)
 
-    uid = add_memo(issues_root, content, context)
+    # TODO: Get actual user name if possible
+    author = "User" 
+    
+    uid = add_memo(
+        issues_root, 
+        content, 
+        context=context,
+        author=author,
+        source=source,
+        memo_type=type
+    )
 
     console.print(f"[green]✔ Memo recorded.[/green] ID: [bold]{uid}[/bold]")
 
 
 @app.command("list")
-def list_command():
+def list_command(
+    status: Optional[str] = typer.Option(None, "--status", help="Filter by status (pending, tracked, resolved)."),
+    limit: int = typer.Option(None, "--limit", "-n", help="Limit number of memos shown.")
+):
     """
     List all memos in the inbox.
     """
     issues_root = get_issues_root()
 
-    memos = list_memos(issues_root)
+    memos = load_memos(issues_root)
+    
+    if status:
+        memos = [m for m in memos if m.status == status]
 
     if not memos:
-        console.print("No memos found. Use `monoco memo add` to create one.")
+        console.print("No memos found.")
         return
+        
+    # Reverse sort by timestamp (newest first) usually? 
+    # But file is appended. Let's show newest at bottom (log style) or newest at top?
+    # Usually list shows content. Newest at bottom is standard for logs, but for "Inbox" maybe newest top?
+    # Let's keep file order (oldest first) unless user asks otherwise, or maybe reverse it for "Inbox" feel?
+    # Let's reverse it to see latest first.
+    memos.reverse()
+    
+    if limit:
+        memos = memos[:limit]
 
     table = Table(title="Memo Inbox")
     table.add_column("ID", style="cyan", no_wrap=True)
-    table.add_column("Timestamp", style="magenta")
+    table.add_column("Stat", style="yellow", width=4)
+    table.add_column("Type", style="magenta", width=8)
+    table.add_column("Ref", style="blue")
     table.add_column("Content")
 
     for memo in memos:
         # Truncate content for list view
-        content_preview = memo["content"].split("\n")[0]
-        if len(memo["content"]) > 50:
+        content_preview = memo.content.split("\n")[0]
+        if len(content_preview) > 50:
             content_preview = content_preview[:47] + "..."
-
-        table.add_row(memo["id"], memo["timestamp"], content_preview)
+            
+        status_icon = " "
+        if memo.status == "pending": status_icon = "P"
+        elif memo.status == "tracked": status_icon = "T"
+        elif memo.status == "resolved": status_icon = "✔"
+        
+        table.add_row(
+            memo.uid, 
+            status_icon,
+            memo.type,
+            memo.ref or "",
+            content_preview
+        )
 
     console.print(table)
 
@@ -110,3 +155,51 @@ def delete_command(
     else:
         console.print(f"[red]Error: Memo with ID [bold]{memo_id}[/bold] not found.[/red]")
         raise typer.Exit(code=1)
+
+
+@app.command("link")
+def link_command(
+    memo_id: str = typer.Argument(..., help="Memo ID"),
+    issue_id: str = typer.Argument(..., help="Issue ID to link to")
+):
+    """
+    Link a memo to an issue (Traceability).
+    Sets status to 'tracked'.
+    """
+    issues_root = get_issues_root()
+    
+    updates = {
+        "status": "tracked",
+        "ref": issue_id
+    }
+    
+    if update_memo(issues_root, memo_id, updates):
+        console.print(f"[green]✔ Memo {memo_id} linked to {issue_id}.[/green]")
+    else:
+        console.print(f"[red]Error: Memo {memo_id} not found.[/red]")
+        raise typer.Exit(code=1)
+
+
+@app.command("resolve")
+def resolve_command(
+    memo_id: str = typer.Argument(..., help="Memo ID")
+):
+    """
+    Mark a memo as resolved.
+    """
+    issues_root = get_issues_root()
+    
+    updates = {
+        "status": "resolved"
+    }
+    
+    if update_memo(issues_root, memo_id, updates):
+        console.print(f"[green]✔ Memo {memo_id} resolved.[/green]")
+    else:
+        console.print(f"[red]Error: Memo {memo_id} not found.[/red]")
+        raise typer.Exit(code=1)
+
+
+
+
+

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