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

jleechanorg_pr_automation/automation_safety_wrapper.py

@@ -3,33 +3,27 @@
 Automation Safety Wrapper for launchd
 
 This wrapper enforces safety limits before running PR automation:
-- Max 5 attempts per PR
+- Max 10 attempts per PR
 - Max 50 total automation runs before requiring manual approval
 - Email notifications when limits are reached
 """
 
-import sys
+import logging
 import os
 import subprocess
-import logging
+import sys
 from pathlib import Path
+
 from .automation_safety_manager import AutomationSafetyManager
+from .logging_utils import setup_logging as _setup_logging
 
 
 def setup_logging() -> logging.Logger:
-    """Set up logging for automation wrapper"""
+    """Set up logging delegated to centralized logging_utils"""
     log_dir = Path.home() / "Library" / "Logs" / "worldarchitect-automation"
-    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / "automation_safety.log"
 
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(levelname)s - %(message)s',
-        handlers=[
-            logging.FileHandler(log_dir / "automation_safety.log"),
-            logging.StreamHandler()
-        ]
-    )
-    return logging.getLogger(__name__)
+    return _setup_logging(__name__, log_file=str(log_file))
 
 
 def main() -> int:
@@ -66,8 +60,8 @@ def main() -> int:
 
         # Execute with environment variables for safety integration
         env = os.environ.copy()
-        env['AUTOMATION_SAFETY_DATA_DIR'] = str(data_dir)
-        env['AUTOMATION_SAFETY_WRAPPER'] = '1'
+        env["AUTOMATION_SAFETY_DATA_DIR"] = str(data_dir)
+        env["AUTOMATION_SAFETY_WRAPPER"] = "1"
 
         # Record the global run *before* launching the monitor so the attempt
         # is counted even if the subprocess fails to start or exits early.
@@ -78,8 +72,8 @@ def main() -> int:
         )
 
         result = subprocess.run(
-            [sys.executable, '-m', 'jleechanorg_pr_automation.jleechanorg_pr_monitor'],
-            env=env,
+            [sys.executable, "-m", "jleechanorg_pr_automation.jleechanorg_pr_monitor"],
+            check=False, env=env,
             capture_output=True,
             text=True,
             timeout=3600,
@@ -112,5 +106,5 @@ def main() -> int:
         manager.check_and_notify_limits()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())

jleechanorg_pr_automation/automation_utils.py

@@ -10,20 +10,21 @@ Consolidates common functionality used across automation components:
 - File and directory management utilities
 """
 
-import os
-import sys
+import fcntl
 import json
 import logging
+import os
 import smtplib
-import tempfile
-import threading
-import fcntl
 import subprocess
+import tempfile
+import time
 from datetime import datetime
-from pathlib import Path
-from typing import Dict, Optional, Tuple, Any
-from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from pathlib import Path
+from typing import Any, Dict, Optional, Sequence, Tuple
+
+from .logging_utils import setup_logging as _setup_logging
 
 try:
     import keyring
@@ -37,17 +38,17 @@ class AutomationUtils:
 
     # Default configuration
     DEFAULT_CONFIG = {
-        'SMTP_SERVER': 'smtp.gmail.com',
-        'SMTP_PORT': 587,
-        'LOG_DIR': '~/Library/Logs/worldarchitect-automation',
-        'DATA_DIR': '~/Library/Application Support/worldarchitect-automation',
-        'MAX_SUBPROCESS_TIMEOUT': int(os.getenv('AUTOMATION_SUBPROCESS_TIMEOUT', '300')),  # 5 minutes (configurable)
-        'EMAIL_SUBJECT_PREFIX': '[WorldArchitect Automation]'
+        "SMTP_SERVER": "smtp.gmail.com",
+        "SMTP_PORT": 587,
+        "LOG_DIR": "~/Library/Logs/worldarchitect-automation",
+        "DATA_DIR": "~/Library/Application Support/worldarchitect-automation",
+        "MAX_SUBPROCESS_TIMEOUT": int(os.getenv("AUTOMATION_SUBPROCESS_TIMEOUT", "300")),  # 5 minutes (configurable)
+        "EMAIL_SUBJECT_PREFIX": "[WorldArchitect Automation]"
     }
 
     @classmethod
     def setup_logging(cls, name: str, log_filename: str = None) -> logging.Logger:
-        """Unified logging setup for all automation components
+        """Unified logging setup delegated to centralized logging_utils.
 
         Args:
             name: Logger name (typically __name__)
