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

monoco/features/issue/test_resolver.py

@@ -0,0 +1,83 @@
+from monoco.features.issue.resolver import ReferenceResolver, ResolutionContext
+
+
+def test_resolve_explicit_namespace():
+    context = ResolutionContext(
+        current_project="toolkit",
+        workspace_root="monoco",
+        available_ids={"toolkit::FEAT-0001", "monoco::FEAT-0001", "EPIC-0001"},
+    )
+    resolver = ReferenceResolver(context)
+
+    # Explicitly project reference
+    assert resolver.resolve("toolkit::FEAT-0001") == "toolkit::FEAT-0001"
+    assert resolver.resolve("monoco::FEAT-0001") == "monoco::FEAT-0001"
+
+    # Non-existent namespace
+    assert resolver.resolve("other::FEAT-0001") is None
+
+
+def test_resolve_proximity_current_project():
+    context = ResolutionContext(
+        current_project="toolkit",
+        workspace_root="monoco",
+        available_ids={
+            "toolkit::FEAT-0001",
+            "monoco::FEAT-0001",
+        },
+    )
+    resolver = ReferenceResolver(context)
+
+    # Should prefer current project
+    assert resolver.resolve("FEAT-0001") == "toolkit::FEAT-0001"
+
+
+def test_resolve_root_fallback():
+    context = ResolutionContext(
+        current_project="toolkit",
+        workspace_root="monoco",
+        available_ids={
+            "monoco::EPIC-0000",
+            "toolkit::FEAT-0001",
+        },
+    )
+    resolver = ReferenceResolver(context)
+
+    # Should fallback to root if not in current
+    assert resolver.resolve("EPIC-0000") == "monoco::EPIC-0000"
+
+
+def test_resolve_local_ids():
+    context = ResolutionContext(
+        current_project="toolkit",
+        workspace_root="monoco",
+        available_ids={
+            "EPIC-9999",
+        },
+    )
+    resolver = ReferenceResolver(context)
+
+    # Should resolve plain local IDs
+    assert resolver.resolve("EPIC-9999") == "EPIC-9999"
+
+
+def test_priority_order():
+    context = ResolutionContext(
+        current_project="toolkit",
+        workspace_root="monoco",
+        available_ids={"toolkit::FEAT-0001", "monoco::FEAT-0001", "FEAT-0001"},
+    )
+    resolver = ReferenceResolver(context)
+
+    # Order: toolkit::FEAT-0001 > monoco::FEAT-0001 > FEAT-0001
+    assert resolver.resolve("FEAT-0001") == "toolkit::FEAT-0001"
+
+    # If removed from toolkit context
+    context.available_ids.remove("toolkit::FEAT-0001")
+    resolver = ReferenceResolver(context)
+    assert resolver.resolve("FEAT-0001") == "monoco::FEAT-0001"
+
+    # If removed from root context
+    context.available_ids.remove("monoco::FEAT-0001")
+    resolver = ReferenceResolver(context)
+    assert resolver.resolve("FEAT-0001") == "FEAT-0001"

monoco/features/issue/validator.py

@@ -8,6 +8,7 @@ from monoco.features.i18n.core import detect_language
 from .models import IssueMetadata
 from .domain.parser import MarkdownParser
 from .domain.models import ContentBlock
+from .resolver import ReferenceResolver, ResolutionContext
 
 
 class IssueValidator:
@@ -20,9 +21,19 @@ class IssueValidator:
         self.issue_root = issue_root
 
     def validate(
-        self, meta: IssueMetadata, content: str, all_issue_ids: Set[str] = set()
+        self,
+        meta: IssueMetadata,
+        content: str,
+        all_issue_ids: Set[str] = set(),
+        current_project: Optional[str] = None,
+        workspace_root: Optional[str] = None,
     ) -> List[Diagnostic]:
+        """
+        Validate an issue and return diagnostics.
+        """
         diagnostics = []
+        self._current_project = current_project
+        self._workspace_root = workspace_root
 
         # Parse Content into Blocks (Domain Layer)
         # Handle case where content might be just body (from update_issue) or full file
@@ -311,7 +322,11 @@ class IssueValidator:
                 if stripped == expected_header:
                     header_found = True
 
