jleechanorg-pr-automation 0.2.41__tar.gz → 0.2.82__tar.gz

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jleechanorg-pr-automation
-Version: 0.2.41
+Version: 0.2.82
 Summary: GitHub PR automation system with safety limits and actionable counting
 Author-email: jleechan <jlee@jleechan.org>
 License-Expression: MIT
@@ -17,13 +17,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Version Control :: Git
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.25.0
 Requires-Dist: jleechanorg-orchestration>=0.1.18
 Requires-Dist: playwright>=1.40.0
 Requires-Dist: playwright-stealth>=1.0.0
 Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: PyYAML>=6.0
 Provides-Extra: email
 Requires-Dist: keyring>=23.0.0; extra == "email"
 Provides-Extra: dev
@@ -290,7 +291,7 @@ jleechanorg-pr-monitor --fixpr --dry-run
 
 ```bash
 # Monitor and fix in one command
-jleechanorg-pr-monitor --fixpr --max-prs 5 --fixpr-agent claude
+jleechanorg-pr-monitor --fixpr --max-prs 5 --cli-agent claude
 ```
 
 ### Agent CLI Options

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.82}/README.md

@@ -255,7 +255,7 @@ jleechanorg-pr-monitor --fixpr --dry-run
 
 ```bash
 # Monitor and fix in one command
-jleechanorg-pr-monitor --fixpr --max-prs 5 --fixpr-agent claude
+jleechanorg-pr-monitor --fixpr --max-prs 5 --cli-agent claude
 ```
 
 ### Agent CLI Options

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.82}/jleechanorg_pr_automation/__init__.py

@@ -6,12 +6,23 @@ safety features, intelligent filtering, and cross-process synchronization.
 """
 
 import re
-from importlib.metadata import PackageNotFoundError, version as dist_version
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as dist_version
 from pathlib import Path
-from typing import Optional
+from typing import Any
 
 from .automation_safety_manager import AutomationSafetyManager
-from .jleechanorg_pr_monitor import JleechanorgPRMonitor
+
+
+# Lazy import to avoid RuntimeWarning when running as script
+# Use __getattr__ for Python 3.7+ lazy module imports
+def __getattr__(name: str) -> Any:
+    """Lazy import of JleechanorgPRMonitor to avoid frozen module warning."""
+    if name == "JleechanorgPRMonitor":
+        from .jleechanorg_pr_monitor import JleechanorgPRMonitor
+        return JleechanorgPRMonitor
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 from .utils import (
     SafeJSONManager,
     get_automation_limits,
@@ -26,7 +37,7 @@ _SECTION_RE = re.compile(r"^\s*\[[^\]]+\]\s*$")
 _VERSION_RE = re.compile(r'^\s*version\s*=\s*"([^"]+)"\s*$')
 
 
-def _version_from_pyproject(pyproject_path: Path) -> Optional[str]:
+def _version_from_pyproject(pyproject_path: Path) -> str | None:
     if not pyproject_path.exists():
         return None
 

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.82}/jleechanorg_pr_automation/automation_safety_manager.py

@@ -17,7 +17,7 @@ import os
 import smtplib
 import sys
 import threading
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from typing import Dict, Optional, Union
@@ -194,6 +194,29 @@ class AutomationSafetyManager:
             # Sync inflight cache to prevent concurrent processing
             self._write_json_file(self.inflight_file, self._pr_inflight_cache)
 
+    def _parse_timestamp(self, timestamp_str: str) -> datetime:
+        """Parse ISO timestamp string to datetime object.
+
+        Returns:
+            datetime object in UTC, or epoch (1970-01-01) if parsing fails
+        """
+        if not timestamp_str:
+            return datetime(1970, 1, 1, tzinfo=timezone.utc)
+
+        try:
+            # Parse ISO format timestamp (e.g., "2026-01-18T02:33:26.798956+00:00")
+            dt = datetime.fromisoformat(timestamp_str)
+            # Ensure timezone-aware (convert to UTC if needed)
+            if dt.tzinfo is None:
+                dt = dt.replace(tzinfo=timezone.utc)
+            return dt
+        except (ValueError, AttributeError, TypeError):
+            # Return epoch if parse fails (very old attempt, will be filtered out)
+            # TypeError: timestamp is not a string (e.g., int from corrupted/legacy data)
+            # ValueError: timestamp string is malformed
+            # AttributeError: timestamp_str is None or has no expected attributes
+            return datetime(1970, 1, 1, tzinfo=timezone.utc)
+
     def _make_pr_key(
         self,
         pr_number: Union[int, str],
@@ -354,11 +377,12 @@ class AutomationSafetyManager:
     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).
 
-        NEW BEHAVIOR: Counts ALL attempts (success + failure) against the limit.
+        NEW BEHAVIOR: Uses rolling window (default 24 hours) instead of daily reset.
+        Attempts expire gradually as they age out of the window, not all at midnight.
         Supports per-PR limit overrides (0 = unlimited).
 
         Blocks if:
-        1. Total attempts >= effective_pr_limit (respects overrides)
+        1. Attempts in last N hours >= effective_pr_limit (respects overrides)
         """
         with self.lock:
             raw_data = self._read_json_file(self.pr_attempts_file)
