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

monoco/features/issue/linter.py

@@ -24,46 +24,201 @@ def check_integrity(issues_root: Path, recursive: bool = False) -> List[Diagnost
     validator = IssueValidator(issues_root)
 
     all_issue_ids = set()
+    id_to_path = {}
     all_issues = []
 
     # 1. Collection Phase (Build Index)
     # Helper to collect issues from a project
     def collect_project_issues(project_issues_root: Path, project_name: str = "local"):
         project_issues = []
-        for subdir in ["Epics", "Features", "Chores", "Fixes"]:
+        project_diagnostics = []
+        for subdir in ["Epics", "Features", "Chores", "Fixes", "Domains"]:
             d = project_issues_root / subdir
             if d.exists():
-                files = []
-                for status in ["open", "closed", "backlog"]:
-                    status_dir = d / status
-                    if status_dir.exists():
-                        files.extend(status_dir.rglob("*.md"))
-
-                for f in files:
-                    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, project_name))
-                    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
+                if subdir == "Domains":
+                    # Special handling for Domains (not Issue tickets)
+                    for f in d.rglob("*.md"):
+                        # Domain validation happens here inline or via separate validator
+                        # For now, we just index them for reference validation
+                        domain_key = f.stem
+                        # Ensure H1 matches filename
+                        try:
+                            content = f.read_text(encoding="utf-8")
+
+                            # 1. H1 Check
+                            h1_match = re.search(r"^#\s+(.+)$", content, re.MULTILINE)
+                            if not h1_match:
+                                project_diagnostics.append(
+                                    Diagnostic(
+                                        range=Range(
+                                            start=Position(line=0, character=0),
+                                            end=Position(line=0, character=0),
+                                        ),
+                                        message=f"Domain '{f.name}' missing H1 title.",
+                                        severity=DiagnosticSeverity.Error,
+                                        source="DomainValidator",
+                                    )
+                                )
+                            else:
+                                h1_title = h1_match.group(1).strip()
+                                # Allow exact match or "Domain: Name" pattern? User said "Title should be same as filename"
+                                # But let's be strict: Filename stem MUST match H1
+                                # User spec: "标题应该和文件名相同" -> The H1 content (after #) must equal filename stem (spaces sensitive).
+                                # But wait, user example "Domain: Agent Onboarding" (bad) vs "Agent Onboarding" (good?).
+                                # Actually user said "Attribute key in yaml" should match.
+                                # Let's enforce: Filename 'Agent Onboarding.md' -> H1 '# Agent Onboarding'
+
+                                # Check for "Domain: " prefix which is forbidden
+                                if h1_title.lower().startswith("domain:"):
+                                    project_diagnostics.append(
+                                        Diagnostic(
+                                            range=Range(
+                                                start=Position(line=0, character=0),
+                                                end=Position(line=0, character=0),
+                                            ),
+                                            message=f"Domain H1 must not use 'Domain:' prefix. Found '{h1_title}'.",
+                                            severity=DiagnosticSeverity.Error,
+                                            source="DomainValidator",
+                                        )
+                                    )
+                                elif h1_title != f.stem:
+                                    project_diagnostics.append(
+                                        Diagnostic(
+                                            range=Range(
+                                                start=Position(line=0, character=0),
+                                                end=Position(line=0, character=0),
+                                            ),
+                                            message=f"Domain H1 '{h1_title}' does not match filename '{f.stem}'.",
+                                            severity=DiagnosticSeverity.Error,
+                                            source="DomainValidator",
+                                        )
+                                    )
+
+                            # 2. Source Language Check
+                            # We import the check from i18n core if not available in validator yet
+                            # But linter.py imports core... issue core.
+
+                            # Need source lang. Conf is available below, let's grab it or pass it.
+                            # We are inside a helper func, need to access outer scope or pass config.
+                            # We'll do it in validation phase? Or here?
+                            # 'conf' is defined in outer scope but not passed to this helper.
+                            # Let's resolve config inside loop or pass it.
+                            # To keep it simple, we do light check here.
+
+                            # Actually, we should collect Domains into a list to pass to Validator
+                            # so Validator can check if Issue 'domains' field references valid domains.
+                            # We'll use a special set for this.
+                            project_issues.append(
+                                (f, "DOMAIN", f.stem)
+                            )  # Marker for later
+
+                        except Exception as e:
+                            project_diagnostics.append(
+                                Diagnostic(
+                                    range=Range(
+                                        start=Position(line=0, character=0),
+                                        end=Position(line=0, character=0),
+                                    ),
+                                    message=f"Domain Read Error: {e}",
+                                    severity=DiagnosticSeverity.Error,
+                                    source="DomainValidator",
+                                )
+                            )
+
+                else:
+                    # Standard Issues (Epics/Features/etc)
+                    files = []
+                    for status in ["open", "closed", "backlog"]:
+                        status_dir = d / status
+                        if status_dir.exists():
+                            files.extend(status_dir.rglob("*.md"))
+
+                    for f in files:
+                        try:
+                            meta = core.parse_issue(f, raise_error=True)
+                            if meta:
+                                local_id = meta.id
+                                full_id = f"{project_name}::{local_id}"
+
+                                if local_id in id_to_path:
+                                    other_path = id_to_path[local_id]
+                                    # Report on current file
+                                    d_dup = Diagnostic(
+                                        range=Range(
+                                            start=Position(line=0, character=0),
+                                            end=Position(line=0, character=0),
+                                        ),
+                                        message=f"Duplicate ID Violation: ID '{local_id}' is already used by {other_path.name}",
+                                        severity=DiagnosticSeverity.Error,
+                                        source=local_id,
+                                    )
+                                    d_dup.data = {"path": f}
+                                    project_diagnostics.append(d_dup)
+                                else:
+                                    id_to_path[local_id] = f
+
+                                all_issue_ids.add(local_id)
+                                all_issue_ids.add(full_id)
+
+                                # Filename Consistency Check
+                                # Pattern: {ID}-{slug}.md
+                                expected_slug = meta.title.lower().replace(" ", "-")
+                                # Remove common symbols from slug for matching
+                                expected_slug = re.sub(
+                                    r"[^a-z0-9\-]", "", expected_slug
+                                )
+                                # Trim double dashes
+                                expected_slug = re.sub(r"-+", "-", expected_slug).strip(
+                                    "-"
+                                )
+
+                                filename_stem = f.stem
+                                # Check if it starts with ID-
+                                if not filename_stem.startswith(f"{meta.id}-"):
+                                    project_diagnostics.append(
+                                        Diagnostic(
+                                            range=Range(
+                                                start=Position(line=0, character=0),
+                                                end=Position(line=0, character=0),
+                                            ),
+                                            message=f"Filename Error: Filename '{f.name}' must start with ID '{meta.id}-'",
+                                            severity=DiagnosticSeverity.Error,
+                                            source=meta.id,
+                                            data={"path": f},
+                                        )
+                                    )
+                                else:
+                                    # Check slug matching (loose match, ensuring it's present)
+                                    actual_slug = filename_stem[len(meta.id) + 1 :]
+                                    if not actual_slug:
+                                        project_diagnostics.append(
+                                            Diagnostic(
+                                                range=Range(
+                                                    start=Position(line=0, character=0),
+                                                    end=Position(line=0, character=0),
+                                                ),
+                                                message=f"Filename Error: Filename '{f.name}' missing title slug. Expected: '{meta.id}-{expected_slug}.md'",
+                                                severity=DiagnosticSeverity.Error,
+                                                source=meta.id,
+                                                data={"path": f},
+                                            )
+                                        )
+
+                                project_issues.append((f, meta, project_name))
+                        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}
+                            project_diagnostics.append(d)
+        return project_issues, project_diagnostics
 
     conf = get_config(str(issues_root.parent))
 