@@ -56,25 +57,17 @@ class AutomationUtils:
         Returns:
             Configured logger instance
         """
+        # Use centralized logging with DEFAULT_CONFIG log directory
+        log_dir = Path(cls.DEFAULT_CONFIG["LOG_DIR"]).expanduser()
+
+        # If no filename specified, create one from module name
         if log_filename is None:
-            log_filename = f"{name.split('.')[-1]}.log"
-
-        # Create log directory
-        log_dir = Path(cls.DEFAULT_CONFIG['LOG_DIR']).expanduser()
-        log_dir.mkdir(parents=True, exist_ok=True)
-
-        # Set up logging with consistent format
-        logging.basicConfig(
-            level=logging.INFO,
-            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-            handlers=[
-                logging.FileHandler(log_dir / log_filename),
-                logging.StreamHandler()
-            ]
-        )
-
-        logger = logging.getLogger(name)
-        logger.info(f"🛠️  Logging initialized - logs: {log_dir / log_filename}")
+            log_file = log_dir / f"{name.split('.')[-1]}.log"
+        else:
+            log_file = log_dir / log_filename if not Path(log_filename).is_absolute() else log_filename
+
+        logger = _setup_logging(name, log_file=str(log_file))
+        logger.info(f"🛠️  Logging initialized - logs: {log_file}")
         return logger
 
     @classmethod
@@ -84,8 +77,8 @@ class AutomationUtils:
         if env_value is not None:
             # Try to convert to appropriate type
             if isinstance(default, bool):
-                return env_value.lower() in ('true', '1', 'yes', 'on')
-            elif isinstance(default, int):
+                return env_value.lower() in ("true", "1", "yes", "on")
+            if isinstance(default, int):
                 try:
                     return int(env_value)
                 except ValueError:
@@ -96,7 +89,7 @@ class AutomationUtils:
     @classmethod
     def get_data_directory(cls, subdir: str = None) -> Path:
         """Get standardized data directory path"""
-        data_dir = Path(cls.DEFAULT_CONFIG['DATA_DIR']).expanduser()
+        data_dir = Path(cls.DEFAULT_CONFIG["DATA_DIR"]).expanduser()
         if subdir:
             data_dir = data_dir / subdir
         data_dir.mkdir(parents=True, exist_ok=True)
@@ -117,9 +110,9 @@ class AutomationUtils:
 
         # Fallback to environment variables if keyring fails or unavailable
         if not username:
-            username = os.environ.get('SMTP_USERNAME')
+            username = os.environ.get("SMTP_USERNAME")
         if not password:
-            password = os.environ.get('SMTP_PASSWORD')
+            password = os.environ.get("SMTP_PASSWORD")
 
         return username, password
 
@@ -139,13 +132,13 @@ class AutomationUtils:
         """
         try:
             # Get SMTP configuration
-            smtp_server = cls.get_config_value('SMTP_SERVER')
-            smtp_port = cls.get_config_value('SMTP_PORT')
+            smtp_server = cls.get_config_value("SMTP_SERVER")
+            smtp_port = cls.get_config_value("SMTP_PORT")
             username, password = cls.get_smtp_credentials()
 
             # Get email addresses
-            from_email = from_email or os.environ.get('MEMORY_EMAIL_FROM')
-            to_email = to_email or os.environ.get('MEMORY_EMAIL_TO')
+            from_email = from_email or os.environ.get("MEMORY_EMAIL_FROM")
+            to_email = to_email or os.environ.get("MEMORY_EMAIL_TO")
 
             if not all([username, password, from_email, to_email]):
                 print("Email configuration incomplete - skipping notification")
@@ -153,9 +146,9 @@ class AutomationUtils:
 
             # Build email message
             msg = MIMEMultipart()
-            msg['From'] = from_email
-            msg['To'] = to_email
-            msg['Subject'] = f"{cls.DEFAULT_CONFIG['EMAIL_SUBJECT_PREFIX']} {subject}"
+            msg["From"] = from_email
+            msg["To"] = to_email
+            msg["Subject"] = f"{cls.DEFAULT_CONFIG['EMAIL_SUBJECT_PREFIX']} {subject}"
 
             # Add timestamp to message
             full_message = f"""{message}
@@ -165,7 +158,7 @@ System: WorldArchitect Automation
 
 This is an automated notification from the WorldArchitect.AI automation system."""
 
-            msg.attach(MIMEText(full_message, 'plain'))
+            msg.attach(MIMEText(full_message, "plain"))
 
             # Send email with timeout and proper error handling
             with smtplib.SMTP(smtp_server, smtp_port, timeout=30) as server:
@@ -192,7 +185,11 @@ This is an automated notification from the WorldArchitect.AI automation system."
     @classmethod
     def execute_subprocess_with_timeout(cls, command: list, timeout: int = None,
                                       cwd: str = None, capture_output: bool = True,
-                                      check: bool = True) -> subprocess.CompletedProcess:
+                                      check: bool = True,
+                                      retry_attempts: int = 1,
+                                      retry_backoff_seconds: float = 1.0,
+                                      retry_backoff_multiplier: float = 2.0,
+                                      retry_on_stderr_substrings: Optional[Sequence[str]] = None) -> subprocess.CompletedProcess:
         """Execute subprocess with standardized timeout and error handling
 
         Args:
@@ -201,6 +198,10 @@ This is an automated notification from the WorldArchitect.AI automation system."
             cwd: Working directory
             capture_output: Whether to capture stdout/stderr
             check: Whether to raise CalledProcessError on non-zero exit (default True)
+            retry_attempts: Total attempts for retryable failures (default 1 = no retries)
+            retry_backoff_seconds: Initial backoff between retries
+            retry_backoff_multiplier: Backoff multiplier per attempt
+            retry_on_stderr_substrings: If provided, only retry when stderr/stdout contains one of these substrings
 
         Returns:
             CompletedProcess instance
@@ -210,26 +211,47 @@ This is an automated notification from the WorldArchitect.AI automation system."
             subprocess.CalledProcessError: If command fails and check=True
         """
         if timeout is None:
-            timeout = cls.get_config_value('MAX_SUBPROCESS_TIMEOUT')
+            timeout = cls.get_config_value("MAX_SUBPROCESS_TIMEOUT")
+
+        try:
+            retry_attempts_int = int(retry_attempts)
+        except (TypeError, ValueError):
+            retry_attempts_int = 1
+        if retry_attempts_int < 1:
+            retry_attempts_int = 1
+
+        attempt = 1
+        while True:
+            try:
+                # Ensure shell=False for security, check parameter controls error handling
+                return subprocess.run(
+                    command,
+                    timeout=timeout,
+                    cwd=cwd,
+                    capture_output=capture_output,
+                    text=True,
+                    shell=False,
+                    check=check,
+                )
+            except subprocess.CalledProcessError as exc:
+                if attempt >= retry_attempts_int:
+                    raise
 
-        # Ensure shell=False for security, check parameter controls error handling
-        result = subprocess.run(
-            command,
-            timeout=timeout,
-            cwd=cwd,
-            capture_output=capture_output,
-            text=True,
-            shell=False,
-            check=check
-        )
+                if retry_on_stderr_substrings:
+                    stderr = (exc.stderr or "") + "\n" + (exc.stdout or "")
+                    if not any(token in stderr for token in retry_on_stderr_substrings):
+                        raise
 
-        return result
+                delay = float(retry_backoff_seconds) * (float(retry_backoff_multiplier) ** (attempt - 1))
+                delay = max(0.0, min(delay, 60.0))
+                time.sleep(delay)
+                attempt += 1
 
     @classmethod
     def safe_read_json(cls, file_path: Path) -> dict:
         """Safely read JSON file with file locking"""
         try:
-            with open(file_path, 'r') as f:
+            with open(file_path) as f:
                 fcntl.flock(f.fileno(), fcntl.LOCK_SH)  # Shared lock for reading
                 data = json.load(f)
                 fcntl.flock(f.fileno(), fcntl.LOCK_UN)  # Unlock
@@ -245,7 +267,7 @@ This is an automated notification from the WorldArchitect.AI automation system."
         try:
             # Create temporary file securely
             with tempfile.NamedTemporaryFile(
-                mode='w',
+                mode="w",
                 suffix=".tmp",
                 delete=False
             ) as temp_file:
@@ -263,7 +285,7 @@ This is an automated notification from the WorldArchitect.AI automation system."
             os.rename(temp_path, file_path)
             temp_path = None  # Successful, don't clean up
 
-        except (OSError, IOError, json.JSONEncodeError) as e:
+        except (OSError, json.JSONEncodeError) as e:
             # Clean up temp file on error
             if temp_path and os.path.exists(temp_path):
                 try:
@@ -282,13 +304,13 @@ This is an automated notification from the WorldArchitect.AI automation system."
             try:
                 # Source the bash config file by running it and capturing environment
                 result = cls.execute_subprocess_with_timeout(
-                    ['bash', '-c', f'source {config_file} && env'],
+                    ["bash", "-c", f"source {config_file} && env"],
                     timeout=10
                 )
 
                 for line in result.stdout.splitlines():
-                    if '=' in line:
-                        key, value = line.split('=', 1)
+                    if "=" in line:
+                        key, value = line.split("=", 1)
                         config[key] = value
 
             except Exception as e:

jleechanorg_pr_automation/check_codex_comment.py

@@ -55,7 +55,13 @@ def decide(marker_prefix: str, marker_suffix: str) -> Tuple[str, str]:
         if end_index == -1:
             continue
 
-        marker_sha = body[start_index:end_index].strip()
+        marker_content = body[start_index:end_index].strip()
+        # Handle new format: SHA:cli -> extract just SHA
+        # Also handles old format: SHA (no colon)
+        if ":" in marker_content:
+            marker_sha = marker_content.split(":")[0]
+        else:
+            marker_sha = marker_content
         if marker_sha == head_sha:
             return "skip", head_sha
 

jleechanorg_pr_automation/codex_branch_updater.py

@@ -13,18 +13,22 @@ from typing import Dict, Tuple
 from playwright.async_api import (
     Browser,
     BrowserContext,
-    Error as PlaywrightError,
     Page,
-    TimeoutError as PlaywrightTimeoutError,
     async_playwright,
 )
+from playwright.async_api import (
+    Error as PlaywrightError,
+)
+from playwright.async_api import (
+    TimeoutError as PlaywrightTimeoutError,
+)
 
 CHATGPT_CODEX_URL = "https://chatgpt.com/codex"
 CREDENTIALS_PATH = Path.home() / ".chatgpt_codex_credentials.json"
 AUTH_STATE_PATH = Path.home() / ".chatgpt_codex_auth_state.json"
-TASK_CARD_SELECTOR = "[data-testid=\"codex-task-card\"]"
-UPDATE_BRANCH_BUTTON_SELECTOR = "button:has-text(\"Update Branch\")"
-TASK_TITLE_SELECTOR = "[data-testid=\"codex-task-title\"]"
+TASK_CARD_SELECTOR = '[data-testid="codex-task-card"]'
+UPDATE_BRANCH_BUTTON_SELECTOR = 'button:has-text("Update Branch")'
+TASK_TITLE_SELECTOR = '[data-testid="codex-task-title"]'
 
 
 def _save_credentials(credentials: Dict[str, str]) -> None:
@@ -76,14 +80,16 @@ def get_credentials() -> Dict[str, str]:
     return credentials
 
 
-async def ensure_logged_in(page: Page, credentials: Dict[str, str] | None = None) -> None:
-    """Log into ChatGPT Codex if required."""
+async def ensure_logged_in(page: Page, context: BrowserContext, credentials: Dict[str, str] | None = None) -> None:
+    """Log into ChatGPT Codex if required and save auth state immediately."""
 
     await page.goto(CHATGPT_CODEX_URL, wait_until="domcontentloaded")
 
     if await is_task_list_visible(page):
+        print("✅ Session still valid (task list visible).")
         return
 
+    print("⚠️  Session expired. Re-authenticating...")
     if credentials is None:
         credentials = get_credentials()
 
@@ -95,6 +101,9 @@ async def ensure_logged_in(page: Page, credentials: Dict[str, str] | None = None
 
     await _complete_login_flow(page, credentials)
 
+    await context.storage_state(path=str(AUTH_STATE_PATH))
+    print(f"💾 New authentication state saved immediately to {AUTH_STATE_PATH}.")
+
 
 async def _complete_login_flow(page: Page, credentials: Dict[str, str]) -> None:
     """Fill in the login flow using the provided credentials."""
@@ -244,16 +253,19 @@ async def run() -> None:
         browser = await playwright.chromium.launch(headless=False)
         context_kwargs = {}
         if AUTH_STATE_PATH.exists():
+            print(f"🔄 Loading saved authentication state from {AUTH_STATE_PATH}")
             context_kwargs["storage_state"] = str(AUTH_STATE_PATH)
+        else:
+            print("ℹ️  No saved authentication state found. Fresh login required.")
         context = await browser.new_context(**context_kwargs)
         page = await context.new_page()
 
-        await ensure_logged_in(page)
+        await ensure_logged_in(page, context)
         await wait_for_task_list(page)
         await process_tasks(page)
 
         await context.storage_state(path=str(AUTH_STATE_PATH))
-        print(f"💾 Authentication state saved to {AUTH_STATE_PATH}.")
+        print(f"💾 Final authentication state saved to {AUTH_STATE_PATH}.")
     finally:
         if context is not None:
             await context.close()

jleechanorg_pr_automation/codex_config.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-
 DEFAULT_ASSISTANT_HANDLE = "coderabbitai"
 
 
@@ -25,13 +24,81 @@ CODEX_COMMENT_INTRO_BODY = (
 CODEX_COMMENT_TEMPLATE = (
     "{comment_intro}\n\n"
     "Use your judgment to fix comments from everyone or explain why it should not be fixed. "
-    "Follow binary response protocol - every comment needs \"DONE\" or \"NOT DONE\" classification "
+    'Follow binary response protocol - every comment needs "DONE" or "NOT DONE" classification '
     "explicitly with an explanation. Address all comments on this PR. Fix any failing tests and "
     "resolve merge conflicts. Push any commits needed to remote so the PR is updated."
 )
 
 CODEX_COMMIT_MARKER_PREFIX = "<!-- codex-automation-commit:"
 CODEX_COMMIT_MARKER_SUFFIX = "-->"
+FIX_COMMENT_MARKER_PREFIX = "<!-- fix-comment-automation-commit:"
+FIX_COMMENT_MARKER_SUFFIX = "-->"
+# Updated to match new format from build_automation_marker()
+FIX_COMMENT_RUN_MARKER_PREFIX = "<!-- fix-comment-run-automation-commit:"
+FIX_COMMENT_RUN_MARKER_SUFFIX = "-->"
+# Updated to match new format from build_automation_marker()
+FIXPR_MARKER_PREFIX = "<!-- fixpr-run-automation-commit:"
+FIXPR_MARKER_SUFFIX = "-->"
+
+
+def build_automation_marker(workflow: str, agent: str, commit_sha: str) -> str:
+    """Build enhanced automation marker with workflow, agent, and commit info.
+
+    Args:
+        workflow: Workflow type (e.g., 'fix-comment-run', 'fixpr-run', 'codex')
+        agent: Agent/CLI name (e.g., 'gemini', 'codex', 'claude')
+        commit_sha: Git commit SHA
+
+    Returns:
+        HTML comment marker with format: <!-- workflow-automation-commit:agent:sha -->
+
+    Example:
+        >>> build_automation_marker('fix-comment-run', 'gemini', 'abc123')
+        '<!-- fix-comment-run-automation-commit:gemini:abc123-->'
+    """
+    return f"<!-- {workflow}-automation-commit:{agent}:{commit_sha}-->"
+
+
+def parse_automation_marker(marker: str) -> dict[str, str] | None:
+    """Parse automation marker to extract workflow, agent, and commit.
+
+    Args:
+        marker: Automation marker string
+
+    Returns:
+        Dict with 'workflow', 'agent', 'commit' keys, or None if invalid
+
+    Example:
+        >>> parse_automation_marker('<!-- fix-comment-automation-commit:gemini:abc123-->')
+        {'workflow': 'fix-comment', 'agent': 'gemini', 'commit': 'abc123'}
+    """
+    if not marker.startswith('<!--') or not marker.endswith('-->'):
+        return None
+
+    # Remove HTML comment markers (slice off "<!--" and "-->")
+    content = marker[4:-3].strip()
+
+    # Try new format first: workflow-automation-commit:agent:sha
+    if '-automation-commit:' in content and content.count(':') == 2:
+        parts = content.split(':')
+        workflow = parts[0].replace('-automation-commit', '')
+        return {
+            'workflow': workflow,
+            'agent': parts[1],
+            'commit': parts[2]
+        }
+
+    # Legacy format: workflow-automation-commit:sha (no agent)
+    if '-automation-commit:' in content and content.count(':') == 1:
+        parts = content.split(':')
+        workflow = parts[0].replace('-automation-commit', '')
+        return {
+            'workflow': workflow,
+            'agent': 'unknown',
+            'commit': parts[1]
+        }
+
+    return None
 
 
 def normalise_handle(assistant_handle: str | None) -> str:
@@ -115,7 +182,7 @@ class CodexConfig:
     commit_marker_suffix: str = CODEX_COMMIT_MARKER_SUFFIX
 
     @classmethod
-    def from_env(cls, assistant_handle: str | None) -> "CodexConfig":
+    def from_env(cls, assistant_handle: str | None) -> CodexConfig:
         handle = normalise_handle(assistant_handle)
         return cls(
             assistant_handle=handle,