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

monoco/features/issue/domain_service.py

@@ -0,0 +1,69 @@
+from typing import Dict, Optional, Set
+from monoco.core.config import get_config, DomainConfig
+
+
+class DomainService:
+    """
+    Service for managing domain ontology, aliases, and validation.
+    """
+
+    def __init__(self, config: Optional[DomainConfig] = None):
+        self.config = config or get_config().domains
+        self._alias_map: Dict[str, str] = {}
+        self._canonical_domains: Set[str] = set()
+        self._build_index()
+
+    def _build_index(self):
+        self._alias_map.clear()
+        self._canonical_domains.clear()
+
+        for item in self.config.items:
+            self._canonical_domains.add(item.name)
+            for alias in item.aliases:
+                self._alias_map[alias] = item.name
+
+    def reload(self):
+        """Reload configuration (if get_config returns new instance referenced)"""
+        # Usually get_config() returns the singleton. If singleton updates, we might see it?
+        # But we stored self.config.
+        # Ideally we fetch fresh config if we want reload.
+        self.config = get_config().domains
+        self._build_index()
+
+    def is_defined(self, domain: str) -> bool:
+        """Check if domain is known (canonical or alias)."""
+        return domain in self._canonical_domains or domain in self._alias_map
+
+    def is_canonical(self, domain: str) -> bool:
+        """Check if domain is a canonical name."""
+        return domain in self._canonical_domains
+
+    def is_alias(self, domain: str) -> bool:
+        """Check if domain is a known alias."""
+        return domain in self._alias_map
+
+    def get_canonical(self, domain: str) -> Optional[str]:
+        """
+        Resolve alias to canonical name.
+        Returns Canonical Name if found.
+        Returns None if it is not an alias (could be canonical or unknown).
+        """
+        return self._alias_map.get(domain)
+
+    def normalize(self, domain: str) -> str:
+        """
+        Normalize domain: return canonical if it's an alias, else return original.
+        """
+        return self._alias_map.get(domain, domain)
+
+    def suggest_correction(self, domain: str) -> Optional[str]:
+        """
+        Suggest a correction for an unknown domain (Fuzzy matching).
+        """
+        # Simple fuzzy match implementation (optional)
+        # Using simple containment or levenshtein if available?
+        # Let's keep it simple: check if domain is substring of canonical?
+        # Or simple typo check loop.
+
+        # For now, just return None as fuzzy match is optional and requires dependency or complex logic
+        return None

monoco/features/issue/linter.py

@@ -7,7 +7,7 @@ import re
 from monoco.core import git
 from . import core
 from .validator import IssueValidator
-from monoco.core.lsp import Diagnostic, DiagnosticSeverity
+from monoco.core.lsp import Diagnostic, DiagnosticSeverity, Range, Position
 
 console = Console()
 
