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

monoco/features/issue/core.py

@@ -15,12 +15,18 @@ from .models import (
     current_time,
     generate_uid,
 )
+from .criticality import (
+    CriticalityLevel,
+    CriticalityTypeMapping,
+    CriticalityInheritanceService,
+)
 from monoco.core import git
 from monoco.core.config import get_config, MonocoConfig
 from monoco.core.lsp import DiagnosticSeverity
 from .validator import IssueValidator
 
 from .engine import get_engine
+from .git_service import IssueGitService
 
 
 def get_prefix_map(issues_root: Path) -> Dict[str, str]:
@@ -137,6 +143,10 @@ def _serialize_metadata(metadata: IssueMetadata) -> str:
         elif k == "parent":
             ordered_data[k] = None
 
+    # Add criticality if present
+    if "criticality" in data:
+        ordered_data["criticality"] = data["criticality"]
+
     # Add remaining
     for k, v in data.items():
         if k not in ordered_data:
@@ -211,6 +221,7 @@ def create_issue_file(
     subdir: Optional[str] = None,
     sprint: Optional[str] = None,
     tags: List[str] = [],
+    criticality: Optional[CriticalityLevel] = None,
 ) -> Tuple[IssueMetadata, Path]:
     # Validation
     for dep_id in dependencies:
@@ -225,6 +236,38 @@ def create_issue_file(
     if issue_type != IssueType.EPIC and not parent:
         parent = "EPIC-0000"
 
+    # Determine criticality
+    # 1. Use provided criticality if specified
+    # 2. Check parent for inheritance
+    # 3. Apply type-based default
+    effective_criticality = criticality
+
+    # Get issue type string for mapping lookup
+    issue_type_str = (
+        issue_type.value if isinstance(issue_type, IssueType) else str(issue_type)
+    )
+
+    if effective_criticality is None:
+        # Check parent inheritance
+        if parent:
+            parent_path = find_issue_path(issues_root, parent)
+            if parent_path:
+                parent_meta = parse_issue(parent_path)
+                if parent_meta and parent_meta.criticality:
+                    # Child must inherit at least parent's criticality
+                    default_type_criticality = CriticalityTypeMapping.get_default(
+                        issue_type_str
+                    )
+                    effective_criticality = (
+                        CriticalityInheritanceService.resolve_child_criticality(
+                            parent_meta.criticality, default_type_criticality
+                        )
+                    )
+
+        # Fall back to type-based default
+        if effective_criticality is None:
+            effective_criticality = CriticalityTypeMapping.get_default(issue_type_str)
+
     issue_id = find_next_id(issue_type, issues_root)
     base_type_dir = get_issue_dir(issue_type, issues_root)
     target_dir = base_type_dir / status
@@ -268,6 +311,7 @@ def create_issue_file(
         sprint=sprint,
         tags=final_tags,
         opened_at=current_time() if status == IssueStatus.OPEN else None,
+        criticality=effective_criticality,
     )
 
     # Enforce lifecycle policies
@@ -403,6 +447,9 @@ def update_issue(
     related: Optional[List[str]] = None,
     tags: Optional[List[str]] = None,
     files: Optional[List[str]] = None,
+    criticality: Optional[CriticalityLevel] = None,
+    no_commit: bool = False,
+    project_root: Optional[Path] = None,
 ) -> IssueMetadata:
     path = find_issue_path(issues_root, issue_id)
     if not path:
@@ -464,13 +511,17 @@ def update_issue(
         except ValueError:
             pass
 
+    # Reconstruct temporary metadata for policy validation
+    temp_meta = IssueMetadata(**data)
+
     # Use engine to validate the transition
-    engine.validate_transition(
+    transition = engine.validate_transition(
         from_status=current_status,
         from_stage=current_stage,
         to_status=target_status,
         to_stage=target_stage,
         solution=effective_solution,
+        meta=temp_meta,
     )
 
     if target_status == "closed":
@@ -536,6 +587,23 @@ def update_issue(
     if files is not None:
         data["files"] = files
 
+    # Criticality update (only through escalation workflow)
+    if criticality is not None:
+        current_criticality = data.get("criticality")
+        if current_criticality:
+            current_level = CriticalityLevel(current_criticality)
+            # Only allow escalation (increase), never lowering
+            if criticality > current_level:
+                data["criticality"] = criticality.value
+            elif criticality < current_level:
+                raise ValueError(
+                    f"Cannot lower criticality from {current_level.value} to {criticality.value}. "
+                    "Criticality is immutable and can only be increased through escalation workflow."
+                )
+        else:
+            # Set if not previously set
+            data["criticality"] = criticality.value
+
     # Lifecycle Hooks
     # 1. Opened At: If transitioning to OPEN
     if target_status == IssueStatus.OPEN and current_status != IssueStatus.OPEN:
@@ -591,6 +659,8 @@ def update_issue(
     path.write_text(new_content)
 
     # 3. Handle physical move if status changed
+    # Save old path before move for git tracking
+    old_path_before_move = path
     if status and status != current_status:
         # Move file
         prefix = issue_id.split("-")[0].upper()
@@ -618,12 +688,81 @@ def update_issue(
     if updated_meta.parent:
         recalculate_parent(issues_root, updated_meta.parent)
 
+    # Auto-commit issue file changes (FEAT-0115)
+    if not no_commit:
+        # Determine the action type for commit message
+        action = "update"
+        if status and status != current_status:
+            action = status  # "open", "closed", "backlog"
+        elif stage and stage != current_stage:
+            action = stage  # "draft", "doing", "review", "done"
+
+        # Resolve project root if not provided
+        if project_root is None:
+            project_root = issues_root.parent
+
+        # Only auto-commit if we're in a git repo
+        git_service = IssueGitService(project_root)
+        if git_service.is_git_repository():
+            # Use the saved old path before file move for git tracking
+            old_path_for_git = None
+            if status and status != current_status and old_path_before_move != path:
+                old_path_for_git = old_path_before_move
+
+            commit_result = git_service.commit_issue_change(
+                issue_id=issue_id,
+                action=action,
+                issue_file_path=path,
+                old_file_path=old_path_for_git,
+                no_commit=no_commit,
+            )
+            # Attach commit result to metadata for optional inspection
+            updated_meta.commit_result = commit_result
+
     # Update returned metadata with final absolute path
     updated_meta.path = str(path.absolute())
     updated_meta.actions = get_available_actions(updated_meta)
+
+    # Execute Post Actions (Trigger)
+    if transition and hasattr(transition, "post_actions") and transition.post_actions:
+        _execute_post_actions(transition.post_actions, updated_meta)
+
     return updated_meta
 
 
+def _execute_post_actions(actions: List[str], meta: IssueMetadata):
+    """
+    Execute a list of shell commands as post-actions.
+    Supports template substitution with issue metadata.
+    """
+    import shlex
+    import subprocess
+    from rich.console import Console
+    
+    console = Console()
+    data = meta.model_dump(mode="json")
+    
+    for action in actions:
+        try:
+            # Safe template substitution
+            cmd = action.format(**data)
+        except KeyError as e:
+            console.print(f"[yellow]Trigger Warning:[/yellow] Missing key for template '{action}': {e}")
+            continue
+            
+        console.print(f"[bold cyan]Triggering:[/bold cyan] {cmd}")
+        
+        args = shlex.split(cmd)
+        
+        try:
+            # Run in foreground to allow interaction if needed (e.g. agent output)
+            subprocess.run(args, check=True)
+        except subprocess.CalledProcessError as e:
+            console.print(f"[red]Trigger Failed:[/red] Command '{cmd}' exited with code {e.returncode}")
+        except Exception as e:
+            console.print(f"[red]Trigger Error:[/red] {e}")
+
+
 def start_issue_isolation(
     issues_root: Path, issue_id: str, mode: str, project_root: Path
 ) -> IssueMetadata: