jleechanorg-pr-automation 0.1.1__py3-none-any.whl → 0.2.45__py3-none-any.whl

jleechanorg_pr_automation/automation_safety_manager.py

@@ -3,7 +3,7 @@
 Automation Safety Manager - GREEN Phase Implementation
 
 Minimal implementation to pass the RED phase tests with:
-- PR attempt limits (max 5 per PR)
+- PR attempt limits (max 10 per PR)
 - Global run limits (max 50 per day with automatic midnight reset)
 - Manual approval system
 - Thread-safe operations
@@ -11,21 +11,17 @@ Minimal implementation to pass the RED phase tests with:
 """
 
 import argparse
-import fcntl
 import importlib.util
 import json
-import logging
 import os
 import smtplib
 import sys
-import tempfile
 import threading
 from datetime import datetime, timedelta
-from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
 from typing import Dict, Optional, Union
 
-
 REAL_DATETIME = datetime
 
 # Number of characters in the ISO 8601 date prefix ("YYYY-MM-DD").
@@ -42,28 +38,33 @@ else:
 
 # Import shared utilities
 from .utils import (
+    get_automation_limits_with_overrides,
+    coerce_positive_int,
     json_manager,
     setup_logging,
-    get_email_config,
-    validate_email_config,
-    get_automation_limits,
-    format_timestamp,
-    parse_timestamp,
 )
 
 
 class AutomationSafetyManager:
     """Thread-safe automation safety manager with configurable limits"""
 
-    def __init__(self, data_dir: str):
+    def __init__(self, data_dir: str, limits: Optional[Dict[str, int]] = None):
         self.data_dir = data_dir
         self.lock = threading.RLock()  # Use RLock to prevent deadlock
         self.logger = setup_logging(__name__)
 
-        # Get limits from shared utility
-        limits = get_automation_limits()
-        self.pr_limit = limits['pr_limit']
-        self.global_limit = limits['global_limit']
+        # Start from defaults (hardcoded), then apply config file, then explicit overrides.
+        merged_limits = get_automation_limits_with_overrides()
+        self.pr_limit = merged_limits["pr_limit"]
+        self.global_limit = merged_limits["global_limit"]
+        self.approval_hours = merged_limits["approval_hours"]
+        self.subprocess_timeout = merged_limits["subprocess_timeout"]
+
+        # Workflow-specific *comment* limits
+        self.pr_automation_limit = merged_limits["pr_automation_limit"]
+        self.fix_comment_limit = merged_limits["fix_comment_limit"]
+        self.codex_update_limit = merged_limits["codex_update_limit"]
+        self.fixpr_limit = merged_limits["fixpr_limit"]
 
         # File paths
         self.pr_attempts_file = os.path.join(data_dir, "pr_attempts.json")
@@ -71,11 +72,13 @@ class AutomationSafetyManager:
         self.approval_file = os.path.join(data_dir, "manual_approval.json")
         self.config_file = os.path.join(data_dir, "automation_safety_config.json")
         self.inflight_file = os.path.join(data_dir, "pr_inflight.json")  # NEW: Persist inflight cache
+        self.pr_overrides_file = os.path.join(data_dir, "pr_limit_overrides.json")  # Per-PR limit overrides
 
         # In-memory counters for thread safety
         self._pr_attempts_cache = {}
         self._global_runs_cache = 0
         self._pr_inflight_cache: Dict[str, int] = {}
+        self._pr_overrides_cache: Dict[str, int] = {}  # Per-PR limit overrides (0 = unlimited)
 
         # Initialize files if they don't exist
         self._ensure_files_exist()
@@ -83,6 +86,10 @@ class AutomationSafetyManager:
         # Load configuration from file if it exists
         self._load_config_if_exists()
 
+        # Explicit overrides always win (and are clamped to positive ints).
+        if limits:
+            self._apply_limit_overrides(limits)
+
         # Load initial state from files
         self._load_state_from_files()
 
@@ -113,18 +120,17 @@ class AutomationSafetyManager:
         if not os.path.exists(self.inflight_file):
             self._write_json_file(self.inflight_file, {})
 
+        if not os.path.exists(self.pr_overrides_file):
+            self._write_json_file(self.pr_overrides_file, {})
+
     def _load_config_if_exists(self):
         """Load configuration from file if it exists, create default if not"""
         if os.path.exists(self.config_file):
             # Load existing config
             try:
-                with open(self.config_file, 'r') as f:
+                with open(self.config_file) as f:
                     config = json.load(f)
-                    # Update limits from config
-                    if 'pr_limit' in config:
-                        self.pr_limit = config['pr_limit']
-                    if 'global_limit' in config:
-                        self.global_limit = config['global_limit']
+                    self._apply_limit_overrides(config)
             except (FileNotFoundError, json.JSONDecodeError):
                 pass  # Use defaults
         else:
@@ -132,9 +138,35 @@ class AutomationSafetyManager:
             default_config = {
                 "global_limit": self.global_limit,
                 "pr_limit": self.pr_limit,
+                "approval_hours": self.approval_hours,
+                "subprocess_timeout": self.subprocess_timeout,
+                "pr_automation_limit": self.pr_automation_limit,
+                "fix_comment_limit": self.fix_comment_limit,
+                "codex_update_limit": self.codex_update_limit,
+                "fixpr_limit": self.fixpr_limit,
             }
             self._write_json_file(self.config_file, default_config)
 
+    def _apply_limit_overrides(self, overrides: Dict[str, object]) -> None:
+        """Apply override dict, clamping to positive ints and leaving others unchanged."""
+        defaults = get_automation_limits_with_overrides()
+        if "pr_limit" in overrides:
+            self.pr_limit = coerce_positive_int(overrides.get("pr_limit"), default=defaults["pr_limit"])
+        if "global_limit" in overrides:
+            self.global_limit = coerce_positive_int(overrides.get("global_limit"), default=defaults["global_limit"])
+        if "approval_hours" in overrides:
+            self.approval_hours = coerce_positive_int(overrides.get("approval_hours"), default=defaults["approval_hours"])
+        if "subprocess_timeout" in overrides:
+            self.subprocess_timeout = coerce_positive_int(overrides.get("subprocess_timeout"), default=defaults["subprocess_timeout"])
+        if "pr_automation_limit" in overrides:
+            self.pr_automation_limit = coerce_positive_int(overrides.get("pr_automation_limit"), default=defaults["pr_automation_limit"])
+        if "fix_comment_limit" in overrides:
+            self.fix_comment_limit = coerce_positive_int(overrides.get("fix_comment_limit"), default=defaults["fix_comment_limit"])
+        if "codex_update_limit" in overrides:
+            self.codex_update_limit = coerce_positive_int(overrides.get("codex_update_limit"), default=defaults["codex_update_limit"])
+        if "fixpr_limit" in overrides:
+            self.fixpr_limit = coerce_positive_int(overrides.get("fixpr_limit"), default=defaults["fixpr_limit"])
+
     def _load_state_from_files(self):
         """Load state from files into memory cache"""
         with self.lock:
@@ -149,6 +181,10 @@ class AutomationSafetyManager:
             inflight_data = self._read_json_file(self.inflight_file)
             self._pr_inflight_cache = {k: int(v) for k, v in inflight_data.items()}
 
+            # Load PR limit overrides
+            overrides_data = self._read_json_file(self.pr_overrides_file)
+            self._pr_overrides_cache = {k: int(v) for k, v in overrides_data.items()}
+
     def _sync_state_to_files(self):
         """Sync in-memory state to files"""
         with self.lock:
@@ -167,7 +203,7 @@ class AutomationSafetyManager:
         """Create a labeled key for PR attempt tracking."""
 
         repo_part = f"r={repo or ''}"
-        pr_part = f"p={str(pr_number)}"
+        pr_part = f"p={pr_number!s}"
         branch_part = f"b={branch or ''}"
         return "||".join((repo_part, pr_part, branch_part))
 
@@ -286,8 +322,7 @@ class AutomationSafetyManager:
         except (TypeError, ValueError):
             total_runs = 0
 
-        if total_runs < 0:
-            total_runs = 0
+        total_runs = max(total_runs, 0)
 
         data["total_runs"] = total_runs
 
@@ -317,7 +352,14 @@ class AutomationSafetyManager:
         return data, total_runs, is_stale
 
     def can_process_pr(self, pr_number: Union[int, str], repo: str = None, branch: str = None) -> bool:
-        """Check if PR can be processed (under attempt limit)"""
+        """Check if PR can be processed (under attempt limit).
+
+        NEW BEHAVIOR: Counts ALL attempts (success + failure) against the limit.
+        Supports per-PR limit overrides (0 = unlimited).
+
+        Blocks if:
+        1. Total attempts >= effective_pr_limit (respects overrides)
+        """
         with self.lock:
             raw_data = self._read_json_file(self.pr_attempts_file)
             self._pr_attempts_cache = self._normalize_pr_attempt_keys(raw_data)
@@ -325,20 +367,14 @@ class AutomationSafetyManager:
             pr_key = self._make_pr_key(pr_number, repo, branch)
             attempts = list(self._pr_attempts_cache.get(pr_key, []))
 
-            # Check total attempts limit first
-            if len(attempts) >= self.pr_limit:
-                return False
+            # Get effective limit (checks for per-PR override)
+            effective_limit = self._get_effective_pr_limit(pr_number, repo, branch)
 
-            # Count consecutive failures from latest attempts
-            consecutive_failures = 0
-            for attempt in reversed(attempts):
-                if attempt.get("result") == "failure":
-                    consecutive_failures += 1
-                else:
-                    break
+            # Count ALL attempts (not just failures)
+            total_attempts = len(attempts)
 
-            # Also block if too many consecutive failures (earlier than total limit)
-            return consecutive_failures < self.pr_limit
+            # Check against effective limit
+            return total_attempts < effective_limit
 
     def try_process_pr(self, pr_number: Union[int, str], repo: str = None, branch: str = None) -> bool:
         """Atomically reserve a processing slot for PR."""
@@ -373,18 +409,15 @@ class AutomationSafetyManager:
                 self._write_json_file(self.inflight_file, self._pr_inflight_cache)
 
     def get_pr_attempts(self, pr_number: Union[int, str], repo: str = None, branch: str = None):
-        """Get count of consecutive failures for a specific PR."""
+        """Get count of ALL attempts (success + failure) for a specific PR.
+
+        NEW BEHAVIOR: Counts ALL attempts, not just consecutive failures.
+        """
         with self.lock:
             pr_key = self._make_pr_key(pr_number, repo, branch)
             attempts = list(self._pr_attempts_cache.get(pr_key, []))
-
-            failure_count = 0
-            for attempt in reversed(attempts):
-                if attempt.get("result") == "failure":
-                    failure_count += 1
-                else:
-                    break
-            return failure_count
+            # Return total count of ALL attempts
+            return len(attempts)
 
     def get_pr_attempt_list(self, pr_number: Union[int, str], repo: str = None, branch: str = None):
         """Get list of attempts for a specific PR (for detailed analysis)"""
@@ -517,8 +550,7 @@ class AutomationSafetyManager:
                 approval_date = REAL_DATETIME.fromisoformat(approval_date_str)
             except (TypeError, ValueError):
                 return False
-            approval_hours = get_automation_limits()['approval_hours']
-            expiry = approval_date + timedelta(hours=approval_hours)
+            expiry = approval_date + timedelta(hours=self.approval_hours)
 
             return datetime.now() < expiry
 
@@ -527,19 +559,26 @@ class AutomationSafetyManager:
         notifications_sent = []
 
         with self.lock:
-            # Check for PR limits reached
+            # Check for PR limits reached (count ALL attempts)
             for pr_key, attempts in self._pr_attempts_cache.items():
-                if len(attempts) >= self.pr_limit:
+                total_attempts = len(attempts)  # Count ALL attempts (success + failure)
+                effective_pr_limit = self.pr_limit
+                override = self._pr_overrides_cache.get(pr_key)
+                if override is not None:
+                    # 0 means unlimited
+                    effective_pr_limit = sys.maxsize if override == 0 else override
+
+                if total_attempts >= effective_pr_limit:
                     self._send_limit_notification(
-                        f"PR Automation Limit Reached",
-                        f"PR {pr_key} has reached the maximum attempt limit of {self.pr_limit}."
+                        "PR Automation Attempt Limit Reached",
+                        f"PR {pr_key} has reached the maximum limit of {effective_pr_limit} total attempts."
                     )
                     notifications_sent.append(f"PR {pr_key}")
 
             # Check for global limit reached
             if self._global_runs_cache >= self.global_limit:
                 self._send_limit_notification(
-                    f"Global Automation Limit Reached",
+                    "Global Automation Limit Reached",
                     f"Global automation runs have reached the maximum limit of {self.global_limit}."
                 )
                 notifications_sent.append("Global limit")
@@ -585,9 +624,9 @@ class AutomationSafetyManager:
                 password = None
 
         if username is None:
-            username = os.environ.get('SMTP_USERNAME') or os.environ.get('EMAIL_USER')
+            username = os.environ.get("SMTP_USERNAME") or os.environ.get("EMAIL_USER")
         if password is None:
-            password = os.environ.get('SMTP_PASSWORD') or os.environ.get('EMAIL_PASS')
+            password = os.environ.get("SMTP_PASSWORD") or os.environ.get("EMAIL_PASS")
 
         return username, password
 
@@ -595,20 +634,20 @@ class AutomationSafetyManager:
         """Send email notification with secure credential handling"""
         try:
             # Load email configuration
-            smtp_server = os.environ.get('SMTP_SERVER', 'smtp.gmail.com')
-            smtp_port = int(os.environ.get('SMTP_PORT', '587'))
+            smtp_server = os.environ.get("SMTP_SERVER", "smtp.gmail.com")
+            smtp_port = int(os.environ.get("SMTP_PORT", "587"))
             username, password = self._get_smtp_credentials()
-            to_email = os.environ.get('EMAIL_TO')
-            from_email = os.environ.get('EMAIL_FROM') or username
+            to_email = os.environ.get("EMAIL_TO")
+            from_email = os.environ.get("EMAIL_FROM") or username
 
             if not (username and password and to_email and from_email):
                 self.logger.info("Email configuration incomplete - skipping notification")
                 return False
 
             msg = MIMEMultipart()
-            msg['From'] = from_email
-            msg['To'] = to_email
-            msg['Subject'] = f"[WorldArchitect Automation] {subject}"
+            msg["From"] = from_email
+            msg["To"] = to_email
+            msg["Subject"] = f"[WorldArchitect Automation] {subject}"
 
             body = f"""
 {message}