@@ -92,7 +247,11 @@ def check_integrity(issues_root: Path, recursive: bool = False) -> List[Diagnost
             workspace_root_name = root_conf.project.name.lower()
 
     # Collect from local issues_root
-    all_issues.extend(collect_project_issues(issues_root, local_project_name))
+    proj_issues, proj_diagnostics = collect_project_issues(
+        issues_root, local_project_name
+    )
+    all_issues.extend(proj_issues)
+    diagnostics.extend(proj_diagnostics)
 
     if recursive:
         try:
@@ -103,34 +262,76 @@ def check_integrity(issues_root: Path, recursive: bool = False) -> List[Diagnost
             if workspace_root != issues_root.parent:
                 root_issues_dir = workspace_root / "Issues"
                 if root_issues_dir.exists():
-                    all_issues.extend(
-                        collect_project_issues(
-                            root_issues_dir, ws_conf.project.name.lower()
-                        )
+                    r_issues, r_diags = collect_project_issues(
+                        root_issues_dir, ws_conf.project.name.lower()
                     )
+                    all_issues.extend(r_issues)
+                    diagnostics.extend(r_diags)
 
             # Index all members
             for member_name, rel_path in ws_conf.project.members.items():
                 member_root = (workspace_root / rel_path).resolve()
                 member_issues_dir = member_root / "Issues"
                 if member_issues_dir.exists() and member_issues_dir != issues_root:
-                    all_issues.extend(
-                        collect_project_issues(member_issues_dir, member_name.lower())
+                    m_issues, m_diags = collect_project_issues(
+                        member_issues_dir, member_name.lower()
                     )
+                    all_issues.extend(m_issues)
+                    diagnostics.extend(m_diags)
         except Exception:
             pass
 
     # 2. Validation Phase
+    valid_domains = set()
+    # Now validate
+    for path, meta, project_name in all_issues:
+        if meta == "DOMAIN":
+            valid_domains.add(
+                project_name
+            )  # Record the domain name (which was stored in project_name slot)
+
     for path, meta, project_name in all_issues:
+        if meta == "DOMAIN":
+            # Track B: Domain Validation
+            # Already did semantic checks in collection phase (H1 etc)
+            # Now do Source Language Check
+            try:
+                from monoco.features.i18n import core as i18n_core
+
+                # We need source_lang from config.
+                # We have 'conf' object from earlier.
+                source_lang = "en"
+                if conf and conf.i18n and conf.i18n.source_lang:
+                    source_lang = conf.i18n.source_lang
+
+                if not i18n_core.is_content_source_language(path, source_lang):
+                    diagnostics.append(
+                        Diagnostic(
+                            range=Range(
+                                start=Position(line=0, character=0),
+                                end=Position(line=0, character=0),
+                            ),
+                            message=f"Language Mismatch: Domain definition appears not to be in source language '{source_lang}'.",
+                            severity=DiagnosticSeverity.Warning,
+                            source="DomainValidator",
+                        )
+                    )
+            except Exception:
+                pass
+            continue
+
+        # Track A: Issue Validation
         content = path.read_text()  # Re-read content for validation
 
         # A. Run Core Validator
+        # Pass valid_domains kwarg (Validator needs update to accept it)
         file_diagnostics = validator.validate(
             meta,
             content,
             all_issue_ids,
             current_project=project_name,
             workspace_root=workspace_root_name,
+            valid_domains=valid_domains,
         )
 
         # Add context to diagnostics (Path)
@@ -183,6 +384,13 @@ def run_lint(
                             except Exception:
                                 pass
 
+        # Collect valid domains
+        valid_domains = set()
+        domains_dir = issues_root / "Domains"
+        if domains_dir.exists():
+            for f in domains_dir.rglob("*.md"):
+                valid_domains.add(f.stem)
+
         validator = IssueValidator(issues_root)
 
         for file_path in file_paths:
@@ -209,7 +417,11 @@ def run_lint(
                     current_project_name = conf.project.name.lower()
 
                 file_diagnostics = validator.validate(
-                    meta, content, all_issue_ids, current_project=current_project_name
+                    meta,
+                    content,
+                    all_issue_ids,
+                    current_project=current_project_name,
+                    valid_domains=valid_domains,
                 )
 
                 # Add context
@@ -465,12 +677,15 @@ def run_lint(
             except Exception as e:
                 console.print(f"[red]Failed to fix domains for {path.name}: {e}[/red]")
 
-            # Domain Alias Fix
+            # Domain Alias and Format Fix
             try:
-                alias_fixes = [
-                    d for d in current_file_diags if "Domain Alias:" in d.message
+                format_fixes = [
+                    d
+                    for d in current_file_diags
+                    if "Domain Format Error:" in d.message
+                    or "Domain Alias:" in d.message
                 ]
-                if alias_fixes:
+                if format_fixes:
                     fm_match = re.search(
                         r"^---(.*?)---", new_content, re.DOTALL | re.MULTILINE
                     )
@@ -483,24 +698,41 @@ def run_lint(
                         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,
-                                )
+                            for d in format_fixes:
+                                if "Domain Format Error:" in d.message:
+                                    # Message: Domain Format Error: 'alias' must be PascalCase (e.g., 'canonical').
+                                    m = re.search(
+                                        r"Domain Format Error: '([^']+)' must be PascalCase \(e.g\., '([^']+)'\)",
+                                        d.message,
+                                    )
+                                else:
+                                    # 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:
+                                        # Replace exact match
                                         domains = [
                                             new_d if x == old_d else x for x in domains
                                         ]
                                         domain_changed = True
 
                             if domain_changed:
-                                data["domains"] = domains
+                                # Deduplicate while preserving order if needed, but set is easier
+                                seen = set()
+                                unique_domains = []
+                                for dom in domains:
+                                    if dom not in seen:
+                                        unique_domains.append(dom)
+                                        seen.add(dom)
+
+                                data["domains"] = unique_domains
                                 new_fm_text = yaml.dump(
                                     data, sort_keys=False, allow_unicode=True
                                 )
@@ -508,25 +740,17 @@ def run_lint(
                                     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]"
+                                    f"[dim]Fixed (Domain Normalization): {path.name}[/dim]"
                                 )
 
             except Exception as e:
                 console.print(
-                    f"[red]Failed to fix domain aliases for {path.name}: {e}[/red]"
+                    f"[red]Failed to fix domain normalization for {path.name}: {e}[/red]"
                 )
 
         console.print(f"[green]Applied auto-fixes to {fixed_count} files.[/green]")
@@ -548,7 +772,12 @@ def run_lint(
                 try:
                     meta = core.parse_issue(file)
                     content = file.read_text()
-                    file_diagnostics = validator.validate(meta, content, all_issue_ids)
+                    file_diagnostics = validator.validate(
+                        meta,
+                        content,
+                        all_issue_ids,
+                        valid_domains=valid_domains,
+                    )
                     for d in file_diagnostics:
                         d.source = meta.id
                         d.data = {"path": file}

monoco/features/issue/models.py

@@ -1,9 +1,19 @@
 from enum import Enum
 from typing import List, Optional, Any, Dict
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, Field, model_validator, ConfigDict, field_validator
 from datetime import datetime
 import hashlib
 import secrets
+import re
+
+from .criticality import CriticalityLevel, Policy, PolicyResolver
+
+
+# Forward reference for type hints
+class CommitResult:
+    """Result of a commit operation (defined in git_service)."""
+
+    pass
 
 
 class IssueID:
@@ -105,13 +115,24 @@ class IssueAction(BaseModel):
 
 
 class IssueMetadata(BaseModel):
-    model_config = {"extra": "allow"}
+    model_config = ConfigDict(extra="allow", validate_assignment=True)
+
+    id: str = Field()
+
+    @field_validator("id")
+    @classmethod
+    def validate_id_format(cls, v: str) -> str:
+        if not re.match(r"^[A-Z]+-\d{4}$", v):
+            raise ValueError(
+                f"Invalid Issue ID format: '{v}'. Expected 'TYPE-XXXX' (e.g., FEAT-1234). "
+                "For sub-features or sub-tasks, please use the 'parent' field instead of adding suffixes to the ID."
+            )
+        return v
 
-    id: str
     uid: Optional[str] = None  # Global unique identifier for cross-project identity
-    type: str
-    status: str = "open"
-    stage: Optional[str] = None
+    type: IssueType
+    status: IssueStatus = IssueStatus.OPEN
+    stage: Optional[IssueStage] = None
     title: str
 
     # Time Anchors
@@ -122,7 +143,7 @@ class IssueMetadata(BaseModel):
 
     parent: Optional[str] = None
     sprint: Optional[str] = None
-    solution: Optional[str] = None
+    solution: Optional[IssueSolution] = None
     isolation: Optional[IssueIsolation] = None
     dependencies: List[str] = []
     related: List[str] = []
@@ -131,10 +152,28 @@ class IssueMetadata(BaseModel):
     files: List[str] = []
     path: Optional[str] = None  # Absolute path to the issue file
 
+    # Criticality System (FEAT-0114)
+    criticality: Optional[CriticalityLevel] = Field(
+        default=None,
+        description="Issue criticality level (low, medium, high, critical)",
+    )
+
     # Proxy UI Actions (Excluded from file persistence)
     # Modified: Remove exclude=True to allow API/CLI inspection. Must be manually excluded during YAML Dump.
     actions: List[IssueAction] = Field(default=[])
 
+    # Runtime-only field for commit result (FEAT-0115)
+    # Not persisted to YAML, only available in memory after update_issue
+    commit_result: Optional[Any] = Field(default=None, exclude=True)
+
+    @property
+    def resolved_policy(self) -> Policy:
+        """Get the resolved policy based on criticality level."""
+        if self.criticality:
+            return PolicyResolver.resolve(self.criticality)
+        # Default to medium policy if not set
+        return PolicyResolver.resolve(CriticalityLevel.MEDIUM)
+
     @model_validator(mode="before")
     @classmethod
     def normalize_fields(cls, v: Any) -> Any:
@@ -161,26 +200,64 @@ class IssueMetadata(BaseModel):
             # Normalize type and status to lowercase for compatibility
             if "type" in v and isinstance(v["type"], str):
                 v["type"] = v["type"].lower()
+                try:
+                    v["type"] = IssueType(v["type"])
+                except ValueError:
+                    pass
+
             if "status" in v and isinstance(v["status"], str):
                 v["status"] = v["status"].lower()
+                try:
+                    v["status"] = IssueStatus(v["status"])
+                except ValueError:
+                    pass
+
             if "solution" in v and isinstance(v["solution"], str):
                 v["solution"] = v["solution"].lower()
+                try:
+                    v["solution"] = IssueSolution(v["solution"])
+                except ValueError:
+                    pass
+
             # Stage normalization
             if "stage" in v and isinstance(v["stage"], str):
                 v["stage"] = v["stage"].lower()
                 if v["stage"] == "todo":
                     v["stage"] = "draft"
+                try:
+                    v["stage"] = IssueStage(v["stage"])
+                except ValueError:
+                    pass
+
+            # Criticality normalization
+            if "criticality" in v and isinstance(v["criticality"], str):
+                v["criticality"] = v["criticality"].lower()
+                try:
+                    v["criticality"] = CriticalityLevel(v["criticality"])
+                except ValueError:
+                    pass
         return v
 
     @model_validator(mode="after")
     def validate_lifecycle(self) -> "IssueMetadata":
-        # Logic Definition:
-        # status: backlog -> stage: freezed
-        # status: closed -> stage: done
-        # status: open -> stage: draft | doing | review | done (default draft)
-
-        # NOTE: We do NOT auto-correct state here anymore to allow Linter to detect inconsistencies.
-        # Auto-correction should be applied explicitly by 'create' or 'update' commands via core logic.
+        # 1. Solution Consistency: Closed issues MUST have a solution
+        if self.status == IssueStatus.CLOSED and not self.solution:
+            raise ValueError(f"Issue '{self.id}' is closed but 'solution' is missing.")
+
+        # 2. Hierarchy Consistency: non-epic types MUST have a parent (except specific root seeds)
+        if self.type != IssueType.EPIC and not self.parent:
+            # We allow exceptions for very specific bootstrap cases if needed, but currently enforce it.
+            if self.id not in ["FEAT-BOOTSTRAP"]:  # Example exception
+                raise ValueError(
+                    f"Issue '{self.id}' of type '{self.type}' must have a 'parent' reference."
+                )
+
+        # 3. State/Stage Consistency (Warnings or Errors)
+        # Note: In Monoco, status: closed is tightly coupled with stage: done
+        if self.status == IssueStatus.CLOSED and self.stage != IssueStage.DONE:
+            # We could auto-fix here, but let's be strict for Validation purposes
+            # raise ValueError(f"Issue '{self.id}' is closed but stage is '{self.stage}' (expected 'done').")
+            pass
 
         return self