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

monoco/features/issue/validator.py

@@ -27,6 +27,7 @@ class IssueValidator:
         all_issue_ids: Set[str] = set(),
         current_project: Optional[str] = None,
         workspace_root: Optional[str] = None,
+        valid_domains: Set[str] = set(),
     ) -> List[Diagnostic]:
         """
         Validate an issue and return diagnostics.
@@ -77,7 +78,11 @@ class IssueValidator:
         diagnostics.extend(self._validate_references(meta, content, all_issue_ids))
 
         # 5.5 Domain Integrity
-        diagnostics.extend(self._validate_domains(meta, content, all_issue_ids))
+        diagnostics.extend(
+            self._validate_domains(
+                meta, content, all_issue_ids, valid_domains=valid_domains
+            )
+        )
 
         # 6. Time Consistency
         diagnostics.extend(self._validate_time_consistency(meta, content))
@@ -88,6 +93,9 @@ class IssueValidator:
         # 8. Language Consistency
         diagnostics.extend(self._validate_language_consistency(meta, content))
 
+        # 9. Placeholder Detection
+        diagnostics.extend(self._validate_placeholders(meta, content))
+
         return diagnostics
 
     def _validate_language_consistency(
@@ -431,7 +439,7 @@ class IssueValidator:
             )
             resolver = ReferenceResolver(context)
 
-        # Malformed ID Check
+        # 1. Malformed ID Check (Syntax)
         if meta.parent and meta.parent.startswith("#"):
             line = self._get_field_line(content, "parent")
             diagnostics.append(
@@ -466,7 +474,63 @@ class IssueValidator:
                         )
                     )
 
-        if not all_ids or not resolver:
+        # 2. Body Reference Check (Format and Existence)
+        lines = content.split("\n")
+        in_fm = False
+        fm_end = 0
+        for i, line in enumerate(lines):
+            if line.strip() == "---":
+                if not in_fm:
+                    in_fm = True
+                else:
+                    fm_end = i
+                    break
+
+        for i, line in enumerate(lines):
+            if i <= fm_end:
+                continue  # Skip frontmatter
+
+            # Find all matches, including those with invalid suffixes to report them properly
+            matches = re.finditer(r"\b((?:EPIC|FEAT|CHORE|FIX)-\d{4}(?:-\d+)?)\b", line)
+            for match in matches:
+                full_raw_id = match.group(1)
+
+                # Check if it has an invalid suffix (e.g. FEAT-0099-1)
+                if len(full_raw_id.split("-")) > 2:
+                    diagnostics.append(
+                        self._create_diagnostic(
+                            f"Invalid ID Format: '{full_raw_id}' has an invalid suffix. Use 'parent' field for hierarchy.",
+                            DiagnosticSeverity.Warning,
+                            line=i,
+                        )
+                    )
+                    continue
+
+                ref_id = full_raw_id
+
+                # Knowledge Check (Only if resolver is available)
+                if resolver:
+                    # Check for namespaced ID before this match?
+                    full_match = re.search(
+                        r"\b(?:([a-z0-9_-]+)::)?(" + re.escape(ref_id) + r")\b",
+                        line[max(0, match.start() - 50) : match.end()],
+                    )
+
+                    check_id = ref_id
+                    if full_match and full_match.group(1):
+                        check_id = f"{full_match.group(1)}::{ref_id}"
+
+                    if ref_id != meta.id and not resolver.is_valid_reference(check_id):
+                        diagnostics.append(
+                            self._create_diagnostic(
+                                f"Broken Reference: Issue '{check_id}' not found.",
+                                DiagnosticSeverity.Warning,
+                                line=i,
+                            )
+                        )
+
+        # 3. Hierarchy and Graph Integrity (Requires Resolver)
+        if not resolver:
             return diagnostics
 
         # Logic: Epics must have a parent (unless it is the Sink Root EPIC-0000)
@@ -506,49 +570,6 @@ class IssueValidator:
                     )
                 )
 
-        # Body Reference Check
-        # Regex for generic issue ID: (EPIC|FEAT|CHORE|FIX)-\d{4}
-        # We scan line by line to get line numbers
-        lines = content.split("\n")
-        # Skip frontmatter for body check to avoid double counting (handled above)
-        in_fm = False
-        fm_end = 0
-        for i, line in enumerate(lines):
-            if line.strip() == "---":
-                if not in_fm:
-                    in_fm = True
-                else:
-                    fm_end = i
-                    break
-
-        for i, line in enumerate(lines):
-            if i <= fm_end:
-                continue  # Skip frontmatter
-
-            # Find all matches
-            matches = re.finditer(r"\b((?:EPIC|FEAT|CHORE|FIX)-\d{4})\b", line)
-            for match in matches:
-                ref_id = match.group(1)
-                # Check for namespaced ID before this match?
-                # The regex above only catches the ID part.
-                # Let's adjust regex to optionally catch namespace::
-                full_match = re.search(
-                    r"\b(?:([a-z0-9_-]+)::)?(" + re.escape(ref_id) + r")\b",
-                    line[max(0, match.start() - 50) : match.end()],
-                )
-
-                check_id = ref_id
-                if full_match and full_match.group(1):
-                    check_id = f"{full_match.group(1)}::{ref_id}"
-
-                if ref_id != meta.id and not resolver.is_valid_reference(check_id):
-                    diagnostics.append(
-                        self._create_diagnostic(
-                            f"Broken Reference: Issue '{check_id}' not found.",
-                            DiagnosticSeverity.Warning,
-                            line=i,
-                        )
-                    )
         return diagnostics
         return diagnostics
 
@@ -603,7 +624,11 @@ class IssueValidator:
         return diagnostics
 
     def _validate_domains(
-        self, meta: IssueMetadata, content: str, all_ids: Set[str] = set()
+        self,
+        meta: IssueMetadata,
+        content: str,
+        all_ids: Set[str] = set(),
+        valid_domains: Set[str] = set(),
     ) -> List[Diagnostic]:
         diagnostics = []
         # Check if 'domains' field exists in frontmatter text
@@ -650,38 +675,79 @@ class IssueValidator:
                 )
 
         # Domain Content Validation
-        from .domain_service import DomainService
-
-        service = DomainService()
-
+        # If valid_domains is provided (from file scan), use it as strict source of truth
         if hasattr(meta, "domains") and meta.domains:
-            for domain in meta.domains:
-                if service.is_alias(domain):
-                    canonical = service.get_canonical(domain)
-                    diagnostics.append(
-                        self._create_diagnostic(
-                            f"Domain Alias: '{domain}' is an alias for '{canonical}'. Preference: Canonical.",
-                            DiagnosticSeverity.Warning,
-                            line=field_line,
+            if valid_domains:
+                # Use File-based validation
+                for domain in meta.domains:
+                    # 1. Format Check: PascalCase
+                    is_pascal = re.match(r"^[A-Z][a-zA-Z0-9]+$", domain) is not None
+
+                    if not is_pascal:
+                        # Suggest conversion
+                        normalized = "".join(
+                            word.capitalize()
+                            for word in re.findall(r"[a-zA-Z0-9]+", domain)
                         )
-                    )
-                elif not service.is_defined(domain):
-                    if service.config.strict:
+                        if normalized in valid_domains:
+                            diagnostics.append(
+                                self._create_diagnostic(
+                                    f"Domain Format Error: '{domain}' must be PascalCase (e.g., '{normalized}').",
+                                    DiagnosticSeverity.Error,
+                                    line=field_line,
+                                )
+                            )
+                        else:
+                            diagnostics.append(
+                                self._create_diagnostic(
+                                    f"Domain Format Error: '{domain}' must be PascalCase (no spaces/symbols).",
+                                    DiagnosticSeverity.Error,
+                                    line=field_line,
+                                )
+                            )
+                        continue
+
+                    # 2. Existence Check
+                    if domain not in valid_domains:
                         diagnostics.append(
                             self._create_diagnostic(
-                                f"Unknown Domain: '{domain}' is not defined in domain ontology.",
+                                f"Unknown Domain: '{domain}' not found. Available: {', '.join(sorted(valid_domains))}",
                                 DiagnosticSeverity.Error,
                                 line=field_line,
                             )
                         )
-                    else:
+            else:
+                # Fallback to legacy DomainService (hardcoded list)
+                from .domain_service import DomainService
+
+                service = DomainService()
+                for domain in meta.domains:
+                    if service.is_alias(domain):
+                        canonical = service.get_canonical(domain)
                         diagnostics.append(
                             self._create_diagnostic(
-                                f"Unknown Domain: '{domain}' is not defined in domain ontology.",
+                                f"Domain Alias: '{domain}' is an alias for '{canonical}'. Preference: Canonical.",
                                 DiagnosticSeverity.Warning,
                                 line=field_line,
                             )
                         )
+                    elif not service.is_defined(domain):
+                        if service.config.strict:
+                            diagnostics.append(
+                                self._create_diagnostic(
+                                    f"Unknown Domain: '{domain}' is not defined in domain ontology.",
+                                    DiagnosticSeverity.Error,
+                                    line=field_line,
+                                )
+                            )
+                        else:
+                            diagnostics.append(
+                                self._create_diagnostic(
+                                    f"Unknown Domain: '{domain}' is not defined in domain ontology.",
+                                    DiagnosticSeverity.Warning,
+                                    line=field_line,
+                                )
+                            )
 
         return diagnostics
 
@@ -716,3 +782,57 @@ class IssueValidator:
                         )
 
         return diagnostics
+
+    def _validate_placeholders(
+        self, meta: IssueMetadata, content: str
+    ) -> List[Diagnostic]:
+        """
+        Detect uncleared placeholders in issue content.
+        
+        Placeholders are template hints that should be removed before submission.
+        Examples:
+        - <!-- Required for Review/Done stage. Record review feedback here. -->
+        - <!-- TODO: Add implementation details -->
+        - <!-- Placeholder: ... -->
+        
+        Severity depends on stage:
+        - review/done: ERROR (must be cleared before submission)
+        - draft/open/doing: WARNING (should be cleared)
+        """
+        diagnostics = []
+        
+        # Define placeholder patterns
+        placeholder_patterns = [
+            # HTML comments with common placeholder keywords
+            (r"<!--\s*Required for Review/Done stage.*?-->", "Review/Done placeholder"),
+            (r"<!--\s*TODO:.*?-->", "TODO placeholder"),
+            (r"<!--\s*FIXME:.*?-->", "FIXME placeholder"),
+            (r"<!--\s*Placeholder:.*?-->", "Generic placeholder"),
+            (r"<!--\s*Template:.*?-->", "Template placeholder"),
+            (r"<!--\s*Example:.*?-->", "Example placeholder"),
+            # Generic instruction patterns (English and Chinese)
+            (r"<!--\s*Record review feedback here.*?-->", "Review placeholder"),
+            (r"<!--\s*在此记录评审反馈.*?-->", "Review placeholder (Chinese)"),
+        ]
+        
+        lines = content.splitlines()
+        
+        # Determine severity based on stage
+        if meta.stage in ["review", "done"]:
+            severity = DiagnosticSeverity.Error
+        else:
+            severity = DiagnosticSeverity.Warning
+        
+        for line_idx, line in enumerate(lines):
+            for pattern, desc in placeholder_patterns:
+                if re.search(pattern, line, re.IGNORECASE):
+                    diagnostics.append(
+                        self._create_diagnostic(
+                            f"Uncleared Placeholder: {desc} found. Remove template hints before submission.",
+                            severity,
+                            line_idx,
+                        )
+                    )
+                    break  # Only report once per line
+        
+        return diagnostics

monoco/features/memo/__init__.py

@@ -1,3 +1,4 @@
 from .cli import app
+from .adapter import MemoFeature
 
-__all__ = ["app"]
+__all__ = ["app", "MemoFeature"]

monoco/features/memo/adapter.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+from typing import Dict
+from monoco.core.feature import MonocoFeature, IntegrationData
+
+
+class MemoFeature(MonocoFeature):
+    @property
+    def name(self) -> str:
+        return "memo"
+
+    def initialize(self, root: Path, config: Dict) -> None:
+        # Memo feature doesn't require explicit initialization
+        # The inbox is created on first use
+        pass
+
+    def integrate(self, root: Path, config: Dict) -> IntegrationData:
+        # Determine language from config, default to 'en'
+        lang = config.get("i18n", {}).get("source_lang", "en")
+
+        # Resource path: monoco/features/memo/resources/{lang}/AGENTS.md
+        base_dir = Path(__file__).parent / "resources"
+
+        # Try specific language, fallback to 'en'
+        prompt_file = base_dir / lang / "AGENTS.md"
+        if not prompt_file.exists():
+            prompt_file = base_dir / "en" / "AGENTS.md"
+
+        content = ""
+        if prompt_file.exists():
+            content = prompt_file.read_text(encoding="utf-8").strip()
+
+        return IntegrationData(system_prompts={"Memo (Fleeting Notes)": content})

monoco/features/memo/cli.py

@@ -4,25 +4,16 @@ 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, get_inbox_path
+from .core import add_memo, list_memos, delete_memo, get_inbox_path, validate_content_language
 
 app = typer.Typer(help="Manage memos (fleeting notes).")
 console = Console()
 
 
-def get_issues_root() -> Path:
-    config = get_config()
+def get_issues_root(config=None) -> Path:
+    if config is None:
+        config = get_config()
     # Resolve absolute path for issues
-    root = Path(config.paths.root).resolve()
-    # If config.paths.root is '.', it means current or discovered root.
-    # We should trust get_config's loading mechanism, but find_monoco_root might be safer to base off.
-    # Update: config is loaded relative to where it was found.
-    # Let's rely on config.paths.root if it's absolute, or relative to CWD?
-    # Actually, the ConfigLoader doesn't mutate paths.root based on location.
-    # It defaults to "."
-
-    # Better approach:
-    # Use find_monoco_root() to get base, then append config.paths.issues
     from monoco.core.config import find_monoco_root
 
     project_root = find_monoco_root()
@@ -35,11 +26,26 @@ def add_command(
     context: Optional[str] = typer.Option(
         None, "--context", "-c", help="Context reference (e.g. file:line)."
     ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Bypass i18n language validation."
+    ),
 ):
     """
     Capture a new idea or thought into the Memo Inbox.
     """
-    issues_root = get_issues_root()
+    config = get_config()
+    issues_root = get_issues_root(config)
+
+    # Language Validation
+    source_lang = config.i18n.source_lang
+    if not force and not validate_content_language(content, source_lang):
+        console.print(
+            f"[red]Error: Content language mismatch.[/red] Content does not match configured source language: [bold]{source_lang}[/bold]."
+        )
+        console.print(
+            "[yellow]Tip: Use --force to bypass this check if you really want to add this content.[/yellow]"
+        )
+        raise typer.Exit(code=1)
 
     uid = add_memo(issues_root, content, context)
 
@@ -88,3 +94,19 @@ def open_command():
         return
 
     typer.launch(str(inbox_path))
+
+
+@app.command("delete")
+def delete_command(
+    memo_id: str = typer.Argument(..., help="The ID of the memo to delete.")
+):
+    """
+    Delete a memo from the inbox by its ID.
+    """
+    issues_root = get_issues_root()
+
+    if delete_memo(issues_root, memo_id):
+        console.print(f"[green]✔ Memo [bold]{memo_id}[/bold] deleted successfully.[/green]")
+    else:
+        console.print(f"[red]Error: Memo with ID [bold]{memo_id}[/bold] not found.[/red]")
+        raise typer.Exit(code=1)

monoco/features/memo/core.py

@@ -5,6 +5,23 @@ from typing import List, Dict, Optional
 import secrets
 
 
+def is_chinese(text: str) -> bool:
+    """Check if the text contains at least one Chinese character."""
+    return any("\u4e00" <= char <= "\u9fff" for char in text)
+
+
+def validate_content_language(content: str, source_lang: str) -> bool:
+    """
+    Check if content matches source language using simple heuristics.
+    Returns True if matched or if detection is not supported for the lang.
+    """
+    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
+
+
 def get_memos_dir(issues_root: Path) -> Path:
     """
     Get the directory for memos.