@@ -619,10 +658,10 @@ System: PR Automation Safety Manager
 This is an automated notification from the WorldArchitect.AI automation system.
 """
 
-            msg.attach(MIMEText(body, 'plain'))
+            msg.attach(MIMEText(body, "plain"))
 
-            # Connect and send email
-            server = smtplib.SMTP(smtp_server, smtp_port)
+            # Connect and send email with 30s timeout (consistent with automation_utils.py)
+            server = smtplib.SMTP(smtp_server, smtp_port, timeout=30)
             try:
                 server.ehlo()
                 server.starttls()
@@ -673,13 +712,13 @@ This is an automated notification from the WorldArchitect.AI automation system.
     def load_config(self, config_file: str) -> dict:
         """Load configuration from file"""
         try:
-            with open(config_file, 'r') as f:
+            with open(config_file) as f:
                 config = json.load(f)
                 # Update limits from config
-                if 'pr_limit' in config:
-                    self.pr_limit = config['pr_limit']
-                if 'global_limit' in config:
-                    self.global_limit = config['global_limit']
+                if "pr_limit" in config:
+                    self.pr_limit = config["pr_limit"]
+                if "global_limit" in config:
+                    self.global_limit = config["global_limit"]
                 return config
         except (FileNotFoundError, json.JSONDecodeError):
             return {}
@@ -691,7 +730,7 @@ This is an automated notification from the WorldArchitect.AI automation system.
     def has_email_config(self) -> bool:
         """Check if email configuration is available"""
         try:
-            smtp_server = os.environ.get('SMTP_SERVER')
+            smtp_server = os.environ.get("SMTP_SERVER")
             username, password = self._get_smtp_credentials()
             return bool(smtp_server and username and password)
         except Exception:
@@ -707,37 +746,172 @@ This is an automated notification from the WorldArchitect.AI automation system.
     def _is_email_configured(self) -> bool:
         """Check if email configuration is complete"""
         try:
-            smtp_server = os.environ.get('SMTP_SERVER')
-            smtp_port = os.environ.get('SMTP_PORT')
-            email_to = os.environ.get('EMAIL_TO')
+            smtp_server = os.environ.get("SMTP_SERVER")
+            smtp_port = os.environ.get("SMTP_PORT")
+            email_to = os.environ.get("EMAIL_TO")
             username, password = self._get_smtp_credentials()
             return bool(smtp_server and smtp_port and email_to and username and password)
         except Exception:
             return False
 
+    def _get_effective_pr_limit(self, pr_number: Union[int, str], repo: str = None, branch: str = None) -> int:
+        """Get effective PR limit for a specific PR (returns override if set, else default).
+
+        Args:
+            pr_number: PR number
+            repo: Repository name
+            branch: Branch name
+
+        Returns:
+            Effective limit (0 means unlimited, returns sys.maxsize)
+        """
+        with self.lock:
+            # Reload PR override file to stay in sync with CLI updates from other processes.
+            overrides_data = self._read_json_file(self.pr_overrides_file)
+            self._pr_overrides_cache = {k: int(v) for k, v in overrides_data.items()}
+
+            pr_key = self._make_pr_key(pr_number, repo, branch)
+            override = self._pr_overrides_cache.get(pr_key)
+
+            if override is not None:
+                # 0 means unlimited
+                return sys.maxsize if override == 0 else override
+            else:
+                return self.pr_limit
+
+    def clear_pr_attempts(self, pr_number: Union[int, str], repo: str = None, branch: str = None) -> bool:
+        """Clear all attempts for a specific PR.
+
+        Args:
+            pr_number: PR number
+            repo: Repository name
+            branch: Branch name
+
+        Returns:
+            True if successful
+        """
+        with self.lock:
+            pr_key = self._make_pr_key(pr_number, repo, branch)
+
+            # Clear from cache
+            if pr_key in self._pr_attempts_cache:
+                del self._pr_attempts_cache[pr_key]
+
+            # Clear from inflight cache
+            if pr_key in self._pr_inflight_cache:
+                del self._pr_inflight_cache[pr_key]
+
+            # Persist to disk
+            self._write_json_file(self.pr_attempts_file, self._pr_attempts_cache)
+            self._write_json_file(self.inflight_file, self._pr_inflight_cache)
+
+            self.logger.info(f"✅ Cleared all attempts for PR {pr_key}")
+            return True
+
+    def set_pr_limit_override(self, pr_number: Union[int, str], limit: int, repo: str = None, branch: str = None) -> bool:
+        """Set custom limit for a specific PR (0 = unlimited).
+
+        Args:
+            pr_number: PR number
+            limit: Custom limit (0 = unlimited)
+            repo: Repository name
+            branch: Branch name
+
+        Returns:
+            True if successful
+        """
+        with self.lock:
+            pr_key = self._make_pr_key(pr_number, repo, branch)
+
+            # Validate limit
+            if limit < 0:
+                self.logger.error(f"❌ Invalid limit {limit} - must be >= 0")
+                return False
+
+            # Update cache
+            self._pr_overrides_cache[pr_key] = limit
+
+            # Persist to disk
+            self._write_json_file(self.pr_overrides_file, self._pr_overrides_cache)
+
+            if limit == 0:
+                self.logger.info(f"✅ Set unlimited attempts for PR {pr_key}")
+            else:
+                self.logger.info(f"✅ Set custom limit {limit} for PR {pr_key}")
+            return True
+
+    def clear_pr_limit_override(self, pr_number: Union[int, str], repo: str = None, branch: str = None) -> bool:
+        """Remove limit override for a specific PR, revert to default.
+
+        Args:
+            pr_number: PR number
+            repo: Repository name
+            branch: Branch name
+
+        Returns:
+            True if successful
+        """
+        with self.lock:
+            pr_key = self._make_pr_key(pr_number, repo, branch)
+
+            # Remove from cache
+            if pr_key in self._pr_overrides_cache:
+                del self._pr_overrides_cache[pr_key]
+
+            # Persist to disk
+            self._write_json_file(self.pr_overrides_file, self._pr_overrides_cache)
+
+            self.logger.info(f"✅ Cleared limit override for PR {pr_key}, reverted to default ({self.pr_limit})")
+            return True
+
+    def get_pr_limit_override(self, pr_number: Union[int, str], repo: str = None, branch: str = None) -> Optional[int]:
+        """Get current limit override for a specific PR.
+
+        Args:
+            pr_number: PR number
+            repo: Repository name
+            branch: Branch name
+
+        Returns:
+            Override value if set, None otherwise (0 = unlimited)
+        """
+        with self.lock:
+            pr_key = self._make_pr_key(pr_number, repo, branch)
+            return self._pr_overrides_cache.get(pr_key)
+
 
 def main():
     """CLI interface for safety manager"""
 
-    parser = argparse.ArgumentParser(description='Automation Safety Manager')
-    parser.add_argument('--data-dir', default='/tmp/automation_safety',
-                        help='Directory for safety data files')
-    parser.add_argument('--check-pr', type=int, metavar='PR_NUMBER',
-                        help='Check if PR can be processed')
-    parser.add_argument('--record-pr', nargs=2, metavar=('PR_NUMBER', 'RESULT'),
-                        help='Record PR attempt (result: success|failure)')
-    parser.add_argument('--repo', type=str,
-                        help='Repository name (owner/repo) for PR attempt operations')
-    parser.add_argument('--branch', type=str,
-                        help='Branch name for PR attempt tracking')
-    parser.add_argument('--check-global', action='store_true',
-                        help='Check if global run can start')
-    parser.add_argument('--record-global', action='store_true',
-                        help='Record global run')
-    parser.add_argument('--manual_override', type=str, metavar='EMAIL',
-                        help='Grant manual override (emergency use only)')
-    parser.add_argument('--status', action='store_true',
-                        help='Show current status')
+    parser = argparse.ArgumentParser(description="Automation Safety Manager")
+    parser.add_argument("--data-dir", default="/tmp/automation_safety",
+                        help="Directory for safety data files")
+    parser.add_argument("--check-pr", type=int, metavar="PR_NUMBER",
+                        help="Check if PR can be processed")
+    parser.add_argument("--record-pr", nargs=2, metavar=("PR_NUMBER", "RESULT"),
+                        help="Record PR attempt (result: success|failure)")
+    parser.add_argument("--repo", type=str,
+                        help="Repository name (owner/repo) for PR attempt operations")
+    parser.add_argument("--branch", type=str,
+                        help="Branch name for PR attempt tracking")
+    parser.add_argument("--check-global", action="store_true",
+                        help="Check if global run can start")
+    parser.add_argument("--record-global", action="store_true",
+                        help="Record global run")
+    parser.add_argument("--manual_override", type=str, metavar="EMAIL",
+                        help="Grant manual override (emergency use only)")
+    parser.add_argument("--status", action="store_true",
+                        help="Show current status")
+
+    # PR limit override arguments
+    parser.add_argument("--clear-pr", type=int, metavar="PR_NUMBER",
+                        help="Clear all attempts for a specific PR")
+    parser.add_argument("--set-pr-limit", nargs=2, type=int, metavar=("PR_NUMBER", "LIMIT"),
+                        help="Set custom limit for a specific PR (0 = unlimited)")
+    parser.add_argument("--clear-pr-limit", type=int, metavar="PR_NUMBER",
+                        help="Remove limit override for a specific PR")
+    parser.add_argument("--get-pr-limit", type=int, metavar="PR_NUMBER",
+                        help="Get current limit override for a specific PR")
 
     args = parser.parse_args()
 
@@ -822,9 +996,46 @@ def main():
         else:
             print("No PR attempts recorded")
 
+    elif args.clear_pr:
+        manager.clear_pr_attempts(args.clear_pr, repo=args.repo, branch=args.branch)
+        repo_label = f" ({args.repo})" if args.repo else ""
+        branch_label = f" [{args.branch}]" if args.branch else ""
+        print(f"✅ Cleared all attempts for PR #{args.clear_pr}{repo_label}{branch_label}")
+
+    elif args.set_pr_limit:
+        pr_number, limit = args.set_pr_limit
+        repo_label = f" ({args.repo})" if args.repo else ""
+        branch_label = f" [{args.branch}]" if args.branch else ""
+        success = manager.set_pr_limit_override(pr_number, limit, repo=args.repo, branch=args.branch)
+        if not success:
+            print(f"❌ Failed to set PR limit override for PR #{pr_number}{repo_label}{branch_label}")
+            sys.exit(1)
+        if limit == 0:
+            print(f"✅ Set unlimited attempts for PR #{pr_number}{repo_label}{branch_label}")
+        else:
+            print(f"✅ Set custom limit {limit} for PR #{pr_number}{repo_label}{branch_label}")
+
+    elif args.clear_pr_limit:
+        manager.clear_pr_limit_override(args.clear_pr_limit, repo=args.repo, branch=args.branch)
+        repo_label = f" ({args.repo})" if args.repo else ""
+        branch_label = f" [{args.branch}]" if args.branch else ""
+        print(f"✅ Cleared limit override for PR #{args.clear_pr_limit}{repo_label}{branch_label}, reverted to default ({manager.pr_limit})")
+
+    elif args.get_pr_limit:
+        override = manager.get_pr_limit_override(args.get_pr_limit, repo=args.repo, branch=args.branch)
+        repo_label = f" ({args.repo})" if args.repo else ""
+        branch_label = f" [{args.branch}]" if args.branch else ""
+        if override is not None:
+            if override == 0:
+                print(f"PR #{args.get_pr_limit}{repo_label}{branch_label}: unlimited attempts (override)")
+            else:
+                print(f"PR #{args.get_pr_limit}{repo_label}{branch_label}: {override} attempts (override)")
+        else:
+            print(f"PR #{args.get_pr_limit}{repo_label}{branch_label}: {manager.pr_limit} attempts (default)")
+
     else:
         parser.print_help()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()