@@ -370,54 +394,106 @@ class AutomationSafetyManager:
             # Get effective limit (checks for per-PR override)
             effective_limit = self._get_effective_pr_limit(pr_number, repo, branch)
 
-            # Count ALL attempts (not just failures)
-            total_attempts = len(attempts)
+            # Filter attempts to rolling window (last N hours)
+            # Get window hours from env var or config (default 24)
+            # Use coerce_positive_int to gracefully handle invalid env var values
+            window_hours = coerce_positive_int(
+                os.environ.get("AUTOMATION_ATTEMPT_WINDOW_HOURS", "24"),
+                default=24
+            )
+            cutoff_time = datetime.now(timezone.utc) - timedelta(hours=window_hours)
+
+            window_attempts = [
+                attempt for attempt in attempts
+                if isinstance(attempt, dict) and self._parse_timestamp(attempt.get("timestamp")) >= cutoff_time
+            ]
+
+            # Count attempts within rolling window
+            total_attempts = len(window_attempts)
 
             # 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."""
+        """Atomically reserve a processing slot for PR with proper cross-process locking."""
         with self.lock:
             # Check consecutive failure limit first
             if not self.can_process_pr(pr_number, repo, branch):
                 return False
 
             pr_key = self._make_pr_key(pr_number, repo, branch)
-            inflight = self._pr_inflight_cache.get(pr_key, 0)
 
-            # Check if we're at the concurrent processing limit for this PR
-            if inflight >= self.pr_limit:
-                return False
+            # Use atomic_update to prevent race conditions between processes
+            # This holds the file lock across the entire read-modify-write operation
+            success = False
 
-            # Reserve a processing slot
-            self._pr_inflight_cache[pr_key] = inflight + 1
+            def reserve_slot(inflight_data: dict) -> dict:
+                nonlocal success
+                # Update in-memory cache from disk data
+                self._pr_inflight_cache = {k: int(v) for k, v in inflight_data.items()}
 
-            # Persist immediately to prevent race conditions with concurrent cron jobs
-            self._write_json_file(self.inflight_file, self._pr_inflight_cache)
+                inflight = self._pr_inflight_cache.get(pr_key, 0)
 
-            return True
+                # Check if we're at the concurrent processing limit for this PR
+                if inflight >= self.pr_limit:
+                    success = False
+                    return inflight_data  # Return unchanged
+
+                # Reserve a processing slot
+                self._pr_inflight_cache[pr_key] = inflight + 1
+                success = True
+                return self._pr_inflight_cache
+
+            json_manager.atomic_update(self.inflight_file, reserve_slot, {})
+            return success
 
     def release_pr_slot(self, pr_number: Union[int, str], repo: str = None, branch: str = None):