-                if stripped == "## Review Comments":
+                # Flexible matching for Review Comments header
+                if any(
+                    kw in stripped
+                    for kw in ["Review Comments", "评审备注", "评审记录", "Review"]
+                ):
                     review_header_found = True
                     review_header_index = i
 
@@ -406,6 +421,16 @@ class IssueValidator:
     ) -> List[Diagnostic]:
         diagnostics = []
 
+        # Initialize Resolver
+        resolver = None
+        if all_ids:
+            context = ResolutionContext(
+                current_project=self._current_project or "local",
+                workspace_root=self._workspace_root,
+                available_ids=all_ids,
+            )
+            resolver = ReferenceResolver(context)
+
         # Malformed ID Check
         if meta.parent and meta.parent.startswith("#"):
             line = self._get_field_line(content, "parent")
@@ -441,7 +466,7 @@ class IssueValidator:
                         )
                     )
 
-        if not all_ids:
+        if not all_ids or not resolver:
             return diagnostics
 
         # Logic: Epics must have a parent (unless it is the Sink Root EPIC-0000)
@@ -457,8 +482,9 @@ class IssueValidator:
 
         if (
             meta.parent
-            and meta.parent not in all_ids
+            and meta.parent != "EPIC-0000"
             and not meta.parent.startswith("#")
+            and not resolver.is_valid_reference(meta.parent)
         ):
             line = self._get_field_line(content, "parent")
             diagnostics.append(
@@ -470,7 +496,7 @@ class IssueValidator:
             )
 
         for dep in meta.dependencies:
