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

monoco/features/issue/engine/machine.py

@@ -1,6 +1,11 @@
 from typing import List, Optional, Dict
 from monoco.core.config import IssueSchemaConfig, TransitionConfig
 from ..models import IssueMetadata
+from ..criticality import (
+    CriticalityLevel,
+    PolicyResolver,
+    HumanReviewLevel,
+)
 
 
 class StateMachine:
@@ -128,12 +133,15 @@ class StateMachine:
         to_status: str,
         to_stage: Optional[str],
         solution: Optional[str] = None,
-    ) -> None:
+        meta: Optional[IssueMetadata] = None,
+    ) -> Optional[TransitionConfig]:
         """
         Validate if a transition is allowed. Raises ValueError if not.
+        If meta is provided, also validates criticality-based policies.
+        Returns the TransitionConfig if a transition occurred, None if no change.
         """
         if from_status == to_status and from_stage == to_stage:
-            return  # No change is always allowed (unless we want to enforce specific updates)
+            return None  # No change is always allowed (unless we want to enforce specific updates)
 
         transition = self.find_transition(
             from_status, from_stage, to_status, to_stage, solution
@@ -150,28 +158,74 @@ class StateMachine:
                 f"Lifecycle Policy: Transition '{transition.label}' requires solution '{transition.required_solution}'."
             )
 
-    def enforce_policy(self, meta: IssueMetadata) -> None:
+        # Criticality-based policy checks
+        if meta and meta.criticality:
+            self._validate_criticality_policy(meta, from_stage, to_stage)
+            
+        return transition
+
+    def _validate_criticality_policy(
+        self,
+        meta: IssueMetadata,
+        from_stage: Optional[str],
+        to_stage: Optional[str],
+    ) -> None:
         """
-        Apply consistency rules to IssueMetadata.
+        Validate transition against criticality-based policies.
+        Enforces stricter requirements for high/critical issues.
         """
-        from ..models import current_time
+        policy = PolicyResolver.resolve(meta.criticality)
+
+        # Submit to Review: Enforce agent review for medium+
+        if to_stage == "review" and from_stage == "doing":
+            if meta.criticality >= CriticalityLevel.MEDIUM:
+                # For medium+, agent review is mandatory
+                # This is enforced by the policy, but we can't check actual review status here
+                # The check is informational - actual enforcement happens in submit command
+                pass
+
+        # Close/Accept: Enforce human review for high/critical
+        if to_stage == "done":
+            if policy.human_review in [
+                HumanReviewLevel.REQUIRED,
+                HumanReviewLevel.REQUIRED_RECORD,
+            ]:
+                # For high/critical, human review is mandatory before closing
+                # Actual enforcement would check review comments section
+                pass
+
+    def check_policy_compliance(self, meta: IssueMetadata) -> List[str]:
+        """
+        Check if an issue complies with its criticality policy.
+        Returns list of policy violations.
+        """
+        if not meta.criticality:
+            return []
 
-        if meta.status == "backlog":
-            meta.stage = "freezed"
+        violations = []
+        policy = PolicyResolver.resolve(meta.criticality)
 
-        elif meta.status == "closed":
-            if meta.stage != "done":
-                meta.stage = "done"
-            if not meta.closed_at:
-                meta.closed_at = current_time()
+        # Stage-based checks
+        if meta.stage == "review":
+            # In review stage, check coverage requirement
+            # Note: Actual coverage check would require external data
+            pass
 
-        elif meta.status == "open":
-            if meta.stage is None:
-                meta.stage = "draft"
+        if meta.stage == "done" or meta.status == "closed":
+            # For high/critical, require review comments
+            if policy.human_review in [
+                HumanReviewLevel.REQUIRED,
+                HumanReviewLevel.REQUIRED_RECORD,
+            ]:
+                # This is a simplified check - full implementation would parse body
+                pass
+
+        return violations
 
     def enforce_policy(self, meta: IssueMetadata) -> None:
         """
         Apply consistency rules to IssueMetadata.
+        Includes criticality-based defaults.
         """
         from ..models import current_time
 
@@ -187,3 +241,9 @@ class StateMachine:
         elif meta.status == "open":
             if meta.stage is None:
                 meta.stage = "draft"
+
+        # Set default criticality if not set
+        if meta.criticality is None:
+            from ..criticality import CriticalityTypeMapping
+
+            meta.criticality = CriticalityTypeMapping.get_default(meta.type.value)

monoco/features/issue/git_service.py