-        """Release a processing slot for PR (call in finally block)"""
+        """Release a processing slot for PR (call in finally block) with atomic cross-process locking."""
         with self.lock:
             pr_key = self._make_pr_key(pr_number, repo, branch)
-            inflight = self._pr_inflight_cache.get(pr_key, 0)
-            if inflight > 0:
-                self._pr_inflight_cache[pr_key] = inflight - 1
-                # Persist immediately to prevent race conditions
-                self._write_json_file(self.inflight_file, self._pr_inflight_cache)
+
+            # Use atomic_update to prevent race conditions between processes
+            def release_slot(inflight_data: dict) -> dict:
+                # Update in-memory cache from disk data
+                self._pr_inflight_cache = {k: int(v) for k, v in inflight_data.items()}
+
+                inflight = self._pr_inflight_cache.get(pr_key, 0)
+                if inflight > 0:
+                    self._pr_inflight_cache[pr_key] = inflight - 1
+                    if self._pr_inflight_cache[pr_key] == 0:
+                        self._pr_inflight_cache.pop(pr_key, None)
+
+                return self._pr_inflight_cache
+
+            json_manager.atomic_update(self.inflight_file, release_slot, {})
 
     def get_pr_attempts(self, pr_number: Union[int, str], repo: str = None, branch: str = None):
-        """Get count of ALL attempts (success + failure) for a specific PR.
+        """Get count of attempts for a specific PR.
 
-        NEW BEHAVIOR: Counts ALL attempts, not just consecutive failures.
+        NEW BEHAVIOR: Uses rolling window (consistent with can_process_pr()).
+        This ensures CLI output matches actual attempt counting logic.
         """
         with self.lock:
+            raw_data = self._read_json_file(self.pr_attempts_file)
+            self._pr_attempts_cache = self._normalize_pr_attempt_keys(raw_data)
             pr_key = self._make_pr_key(pr_number, repo, branch)
             attempts = list(self._pr_attempts_cache.get(pr_key, []))
-            # Return total count of ALL attempts
-            return len(attempts)
+
+            # Filter attempts to rolling window (last N hours)
+            # MUST match the logic in can_process_pr() to avoid misleading CLI output
+            window_hours = coerce_positive_int(
+                os.environ.get("AUTOMATION_ATTEMPT_WINDOW_HOURS", "24"),
+                default=24
+            )
+            cutoff_time = datetime.now(timezone.utc) - timedelta(hours=window_hours)
+
+            window_attempts = [
+                attempt for attempt in attempts
+                if isinstance(attempt, dict) and self._parse_timestamp(attempt.get("timestamp")) >= cutoff_time
+            ]
+
+            # Return count of attempts within rolling window
+            return len(window_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)"""
@@ -436,7 +512,7 @@ class AutomationSafetyManager:
             # Create attempt record
             attempt_record = {
                 "result": result,
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "pr_number": pr_number,
                 "repo": repo,
                 "branch": branch
@@ -547,7 +623,8 @@ class AutomationSafetyManager:
                 return False
 
             try:
-                approval_date = REAL_DATETIME.fromisoformat(approval_date_str)
+                # Use replace(tzinfo=None) for compatibility with datetime.now()
+                approval_date = REAL_DATETIME.fromisoformat(approval_date_str).replace(tzinfo=None)
             except (TypeError, ValueError):
                 return False
             expiry = approval_date + timedelta(hours=self.approval_hours)

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.82}/jleechanorg_pr_automation/codex_config.py

@@ -39,6 +39,8 @@ FIX_COMMENT_RUN_MARKER_SUFFIX = "-->"
 # Updated to match new format from build_automation_marker()
 FIXPR_MARKER_PREFIX = "<!-- fixpr-run-automation-commit:"
 FIXPR_MARKER_SUFFIX = "-->"
+COMMENT_VALIDATION_MARKER_PREFIX = "<!-- comment-validation-commit:"
+COMMENT_VALIDATION_MARKER_SUFFIX = "-->"
 
 
 def build_automation_marker(workflow: str, agent: str, commit_sha: str) -> str: