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

monoco/core/config.py

@@ -133,6 +133,40 @@ class IssueSchemaConfig(BaseModel):
         return self
 
 
+class DomainItem(BaseModel):
+    name: str = Field(..., description="Canonical domain name (e.g. backend.auth)")
+    description: Optional[str] = Field(None, description="Description of the domain")
+    aliases: List[str] = Field(default_factory=list, description="List of aliases")
+
+
+class DomainConfig(BaseModel):
+    items: List[DomainItem] = Field(
+        default_factory=list, description="List of defined domains"
+    )
+    strict: bool = Field(
+        default=False, description="If True, only allow defined domains"
+    )
+
+    def merge(self, other: "DomainConfig") -> "DomainConfig":
+        if not other:
+            return self
+
+        # Merge items by name
+        if other.items:
+            item_map = {item.name: item for item in self.items}
+            for item in other.items:
+                # Overwrite or merge aliases? Let's overwrite for simplicity/consistency
+                item_map[item.name] = item
+            self.items = list(item_map.values())
+
+        # Strict mode: logic? maybe strict overrides?
+        # Let's say if ANY config asks for strict, it is strict? Or last one wins (project)?
+        # Default merge is usually override.
+        self.strict = other.strict
+
+        return self
+
+
 class StateMachineConfig(BaseModel):
     transitions: List[TransitionConfig]
 
@@ -155,6 +189,7 @@ class MonocoConfig(BaseModel):
     )
 
     issue: IssueSchemaConfig = Field(default_factory=IssueSchemaConfig)
+    domains: DomainConfig = Field(default_factory=DomainConfig)
 
     @staticmethod
     def _deep_merge(base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:

monoco/core/integrations.py

@@ -134,12 +134,6 @@ DEFAULT_INTEGRATIONS: Dict[str, AgentIntegration] = {
         bin_name="kimi",
         version_cmd="--version",
     ),
-    "agent": AgentIntegration(
-        key="agent",
-        name="Antigravity",
-        system_prompt_file="GEMINI.md",
-        skill_root_dir=".agent/skills/",
-    ),
 }
 
 

monoco/core/sync.py

@@ -20,15 +20,9 @@ def _get_targets(root: Path, config, cli_target: Optional[Path]) -> List[Path]:
         targets.append(cli_target)
         return targets
 
-    # 2. Config Targets
-    if config.agent.targets:
-        for t in config.agent.targets:
-            targets.append(root / t)
-        return targets
-
-    # 3. Registry Defaults (Dynamic Detection)
+    # 2. Registry Defaults (Dynamic Detection)
     integrations = get_active_integrations(
-        root, config_overrides=config.agent.integrations, auto_detect=True
+        root, config_overrides=None, auto_detect=True
     )
 
     if integrations:
@@ -69,16 +63,9 @@ def sync_command(
     # 2. Collect Data
     collected_prompts = {}
 
-    # Filter features based on config if specified
+    # Filter features based on config if specified (Deprecated: agent config removed)
     all_features = registry.get_features()
-    active_features = []
-
-    if config.agent.includes:
-        for f in all_features:
-            if f.name in config.agent.includes:
-                active_features.append(f)
-    else:
-        active_features = all_features
+    active_features = all_features
 
     with console.status("[bold green]Collecting feature integration data...") as status:
         for feature in active_features:
@@ -109,7 +96,7 @@ def sync_command(
 
     # Get active integrations
     integrations = get_active_integrations(
-        root, config_overrides=config.agent.integrations, auto_detect=True
+        root, config_overrides=None, auto_detect=True
     )
 
     if integrations:
@@ -231,7 +218,7 @@ def uninstall_command(
 
     # Get active integrations
     integrations = get_active_integrations(
-        root, config_overrides=config.agent.integrations, auto_detect=True
+        root, config_overrides=None, auto_detect=True
     )
 
     if integrations:

monoco/features/issue/commands.py

@@ -17,6 +17,9 @@ backlog_app = typer.Typer(help="Manage backlog operations.")
 lsp_app = typer.Typer(help="LSP Server commands.")
 app.add_typer(backlog_app, name="backlog")
 app.add_typer(lsp_app, name="lsp")
+from . import domain_commands
+
+app.add_typer(domain_commands.app, name="domain")
 console = Console()
 
 
@@ -45,12 +48,12 @@ def create(
     ),
     sprint: Optional[str] = typer.Option(None, "--sprint", help="Sprint ID"),
     tags: List[str] = typer.Option([], "--tag", help="Tags"),
+    domains: List[str] = typer.Option([], "--domain", help="Domains"),
     root: Optional[str] = typer.Option(
         None, "--root", help="Override issues root directory"
     ),
     json: AgentOutput = False,
 ):
-    """Create a new issue."""
     """Create a new issue."""
     config = get_config()
     issues_root = _resolve_issues_root(config, root)
@@ -79,6 +82,7 @@ def create(
             stage=stage,
             dependencies=dependencies,
             related=related,
+            domains=domains,
             subdir=subdir,
             sprint=sprint,
             tags=tags,
@@ -99,6 +103,25 @@ def create(
             )
             console.print(f"Path: {rel_path}")
 
+            # Prompt for Language
+            target_langs = config.i18n.target_langs
+            primary_lang = target_langs[0] if target_langs else "en"
+
+            # Simple mapping for display
+            lang_display = {
+                "zh": "Chinese (Simplified)",
+                "en": "English",
+                "ja": "Japanese",
+            }.get(primary_lang, primary_lang)
+
+            console.print(
+                f"\n[bold yellow]Agent Hint:[/bold yellow] Please fill the ticket content in [bold cyan]{lang_display}[/bold cyan]."
+            )
+
+    except ValueError as e:
+        OutputManager.error(str(e))
+        raise typer.Exit(code=1)
+
     except ValueError as e:
         OutputManager.error(str(e))
         raise typer.Exit(code=1)

monoco/features/issue/core.py

@@ -53,28 +53,108 @@ def _get_slug(title: str) -> str:
     return slug
 
 
-def parse_issue(file_path: Path) -> Optional[IssueMetadata]:
+def parse_issue(file_path: Path, raise_error: bool = False) -> Optional[IssueMetadata]:
     if not file_path.suffix == ".md":
         return None
 
     content = file_path.read_text()
     match = re.search(r"^---(.*?)---", content, re.DOTALL | re.MULTILINE)
     if not match:
+        if raise_error:
+            raise ValueError(f"No frontmatter found in {file_path.name}")
         return None
 
     try:
         data = yaml.safe_load(match.group(1))
         if not isinstance(data, dict):
+            if raise_error:
+                raise ValueError(f"Frontmatter is not a dictionary in {file_path.name}")
             return None
 
         data["path"] = str(file_path.absolute())
         meta = IssueMetadata(**data)
         meta.actions = get_available_actions(meta)
         return meta
-    except Exception:
+    except Exception as e:
+        if raise_error:
+            raise e
         return None
 
 
+def _serialize_metadata(metadata: IssueMetadata) -> str:
+    """
+    Centralized serialization logic to ensure explicit fields and correct ordering.
+    """
+    # Serialize metadata
+    # We want explicit fields even if None/Empty to enforce schema awareness
+    data = metadata.model_dump(
+        exclude_none=True, mode="json", exclude={"actions", "path"}
+    )
+
+    # Force explicit keys if missing (due to exclude_none or defaults)
+    if "parent" not in data:
+        data["parent"] = None
+    if "dependencies" not in data:
+        data["dependencies"] = []
+    if "related" not in data:
+        data["related"] = []
+    if "domains" not in data:
+        data["domains"] = []
+    if "files" not in data:
+        data["files"] = []
+
+    # Custom YAML Dumper to preserve None as 'null' and order
+    # Helper to order keys: id, uid, type, status, stage, title, ... graph ...
+    # Simple sort isn't enough, we rely on insertion order (Python 3.7+)
+    ordered_data = {
+        k: data[k]
+        for k in [
+            "id",
+            "uid",
+            "type",
+            "status",
+            "stage",
+            "title",
+            "created_at",
+            "updated_at",
+        ]
+        if k in data
+    }
+    # Add graph fields
+    for k in [
+        "priority",
+        "parent",
+        "dependencies",
+        "related",
+        "domains",
+        "tags",
+        "files",
+    ]:
+        if k in data:
+            ordered_data[k] = data[k]
+        elif k in ["dependencies", "related", "domains", "tags", "files"]:
+            ordered_data[k] = []
+        elif k == "parent":
+            ordered_data[k] = None
+
+    # Add remaining
+    for k, v in data.items():
+        if k not in ordered_data:
+            ordered_data[k] = v
+
+    yaml_header = yaml.dump(
+        ordered_data, sort_keys=False, allow_unicode=True, default_flow_style=False
+    )
+
+    # Inject Comments for guidance (replace keys with key+comment)
+    if "parent" in ordered_data and ordered_data["parent"] is None:
+        yaml_header = yaml_header.replace(
+            "parent: null", "parent: null # <EPIC-ID> Optional"
+        )
+
+    return yaml_header
+
+
 def parse_issue_detail(file_path: Path) -> Optional[IssueDetail]:
     if not file_path.suffix == ".md":
         return None
@@ -127,6 +207,7 @@ def create_issue_file(
     stage: Optional[IssueStage] = None,
     dependencies: List[str] = [],
     related: List[str] = [],
+    domains: List[str] = [],
     subdir: Optional[str] = None,
     sprint: Optional[str] = None,
     tags: List[str] = [],
@@ -149,8 +230,7 @@ def create_issue_file(
 
     target_dir.mkdir(parents=True, exist_ok=True)
 
-    # Auto-Populate Tags with required IDs (Requirement: Maintain tags field with parent/deps/related/self IDs)
-    # Ensure they are prefixed with '#' for tagging convention if not present (usually tags are just strings, but user asked for #ID)
+    # Auto-Populate Tags with required IDs
     auto_tags = set(tags) if tags else set()
 
     # 1. Add Parent
@@ -165,15 +245,14 @@ def create_issue_file(
     for rel in related:
         auto_tags.add(f"#{rel}")
 
-    # 4. Add Self (as per instruction "auto add this issue... number")
-    # Note: issue_id is generated just above
+    # 4. Add Self
     auto_tags.add(f"#{issue_id}")
 
     final_tags = sorted(list(auto_tags))
 
     metadata = IssueMetadata(
         id=issue_id,
-        uid=generate_uid(),  # Generate global unique identifier
+        uid=generate_uid(),
         type=issue_type,
         status=status,
         stage=stage,
@@ -181,43 +260,23 @@ def create_issue_file(
         parent=parent,
         dependencies=dependencies,
         related=related,
+        domains=domains,
         sprint=sprint,
         tags=final_tags,
         opened_at=current_time() if status == IssueStatus.OPEN else None,
     )
 
-    # Enforce lifecycle policies (defaults, auto-corrections)
+    # Enforce lifecycle policies
     from .engine import get_engine
 
     get_engine().enforce_policy(metadata)
 
     # Serialize metadata
-    # Explicitly exclude actions and path from file persistence
-    yaml_header = yaml.dump(
-        metadata.model_dump(
-            exclude_none=True, mode="json", exclude={"actions", "path"}
-        ),
-        sort_keys=False,
-        allow_unicode=True,
-    )
-
-    # Inject Self-Documenting Hints (Interactive Frontmatter)
-    if "parent:" not in yaml_header:
-        yaml_header += "# parent: <EPIC-ID>   # Optional: Parent Issue ID\n"
-    if "solution:" not in yaml_header:
-        yaml_header += "# solution: null      # Required for Closed state (implemented, cancelled, etc.)\n"
-
-    if "dependencies:" not in yaml_header:
-        yaml_header += "# dependencies: []    # List of dependency IDs\n"
-    if "related:" not in yaml_header:
-        yaml_header += "# related: []         # List of related issue IDs\n"
-    if "files:" not in yaml_header:
-        yaml_header += "# files: []           # List of modified files\n"
+    yaml_header = _serialize_metadata(metadata)
 
     slug = _get_slug(title)
     filename = f"{issue_id}-{slug}.md"
 
-    # Enhanced Template with Instructional Comments
     file_content = f"""---
 {yaml_header}---
 
@@ -249,7 +308,6 @@ def create_issue_file(
     file_path = target_dir / filename
     file_path.write_text(file_content)
 
-    # Inject path into returned metadata
     metadata.path = str(file_path.absolute())
 
     return metadata, file_path
@@ -512,14 +570,7 @@ def update_issue(
         raise ValueError(f"Failed to validate updated metadata: {e}")
 
     # Serialize back
-    # Explicitly exclude actions and path from file persistence
-    new_yaml = yaml.dump(
-        updated_meta.model_dump(
-            exclude_none=True, mode="json", exclude={"actions", "path"}
-        ),
-        sort_keys=False,
-        allow_unicode=True,
-    )
+    new_yaml = _serialize_metadata(updated_meta)
 
     # Reconstruct File
     match_header = re.search(r"^---(.*?)---", content, re.DOTALL | re.MULTILINE)

monoco/features/issue/domain/models.py

@@ -113,6 +113,7 @@ class IssueFrontmatter(BaseModel):
     parent: Optional[str] = None
     dependencies: List[str] = Field(default_factory=list)
     related: List[str] = Field(default_factory=list)
+    domains: List[str] = Field(default_factory=list)
     tags: List[str] = Field(default_factory=list)
     solution: Optional[IssueSolution] = None
     isolation: Optional[IssueIsolation] = None

monoco/features/issue/domain_commands.py

@@ -0,0 +1,47 @@
+import typer
+from rich.table import Table
+from rich.console import Console
+from monoco.features.issue.domain_service import DomainService
+
+app = typer.Typer(help="Manage domain ontology.")
+console = Console()
+
+
+@app.command("list")
+def list_domains():
+    """List defined domains and aliases."""
+    service = DomainService()
+    config = service.config
+
+    table = Table(title=f"Domain Ontology (Strict: {config.strict})")
+    table.add_column("Canonical Name", style="bold cyan")
+    table.add_column("Description", style="white")
+    table.add_column("Aliases", style="yellow")
+
+    for item in config.items:
+        table.add_row(
+            item.name,
+            item.description or "",
+            ", ".join(item.aliases) if item.aliases else "-",
+        )
+
+    console.print(table)
+
+
+@app.command("check")
+def check_domain(domain: str = typer.Argument(..., help="Domain name to check")):
+    """Check if a domain is valid and resolve it."""
+    service = DomainService()
+
+    if service.is_canonical(domain):
+        console.print(f"[green]✔ '{domain}' is a canonical domain.[/green]")
+    elif service.is_alias(domain):
+        canonical = service.get_canonical(domain)
+        console.print(f"[yellow]➜ '{domain}' is an alias for '{canonical}'.[/yellow]")
+    else:
+        if service.config.strict:
+            console.print(f"[red]✘ '{domain}' is NOT a valid domain.[/red]")
+        else:
+            console.print(
+                f"[yellow]⚠ '{domain}' is undefined (Strict Mode: OFF).[/yellow]"
+            )

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