@@ -85,3 +102,45 @@ def list_memos(issues_root: Path) -> List[Dict[str, str]]:
         memos.append({"id": uid, "timestamp": timestamp, "content": body})
 
     return memos
+
+
+def delete_memo(issues_root: Path, memo_id: str) -> bool:
+    """
+    Delete a memo by its ID.
+    Returns True if deleted, False if not found.
+    """
+    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)
+
+    matches = list(pattern.finditer(content))
+    target_idx = -1
+    for i, m in enumerate(matches):
+        if m.group(1) == memo_id:
+            target_idx = i
+            break
+
+    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

monoco/features/memo/resources/en/skills/monoco_memo/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: monoco-memo
+description: Lightweight memo system for quickly recording ideas, inspirations, and temporary notes. Distinguished from the formal Issue system.
+type: standard
+version: 1.0.0
+---
+
+# Monoco Memo
+
+Use this skill to quickly capture fleeting notes (fleeting ideas) without creating a formal Issue.
+
+## When to Use Memo vs Issue
+
+| Scenario | Use | Reason |
+|----------|-----|--------|
+| Temporary ideas, inspirations | **Memo** | No tracking needed, no completion status required |
+| Code snippets, link bookmarks | **Memo** | Quick record, organize later |
+| Meeting notes | **Memo** | Record first, then extract tasks |
+| Actionable work unit | **Issue** | Requires tracking, acceptance criteria, lifecycle |
+| Bug fix | **Issue** | Needs to record reproduction steps, verification results |
+| Feature development | **Issue** | Needs design, decomposition, delivery |
+
+> **Core Principle**: Memos record **ideas**; Issues handle **actionable tasks**.
+
+## Commands
+
+### Add Memo
+
+```bash
+monoco memo add "Your memo content"
+```
+
+Optional parameters:
+- `-c, --context`: Add context reference (e.g., `file:line`)
+
+Examples:
+```bash
+# Simple record
+monoco memo add "Consider using Redis cache for user sessions"
+
+# Record with context
+monoco memo add "Recursion here may cause stack overflow" -c "src/utils.py:42"
+```
+
+### View Memo List
+
+```bash
+monoco memo list
+```
+
+Displays all unarchived memos.
+
+### Open Memo File
+
+```bash
+monoco memo open
+```
+
+Opens the memo file in the default editor for organizing or batch editing.
+
+## Workflow
+
+```
+Idea flashes → monoco memo add "..." → Regular organization → Extract into Issue or archive
+```
+
+1. **Capture**: Use `monoco memo add` immediately when you have an idea
+2. **Organize**: Regularly (e.g., daily/weekly) run `monoco memo list` to review
+3. **Convert**: Transform valuable memos into formal Issues
+4. **Archive**: Remove from memos after processing
+
+## Best Practices
+
+1. **Keep concise**: Memos are quick notes, no detailed description needed
+2. **Convert timely**: Valuable ideas should be converted to Issue as soon as possible to avoid forgetting
+3. **Clean up regularly**: Memos are temporary, don't let them accumulate indefinitely
+4. **Use context**: When recording code-related ideas, use `-c` parameter to mark the location