-            if dep not in all_ids:
+            if not resolver.is_valid_reference(dep):
                 line = self._get_field_line(content, "dependencies")
                 diagnostics.append(
                     self._create_diagnostic(
@@ -503,24 +529,27 @@ class IssueValidator:
             matches = re.finditer(r"\b((?:EPIC|FEAT|CHORE|FIX)-\d{4})\b", line)
             for match in matches:
                 ref_id = match.group(1)
-                if ref_id != meta.id and ref_id not in all_ids:
-                    # Check if it's a namespaced ID? The regex only catches local IDs.
-                    # If users use MON::FEAT-0001, the regex might catch FEAT-0001.
-                    # But all_ids contains full IDs (potentially namespaced).
-                    # Simple logic: if ref_id isn't in all_ids, check if any id ENDS with ref_id
-
-                    found_namespaced = any(
-                        known.endswith(f"::{ref_id}") for known in all_ids
-                    )
+                # 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()],
+                )
 
-                    if not found_namespaced:
-                        diagnostics.append(
-                            self._create_diagnostic(
-                                f"Broken Reference: Issue '{ref_id}' not found.",
-                                DiagnosticSeverity.Warning,
-                                line=i,
-                            )
+                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
 
     def _validate_time_consistency(

monoco/features/memo/__init__.py

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

monoco/features/memo/cli.py

@@ -0,0 +1,90 @@
+import typer
+from pathlib import Path
+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
+
+app = typer.Typer(help="Manage memos (fleeting notes).")
+console = Console()
+
+
+def get_issues_root() -> Path:
+    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()
+    return project_root / config.paths.issues
+
+
+@app.command("add")
+def add_command(
+    content: str = typer.Argument(..., help="The content of the memo."),
+    context: Optional[str] = typer.Option(
+        None, "--context", "-c", help="Context reference (e.g. file:line)."
+    ),
+):
+    """
+    Capture a new idea or thought into the Memo Inbox.
+    """
+    issues_root = get_issues_root()
+
+    uid = add_memo(issues_root, content, context)
+
+    console.print(f"[green]✔ Memo recorded.[/green] ID: [bold]{uid}[/bold]")
+
+
+@app.command("list")
+def list_command():
+    """
+    List all memos in the inbox.
+    """
+    issues_root = get_issues_root()
+
+    memos = list_memos(issues_root)
+
+    if not memos:
+        console.print("No memos found. Use `monoco memo add` to create one.")
+        return
+
+    table = Table(title="Memo Inbox")
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Timestamp", style="magenta")
+    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 = content_preview[:47] + "..."
+
+        table.add_row(memo["id"], memo["timestamp"], content_preview)
+
+    console.print(table)
+
+
+@app.command("open")
+def open_command():
+    """
+    Open the inbox file in the default editor.
+    """
+    issues_root = get_issues_root()
+    inbox_path = get_inbox_path(issues_root)
+
+    if not inbox_path.exists():
+        console.print("[yellow]Inbox does not exist yet.[/yellow]")
+        return
+
+    typer.launch(str(inbox_path))

monoco/features/memo/core.py

@@ -0,0 +1,87 @@
+import re
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Optional
+import secrets
+
+
+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:
+    """
+    Append a memo to the inbox.
+    Returns the generated UID.
+    """
+    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]]:
+    """
+    Parse 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)
+
+    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})
+
+    return memos

monoco/features/scheduler/cli.py

@@ -7,6 +7,90 @@ from monoco.core.config import get_config
 from monoco.features.scheduler import SessionManager, load_scheduler_config
 
 app = typer.Typer(name="agent", help="Manage agent sessions")
+role_app = typer.Typer(name="role", help="Manage agent roles")
+
+
+@role_app.command(name="list")
+def list_roles():
+    """
+    List available agent roles and their sources.
+    """
+    from monoco.features.scheduler.config import RoleLoader
+
+    settings = get_config()
+    project_root = Path(settings.paths.root).resolve()
+
+    loader = RoleLoader(project_root)
+    roles = loader.load_all()
+
+    output = []
+    for name, role in roles.items():
+        output.append(
+            {
+                "role": name,
+                "engine": role.engine,
+                "source": loader.sources.get(name, "unknown"),
+                "description": role.description,
+            }
+        )
+
+    print_output(output, title="Agent Roles")
+
+
+@app.command()
+def draft(
+    desc: str = typer.Option(..., "--desc", "-d", help="Description of the task"),
+    type: str = typer.Option(
+        "feature", "--type", "-t", help="Issue type (feature/chore/fix)"
+    ),
+):
+    """
+    Draft a new issue based on a natural language description.
+    This creates a temporary 'drafter' agent session.
+    """
+    from monoco.core.output import print_error
+
+    settings = get_config()
+    project_root = Path(settings.paths.root).resolve()
+
+    # Load Roles
+    roles = load_scheduler_config(project_root)
+    # Use 'crafter' as the role for drafting (it handles new tasks)
+    role_name = "crafter"
+    selected_role = roles.get(role_name)
+
+    if not selected_role:
+        print_error(f"Role '{role_name}' not found.")
+        raise typer.Exit(code=1)
+
+    print_output(
+        f"Drafting {type} from description: '{desc}'",
+        title="Agent Drafter",
+    )
+
+    manager = SessionManager()
+    # We use a placeholder ID as we don't know the ID yet.
+    # The agent is expected to create the file, so the ID will be generated then.
+    session = manager.create_session("NEW_TASK", selected_role)
+
+    context = {"description": desc, "type": type}
+
+    try:
+        session.start(context=context)
+
+        # Monitoring Loop
+        while session.refresh_status() == "running":
+            time.sleep(1)
+
+        if session.model.status == "failed":
+            print_error("Drafting failed.")
+        else:
+            print_output("Drafting completed.", title="Agent Drafter")
+
+    except KeyboardInterrupt:
+        print("\nStopping...")
+        session.terminate()
+        print_output("Drafting cancelled.")
 
 
 @app.command()
@@ -43,6 +127,7 @@ def run(
         role_name = role or "builder"
         description = None
     else:
+        # Implicit Draft Mode via run command
         issue_id = "NEW_TASK"
         role_name = role or "crafter"
         description = target
@@ -84,7 +169,7 @@ def run(
             session.start(context=context)
 
         # Monitoring Loop
-        while session.model.status == "running":
+        while session.refresh_status() == "running":
             time.sleep(1)
 
         if session.model.status == "failed":
@@ -141,9 +226,15 @@ def autopsy(
         if re.match(r"^[a-zA-Z]+-\d+$", target):
             print_output(f"Session not in memory. Analyzing Issue {target} directly.")
             # We create a transient session just to trigger the coroner
-            from .defaults import DEFAULT_ROLES
+            settings = get_config()
+            project_root = Path(settings.paths.root).resolve()
+            roles = load_scheduler_config(project_root)
+            builder_role = roles.get("builder")
+
+            if not builder_role:
+                print_output("Builder role not found.", style="red")
+                raise typer.Exit(code=1)
 
-            builder_role = next(r for r in DEFAULT_ROLES if r.name == "builder")
             session = manager.create_session(target.upper(), builder_role)
             session.model.status = "failed"
         else:
@@ -192,13 +283,3 @@ def logs(session_id: str):
     # Placeholder
     print("[12:00:00] Session started")
     print("[12:00:01] Worker initialized")
-
-
-@app.command()
-def kill(session_id: str):
-    """
-    Terminate a session.
-    """
-    print_output(f"Killing session {session_id}...", title="Kill Session")
-    # Placeholder
-    print("Signal sent.")

monoco/features/scheduler/config.py

@@ -1,32 +1,68 @@
+from typing import Dict, Optional
 import yaml
 from pathlib import Path
-from typing import Dict
 from .models import RoleTemplate, SchedulerConfig
 from .defaults import DEFAULT_ROLES
 
 
-def load_scheduler_config(project_root: Path) -> Dict[str, RoleTemplate]:
+class RoleLoader:
     """
-    Load scheduler configuration from .monoco/scheduler.yaml
-    Merges with default roles.
+    Tiered configuration loader for Agent Roles.
+    Level 1: Builtin Fallback
+    Level 2: Global (~/.monoco/roles.yaml)
+    Level 3: Project (./.monoco/roles.yaml)
     """
-    roles = {role.name: role for role in DEFAULT_ROLES}
 
-    config_path = project_root / ".monoco" / "scheduler.yaml"
-    if config_path.exists():
+    def __init__(self, project_root: Optional[Path] = None):
+        self.project_root = project_root
+        self.user_home = Path.home()
+        self.roles: Dict[str, RoleTemplate] = {}
+        self.sources: Dict[str, str] = {}  # role_name -> source description
+
+    def load_all(self) -> Dict[str, RoleTemplate]:
+        # Level 1: Defaults
+        for role in DEFAULT_ROLES:
+            self.roles[role.name] = role
+            self.sources[role.name] = "builtin"
+
+        # Level 2: Global
+        global_path = self.user_home / ".monoco" / "roles.yaml"
+        self._load_from_path(global_path, "global")
+
+        # Level 3: Project
+        if self.project_root:
+            project_path = self.project_root / ".monoco" / "roles.yaml"
+            self._load_from_path(project_path, "project")
+
+        return self.roles
+
+    def _load_from_path(self, path: Path, source_label: str):
+        if not path.exists():
+            return
+
         try:
-            with open(config_path, "r") as f:
+            with open(path, "r") as f:
                 data = yaml.safe_load(f) or {}
 
-            # Use Pydantic to validate the whole config if possible, or just the roles list
-            # Depending on file structure. Assuming the file has a 'roles' key.
             if "roles" in data:
-                # We can validate using SchedulerConfig
+                # Validate using SchedulerConfig
                 config = SchedulerConfig(roles=data["roles"])
                 for role in config.roles:
-                    roles[role.name] = role
+                    # Level 3 > Level 2 > Level 1 (名字相同的 Role 进行覆盖/Merge)
+                    # Currently we do total replacement for same-named roles
+                    self.roles[role.name] = role
+                    self.sources[role.name] = str(path)
         except Exception as e:
-            # For now, just log or print. Ideally use a logger.
-            print(f"Warning: Failed to load scheduler config: {e}")
+            # We don't want to crash the whole tool if a config is malformed,
+            # but we should probably warn.
+            import sys
+
+            print(f"Warning: Failed to load roles from {path}: {e}", file=sys.stderr)
+
 
-    return roles
+def load_scheduler_config(project_root: Path) -> Dict[str, RoleTemplate]:
+    """
+    Legacy compatibility wrapper for functional access.
+    """
+    loader = RoleLoader(project_root)
+    return loader.load_all()