@@ -0,0 +1,185 @@
+"""
+Git service for Issue operations.
+
+Provides atomic commit functionality for issue file changes,
+ensuring task state transitions are properly tracked in git history.
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional, List, Tuple
+from dataclasses import dataclass
+
+from monoco.core import git
+
+logger = logging.getLogger("monoco.features.issue.git_service")
+
+
+@dataclass
+class CommitResult:
+    """Result of a commit operation."""
+
+    success: bool
+    commit_hash: Optional[str] = None
+    message: Optional[str] = None
+    error: Optional[str] = None
+
+
+class IssueGitService:
+    """
+    Service for handling git operations related to Issue files.
+
+    Responsibilities:
+    - Detect if current directory is in a git repository
+    - Stage specific issue files
+    - Generate atomic commit messages for issue transitions
+    - Handle graceful degradation when not in a git repo
+    """
+
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+        self._is_git_repo: Optional[bool] = None
+
+    def is_git_repository(self) -> bool:
+        """Check if the project root is inside a git repository."""
+        if self._is_git_repo is None:
+            self._is_git_repo = git.is_git_repo(self.project_root)
+        return self._is_git_repo
+
+    def commit_issue_change(
+        self,
+        issue_id: str,
+        action: str,
+        issue_file_path: Path,
+        old_file_path: Optional[Path] = None,
+        no_commit: bool = False,
+    ) -> CommitResult:
+        """
+        Atomically commit an issue file change.
+
+        Args:
+            issue_id: The issue ID (e.g., "FEAT-0115")
+            action: The action being performed (e.g., "close", "start", "open")
+            issue_file_path: Current path to the issue file
+            old_file_path: Previous path if the file was moved (e.g., status change)
+            no_commit: If True, skip the commit operation
+
+        Returns:
+            CommitResult with success status and commit details
+        """
+        if no_commit:
+            return CommitResult(success=True, message="Skipped (no-commit flag)")
+
+        if not self.is_git_repository():
+            logger.info("Not in a git repository, skipping auto-commit")
+            return CommitResult(success=True, message="Skipped (not a git repo)")
+
+        try:
+            # Stage the changes
+            self._stage_issue_files(issue_file_path, old_file_path)
+
+            # Generate and execute commit
+            commit_message = self._generate_commit_message(issue_id, action)
+            commit_hash = git.git_commit(self.project_root, commit_message)
+
+            return CommitResult(
+                success=True,
+                commit_hash=commit_hash,
+                message=commit_message,
+            )
+
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"Failed to commit issue change: {error_msg}")
+            return CommitResult(success=False, error=error_msg)
+
+    def _stage_issue_files(
+        self, current_path: Path, old_path: Optional[Path] = None
+    ) -> None:
+        """
+        Stage issue file changes.
+
+        If old_path is provided (file was moved), handles the rename properly:
+        - Stages deletion of old file
+        - Stages addition of new file
+        """
+        files_to_stage: List[str] = []
+
+        # Handle the old file path if file was moved (e.g., open -> closed)
+        if old_path and old_path.exists():
+            # File was moved, need to stage the deletion
+            try:
+                rel_old_path = old_path.relative_to(self.project_root)
+                files_to_stage.append(str(rel_old_path))
+            except ValueError:
+                # old_path is not relative to project_root, use absolute
+                files_to_stage.append(str(old_path))
+
+        # Handle the current file path
+        if current_path.exists():
+            try:
+                rel_path = current_path.relative_to(self.project_root)
+                files_to_stage.append(str(rel_path))
+            except ValueError:
+                # current_path is not relative to project_root, use absolute
+                files_to_stage.append(str(current_path))
+
+        if files_to_stage:
+            git.git_add(self.project_root, files_to_stage)
+
+    def _generate_commit_message(self, issue_id: str, action: str) -> str:
+        """
+        Generate a standardized commit message for issue transitions.
+
+        Format: chore(issue): <action> <issue_id>
+
+        Examples:
+            chore(issue): close FIX-0020
+            chore(issue): start FEAT-0115
+            chore(issue): open FEAT-0115
+            chore(issue): submit FEAT-0115
+        """
+        return f"chore(issue): {action} {issue_id}"
+
+    def get_commit_history(
+        self, issue_id: str, max_count: int = 10
+    ) -> List[Tuple[str, str]]:
+        """
+        Get commit history for a specific issue.
+
+        Returns:
+            List of (commit_hash, subject) tuples
+        """
+        if not self.is_git_repository():
+            return []
+
+        try:
+            commits = git.search_commits_by_message(self.project_root, issue_id)
+            return [(c["hash"], c["subject"]) for c in commits[:max_count]]
+        except Exception:
+            return []
+
+
+def should_auto_commit(config) -> bool:
+    """
+    Check if auto-commit should be enabled based on configuration.
+
+    Checks for:
+    1. Explicit disable in config: issue.auto_commit = false
+    2. Environment variable: MONOCO_NO_AUTO_COMMIT=1
+    """
+    import os
+
+    # Check environment variable first
+    if os.environ.get("MONOCO_NO_AUTO_COMMIT", "0") == "1":
+        return False
+
+    # Check config (if issue config has auto_commit setting)
+    try:
+        if hasattr(config, "issue") and hasattr(config.issue, "auto_commit"):
+            return config.issue.auto_commit
+    except Exception:
+        pass
+
+    # Default to enabled
+    return True