monoco-toolkit 0.3.2__py3-none-any.whl → 0.3.5__py3-none-any.whl

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,13 +466,25 @@ 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)
+        if meta.type == "epic" and meta.id != "EPIC-0000" and not meta.parent:
+            line = self._get_field_line(content, "parent")
+            diagnostics.append(
+                self._create_diagnostic(
+                    "Hierarchy Violation: Epics must have a parent (e.g., 'EPIC-0000').",
+                    DiagnosticSeverity.Error,
+                    line=line,
+                )
+            )
+
         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(
@@ -459,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(
@@ -492,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(
@@ -575,6 +615,7 @@ class IssueValidator:
         has_domains_field = False
         lines = content.splitlines()
         in_fm = False
+        field_line = 0
         for i, line_content in enumerate(lines):
             stripped = line_content.strip()
             if stripped == "---":
@@ -585,6 +626,7 @@ class IssueValidator:
             elif in_fm:
                 if stripped.startswith("domains:"):
                     has_domains_field = True
+                    field_line = i
                     break
 
         # Governance Maturity Check
@@ -607,6 +649,40 @@ class IssueValidator:
                     )
                 )
 
+        # Domain Content Validation
+        from .domain_service import DomainService
+
+        service = DomainService()
+
+        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,
+                        )
+                    )
+                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
 
     def _validate_checkbox_logic_blocks(

monoco/features/scheduler/__init__.py

@@ -0,0 +1,19 @@
+from .models import RoleTemplate, SchedulerConfig
+from .worker import Worker
+from .config import load_scheduler_config
+from .defaults import DEFAULT_ROLES
+from .session import Session, RuntimeSession
+from .manager import SessionManager
+from .reliability import ApoptosisManager
+
+__all__ = [
+    "RoleTemplate",
+    "SchedulerConfig",
+    "Worker",
+    "load_scheduler_config",
+    "DEFAULT_ROLES",
+    "Session",
+    "RuntimeSession",
+    "SessionManager",
+    "ApoptosisManager",
+]

monoco/features/scheduler/cli.py

@@ -0,0 +1,285 @@
+import typer
+import time
+from pathlib import Path
+from typing import Optional
+from monoco.core.output import print_output
+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()
+def run(
+    target: str = typer.Argument(
+        ..., help="Issue ID (e.g. FEAT-101) or a Task Description in quotes."
+    ),
+    role: Optional[str] = typer.Option(
+        None,
+        help="Specific role to use (crafter/builder/auditor). Default: intelligent selection.",
+    ),
+    detach: bool = typer.Option(
+        False, "--detach", "-d", help="Run in background (Daemon)"
+    ),
+    fail: bool = typer.Option(
+        False, "--fail", help="Simulate a crash for testing Apoptosis."
+    ),
+):
+    """
+    Start an agent session.
+    - If TARGET is an Issue ID: Work on that issue.
+    - If TARGET is a text description: Create a new issue (Crafter).
+    """
+    settings = get_config()
+    project_root = Path(settings.paths.root).resolve()
+
+    # 1. Smart Intent Recognition
+    import re
+
+    is_id = re.match(r"^[a-zA-Z]+-\d+$", target)
+
+    if is_id:
+        issue_id = target.upper()
+        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
+
+    # 2. Load Roles
+    roles = load_scheduler_config(project_root)
+    selected_role = roles.get(role_name)
+
+    if not selected_role:
+        from monoco.core.output import print_error
+
+        print_error(f"Role '{role_name}' not found. Available: {list(roles.keys())}")
+        raise typer.Exit(code=1)
+
+    print_output(
+        f"Starting Agent Session for '{target}' as {role_name}...",
+        title="Agent Scheduler",
+    )
+
+    # 3. Initialize Session
+    manager = SessionManager()
+    session = manager.create_session(issue_id, selected_role)
+
+    if detach:
+        print_output(
+            "Background mode not fully implemented yet. Running in foreground."
+        )
+
+    try:
+        # Pass description if it's a new task
+        context = {"description": description} if description else None
+
+        if fail:
+            from monoco.core.output import rprint
+
+            rprint("[bold yellow]DEBUG: Simulating immediate crash...[/bold yellow]")
+            session.model.status = "failed"
+        else:
+            session.start(context=context)
+
+        # Monitoring Loop
+        while session.refresh_status() == "running":
+            time.sleep(1)
+
+        if session.model.status == "failed":
+            from monoco.core.output import print_error
+
+            print_error(
+                f"Session {session.model.id} FAILED. Use 'monoco agent autopsy {session.model.id}' for analysis."
+            )
+        else:
+            print_output(
+                f"Session finished with status: {session.model.status}",
+                title="Agent Scheduler",
+            )
+
+    except KeyboardInterrupt:
+        print("\nStopping...")
+        session.terminate()
+        print_output("Session terminated.")
+
+
+@app.command()
+def kill(session_id: str):
+    """
+    Terminate a session.
+    """
+    manager = SessionManager()
+    session = manager.get_session(session_id)
+    if session:
+        session.terminate()
+        print_output(f"Session {session_id} terminated.")
+    else:
+        print_output(f"Session {session_id} not found.", style="red")
+
+
+@app.command()
+def autopsy(
+    target: str = typer.Argument(..., help="Session ID or Issue ID to analyze."),
+):
+    """
+    Execute Post-Mortem analysis on a failed session or target Issue.
+    """
+    from .reliability import ApoptosisManager
+
+    manager = SessionManager()
+
+    print_output(f"Initiating Autopsy for '{target}'...", title="Coroner")
+
+    # Try to find session
+    session = manager.get_session(target)
+    if not session:
+        # Fallback: Treat target as Issue ID and create a dummy failed session context
+        import re
+
+        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
+            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)
+
+            session = manager.create_session(target.upper(), builder_role)
+            session.model.status = "failed"
+        else:
+            print_output(
+                f"Could not find session or valid Issue ID for '{target}'", style="red"
+            )
+            raise typer.Exit(code=1)
+
+    apoptosis = ApoptosisManager(manager)
+    apoptosis.trigger_apoptosis(session.model.id)
+
+
+@app.command(name="list")
+def list_sessions():
+    """
+    List active agent sessions.
+    """
+    manager = SessionManager()
+    sessions = manager.list_sessions()
+
+    output = []
+    for s in sessions:
+        output.append(
+            {
+                "id": s.model.id,
+                "issue": s.model.issue_id,
+                "role": s.model.role_name,
+                "status": s.model.status,
+                "branch": s.model.branch_name,
+            }
+        )
+
+    print_output(
+        output
+        or "No active sessions found (Note: Persistence not implemented in CLI list yet).",
+        title="Active Sessions",
+    )
+
+
+@app.command()
+def logs(session_id: str):
+    """
+    Stream logs for a session.
+    """
+    print_output(f"Streaming logs for {session_id}...", title="Session Logs")
+    # Placeholder
+    print("[12:00:00] Session started")
+    print("[12:00:01] Worker initialized")

monoco/features/scheduler/config.py

@@ -0,0 +1,68 @@
+from typing import Dict, Optional
+import yaml
+from pathlib import Path
+from .models import RoleTemplate, SchedulerConfig
+from .defaults import DEFAULT_ROLES
+
+
+class RoleLoader:
+    """
+    Tiered configuration loader for Agent Roles.
+    Level 1: Builtin Fallback
+    Level 2: Global (~/.monoco/roles.yaml)
+    Level 3: Project (./.monoco/roles.yaml)
+    """
+
+    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(path, "r") as f:
+                data = yaml.safe_load(f) or {}
+
+            if "roles" in data:
+                # Validate using SchedulerConfig
+                config = SchedulerConfig(roles=data["roles"])
+                for role in config.roles:
+                    # 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:
+            # 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)
+
+
+def load_scheduler_config(project_root: Path) -> Dict[str, RoleTemplate]:
+    """
+    Legacy compatibility wrapper for functional access.
+    """
+    loader = RoleLoader(project_root)
+    return loader.load_all()

monoco/features/scheduler/defaults.py

@@ -0,0 +1,54 @@
+from .models import RoleTemplate
+
+DEFAULT_ROLES = [
+    RoleTemplate(
+        name="crafter",
+        description="Responsible for initial design, research, and drafting issues from descriptions.",
+        trigger="task.received",
+        goal="Produce a structured Issue file and/or detailed design document.",
+        tools=[
+            "create_issue_file",
+            "read_file",
+            "search_web",
+            "view_file_outline",
+            "write_to_file",
+        ],
+        system_prompt=(
+            "You are a Crafter agent. Your goal is to turn vague ideas into structured engineering plans.\n"
+            "If the user provides a description, use 'monoco issue create' and 'monoco issue update' to build the task.\n"
+            "If the user provides an existing Issue, analyze the context and provide a detailed design or implementation plan."
+        ),
+        engine="gemini",
+    ),
+    RoleTemplate(
+        name="builder",
+        description="Responsible for implementation.",
+        trigger="design.approved",
+        goal="Implement code and tests",
+        tools=["read_file", "write_to_file", "run_command", "git"],
+        system_prompt="You are a Builder agent. Your job is to implement the code based on the design.",
+        engine="gemini",
+    ),
+    RoleTemplate(
+        name="auditor",
+        description="Responsible for code review.",
+        trigger="implementation.submitted",
+        goal="Review code and provide feedback",
+        tools=[
+            "read_file",
+            "read_terminal",
+            "run_command",
+        ],  # Assumed read_diff and lint are via run_command
+        system_prompt="You are an Auditor agent. Your job is to review the code for quality and correctness.",
+        engine="gemini",
+    ),
+    RoleTemplate(
+        name="coroner",
+        description="Responsible for analyzing failure root causes (Autopsy).",
+        trigger="session.crashed",
+        goal="Produce a post-mortem report",
+        tools=["read_file", "read_terminal", "git_log"],
+        system_prompt="You are a Coroner agent. Your job is to analyze why the previous session failed and write a post-mortem report.",
+        engine="gemini",
+    ),
+]