@@ -68,15 +68,29 @@ def check_integrity(issues_root: Path, recursive: bool = False) -> List[Diagnost
                         files.extend(status_dir.rglob("*.md"))
 
                 for f in files:
-                    meta = core.parse_issue(f)
-                    if meta:
-                        local_id = meta.id
-                        full_id = f"{project_name}::{local_id}"
-
-                        all_issue_ids.add(local_id)
-                        all_issue_ids.add(full_id)
-
-                        project_issues.append((f, meta))
+                    try:
+                        meta = core.parse_issue(f, raise_error=True)
+                        if meta:
+                            local_id = meta.id
+                            full_id = f"{project_name}::{local_id}"
+
+                            all_issue_ids.add(local_id)
+                            all_issue_ids.add(full_id)
+
+                            project_issues.append((f, meta))
+                    except Exception as e:
+                        # Report parsing failure as diagnostic
+                        d = Diagnostic(
+                            range=Range(
+                                start=Position(line=0, character=0),
+                                end=Position(line=0, character=0),
+                            ),
+                            message=f"Schema Error: {str(e)}",
+                            severity=DiagnosticSeverity.Error,
+                            source="System",
+                        )
+                        d.data = {"path": f}
+                        diagnostics.append(d)
         return project_issues
 
     from monoco.core.config import get_config
@@ -193,7 +207,7 @@ def run_lint(
 
             # Parse and validate file
             try:
-                meta = core.parse_issue(file)
+                meta = core.parse_issue(file, raise_error=True)
                 if not meta:
                     console.print(
                         f"[yellow]Warning:[/yellow] Failed to parse issue metadata from {file_path}. Skipping."
@@ -315,6 +329,36 @@ def run_lint(
                                 new_content = "\n".join(lines) + "\n"
                                 has_changes = True
 
+                    if (
+                        "Hierarchy Violation" in d.message
+                        and "Epics must have a parent" in d.message
+                    ):
+                        try:
+                            fm_match = re.search(
+                                r"^---(.*?)---", new_content, re.DOTALL | re.MULTILINE
+                            )
+                            if fm_match:
+                                import yaml
+
+                                fm_text = fm_match.group(1)
+                                data = yaml.safe_load(fm_text) or {}
+
+                                # Default to EPIC-0000
+                                data["parent"] = "EPIC-0000"
+
+                                new_fm_text = yaml.dump(
+                                    data, sort_keys=False, allow_unicode=True
+                                )
+                                # Replace FM block
+                                new_content = new_content.replace(
+                                    fm_match.group(1), "\n" + new_fm_text
+                                )
+                                has_changes = True
+                        except Exception as ex:
+                            console.print(
+                                f"[red]Failed to fix parent hierarchy: {ex}[/red]"
+                            )
+
                     if "Tag Check: Missing required context tags" in d.message:
                         # Extract missing tags from message
                         # Message format: "Tag Check: Missing required context tags: #TAG1, #TAG2"
@@ -426,6 +470,70 @@ def run_lint(
             except Exception as e:
                 console.print(f"[red]Failed to fix domains for {path.name}: {e}[/red]")
 
+            # Domain Alias Fix
+            try:
+                alias_fixes = [
+                    d for d in current_file_diags if "Domain Alias:" in d.message
+                ]
+                if alias_fixes:
+                    fm_match = re.search(
+                        r"^---(.*?)---", new_content, re.DOTALL | re.MULTILINE
+                    )
+                    if fm_match:
+                        import yaml
+
+                        fm_text = fm_match.group(1)
+                        data = yaml.safe_load(fm_text) or {}
+
+                        domain_changed = False
+                        if "domains" in data and isinstance(data["domains"], list):
+                            domains = data["domains"]
+                            for d in alias_fixes:
+                                # Parse message: Domain Alias: 'alias' is an alias for 'canonical'.
+                                m = re.search(
+                                    r"Domain Alias: '([^']+)' is an alias for '([^']+)'",
+                                    d.message,
+                                )
+                                if m:
+                                    old_d = m.group(1)
+                                    new_d = m.group(2)
+
+                                    if old_d in domains:
+                                        domains = [
+                                            new_d if x == old_d else x for x in domains
+                                        ]
+                                        domain_changed = True
+
+                            if domain_changed:
+                                data["domains"] = domains
+                                new_fm_text = yaml.dump(
+                                    data, sort_keys=False, allow_unicode=True
+                                )
+                                new_content = new_content.replace(
+                                    fm_match.group(1), "\n" + new_fm_text
+                                )
+                                has_changes = True
+
+                                # Write immediately if not handled by previous block?
+                                # We are in standard flow where has_changes flag handles write at end of loop?
+                                # Wait, the previous block (Missing domains) logic wrote internally ONLY if has_changes.
+                                # AND it reset has_changes=False at start of try?
+                                # Actually the previous block structure was separate try-except blocks.
+                                # But here I am inserting AFTER the Missing Domains try-except (which was lines 390-442).
+                                # But I need to write if I changed it.
+                                path.write_text(new_content)
+                                if not any(path == p for p in processed_paths):
+                                    fixed_count += 1
+                                    processed_paths.add(path)
+                                console.print(
+                                    f"[dim]Fixed (Domain Alias): {path.name}[/dim]"
+                                )
+
+            except Exception as e:
+                console.print(
+                    f"[red]Failed to fix domain aliases for {path.name}: {e}[/red]"
+                )
+
         console.print(f"[green]Applied auto-fixes to {fixed_count} files.[/green]")
 
         # Re-run validation to verify

monoco/features/issue/validator.py

@@ -444,6 +444,17 @@ class IssueValidator:
         if not all_ids:
             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
@@ -575,6 +586,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 +597,7 @@ class IssueValidator:
             elif in_fm:
                 if stripped.startswith("domains:"):
                     has_domains_field = True
+                    field_line = i
                     break
 
         # Governance Maturity Check
@@ -607,6 +620,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,204 @@
+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")
+
+
+@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:
+        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.model.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
+            from .defaults import DEFAULT_ROLES
+
+            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:
+            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")
+
+
+@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

@@ -0,0 +1,32 @@
+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]:
+    """
+    Load scheduler configuration from .monoco/scheduler.yaml
+    Merges with default roles.
+    """
+    roles = {role.name: role for role in DEFAULT_ROLES}
+
+    config_path = project_root / ".monoco" / "scheduler.yaml"
+    if config_path.exists():
+        try:
+            with open(config_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
+                config = SchedulerConfig(roles=data["roles"])
+                for role in config.roles:
+                    roles[role.name] = role
+        except Exception as e:
+            # For now, just log or print. Ideally use a logger.
+            print(f"Warning: Failed to load scheduler config: {e}")
+
+    return roles

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",
+    ),
+]

monoco/features/scheduler/manager.py

@@ -0,0 +1,49 @@
+from typing import Dict, List, Optional
+import uuid
+from .models import RoleTemplate
+from .worker import Worker
+from .session import Session, RuntimeSession
+
+
+class SessionManager:
+    """
+    Manages the lifecycle of sessions.
+    Responsible for creating, tracking, and retrieving sessions.
+    """
+
+    def __init__(self):
+        # In-memory storage for now. In prod, this might be a DB or file-backed.
+        self._sessions: Dict[str, RuntimeSession] = {}
+
+    def create_session(self, issue_id: str, role: RoleTemplate) -> RuntimeSession:
+        session_id = str(uuid.uuid4())
+        branch_name = (
+            f"agent/{issue_id}/{session_id[:8]}"  # Simple branch naming strategy
+        )
+
+        session_model = Session(
+            id=session_id,
+            issue_id=issue_id,
+            role_name=role.name,
+            branch_name=branch_name,
+        )
+
+        worker = Worker(role, issue_id)
+        runtime = RuntimeSession(session_model, worker)
+        self._sessions[session_id] = runtime
+        return runtime
+
+    def get_session(self, session_id: str) -> Optional[RuntimeSession]:
+        return self._sessions.get(session_id)
+
+    def list_sessions(self, issue_id: Optional[str] = None) -> List[RuntimeSession]:
+        if issue_id:
+            return [s for s in self._sessions.values() if s.model.issue_id == issue_id]
+        return list(self._sessions.values())
+
+    def terminate_session(self, session_id: str):
+        session = self.get_session(session_id)
+        if session:
+            session.terminate()
+            # We might want to keep the record for a while, so don't delete immediately
+            # del self._sessions[session_id]