jleechanorg-pr-automation 0.1.0__py3-none-any.whl

jleechanorg_pr_automation/utils.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""
+Shared utilities for automation system
+
+Consolidates common patterns:
+- JSON file operations with thread safety
+- Logging configuration setup
+- Environment variable handling
+- Email configuration management
+"""
+
+import fcntl
+import json
+import logging
+import os
+import tempfile
+import threading
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+
+class SafeJSONManager:
+    """Thread-safe and cross-process safe JSON file operations with file locking"""
+
+    def __init__(self):
+        self._locks = {}
+        self._locks_lock = threading.Lock()
+
+    def _get_lock(self, file_path: str) -> threading.RLock:
+        """Get or create a lock for a specific file"""
+        # Normalize path to prevent duplicate locks for same file
+        norm_path = os.path.abspath(file_path)
+        with self._locks_lock:
+            if norm_path not in self._locks:
+                self._locks[norm_path] = threading.RLock()
+            return self._locks[norm_path]
+
+    def _get_file_lock_path(self, file_path: str) -> str:
+        """Get file lock path for cross-process safety"""
+        return f"{file_path}.lock"
+
+    def read_json(self, file_path: str, default: Any = None) -> Any:
+        """Cross-process safe JSON file reading with default fallback"""
+        lock = self._get_lock(file_path)
+        with lock:
+            try:
+                if os.path.exists(file_path):
+                    with open(file_path, 'r') as f:
+                        # Add file lock for cross-process safety
+                        fcntl.flock(f.fileno(), fcntl.LOCK_SH)
+                        try:
+                            return json.load(f)
+                        finally:
+                            fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+                else:
+                    return default if default is not None else {}
+            except (json.JSONDecodeError, IOError) as e:
+                logging.warning(f"Failed to read JSON from {file_path}: {e}")
+                return default if default is not None else {}
+
+    def write_json(self, file_path: str, data: Any) -> bool:
+        """Cross-process safe JSON file writing with atomic operations"""
+        lock = self._get_lock(file_path)
+        with lock:
+            try:
+                # Ensure directory exists (guard against empty dirname for root files)
+                directory = os.path.dirname(file_path)
+                if directory:
+                    os.makedirs(directory, exist_ok=True)
+
+                # Create temp file in same directory for atomic replace
+                dir_path = directory or "."
+                fd, temp_path = tempfile.mkstemp(
+                    dir=dir_path,
+                    prefix=os.path.basename(file_path),
+                    suffix=".tmp"
+                )
+
+                try:
+                    with os.fdopen(fd, 'w') as f:
+                        # Add exclusive file lock for cross-process safety
+                        fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+                        try:
+                            json.dump(data, f, indent=2, default=str)
+                            f.flush()
+                            os.fsync(f.fileno())
+                        finally:
+                            fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+
+                    # Atomic replace
+                    os.replace(temp_path, file_path)
+                    return True
+                finally:
+                    # Clean up temp file if replace failed
+                    if os.path.exists(temp_path):
+                        try:
+                            os.remove(temp_path)
+                        except OSError:
+                            pass
+
+            except (IOError, OSError) as e:
+                logging.error(f"Failed to write JSON to {file_path}: {e}")
+                return False
+
+    def update_json(self, file_path: str, update_func, lock_timeout: int = 10) -> bool:
+        """Cross-process safe JSON file update with callback function"""
+        lock = self._get_lock(file_path)
+        with lock:
+            try:
+                data = self.read_json(file_path, {})
+                updated_data = update_func(data)
+                return self.write_json(file_path, updated_data)
+            except Exception as e:
+                logging.error(f"Failed to update JSON {file_path}: {e}")
+                return False
+
+
+# Global instance for shared use
+json_manager = SafeJSONManager()
+
+
+def setup_logging(name: str, level: int = logging.INFO,
+                 log_file: Optional[str] = None) -> logging.Logger:
+    """Standardized logging setup for automation components"""
+    logger = logging.getLogger(name)
+
+    # Avoid duplicate handlers
+    if logger.handlers:
+        return logger
+
+    logger.setLevel(level)
+
+    # Create formatter
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+    # File handler if specified
+    if log_file:
+        os.makedirs(os.path.dirname(log_file), exist_ok=True)
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    return logger
+
+
+def get_env_config(prefix: str = "AUTOMATION_") -> Dict[str, str]:
+    """Get all environment variables with specified prefix"""
+    config = {}
+    for key, value in os.environ.items():
+        if key.startswith(prefix):
+            # Remove prefix and convert to lowercase
+            config_key = key[len(prefix):].lower()
+            config[config_key] = value
+    return config
+
+
+def get_email_config() -> Dict[str, str]:
+    """Get email configuration from environment variables"""
+    email_config = {
+        'smtp_server': os.getenv('SMTP_SERVER', 'localhost'),
+        'smtp_port': int(os.getenv('SMTP_PORT', '587')),
+        'email_user': os.getenv('EMAIL_USER', ''),
+        'email_pass': os.getenv('EMAIL_PASS', ''),
+        'email_to': os.getenv('EMAIL_TO', ''),
+        'email_from': os.getenv('EMAIL_FROM', os.getenv('EMAIL_USER', ''))
+    }
+    return email_config
+
+
+def validate_email_config(config: Dict[str, str]) -> bool:
+    """Validate that required email configuration is present"""
+    required_fields = ['smtp_server', 'email_user', 'email_pass', 'email_to']
+    return all(config.get(field) for field in required_fields)
+
+
+def get_automation_limits() -> Dict[str, int]:
+    """Get automation safety limits from environment or defaults"""
+    return {
+        'pr_limit': int(os.getenv('AUTOMATION_PR_LIMIT', '5')),
+        'global_limit': int(os.getenv('AUTOMATION_GLOBAL_LIMIT', '50')),
+        'approval_hours': int(os.getenv('AUTOMATION_APPROVAL_HOURS', '24')),
+        'subprocess_timeout': int(os.getenv('AUTOMATION_SUBPROCESS_TIMEOUT', '300'))
+    }
+
+
+def ensure_directory(file_path: str) -> None:
+    """Ensure directory exists for given file path"""
+    directory = os.path.dirname(file_path)
+    if directory:
+        os.makedirs(directory, exist_ok=True)
+
+
+def get_project_root() -> str:
+    """Get project root directory"""
+    current_dir = Path(__file__).resolve()
+    # Look for CLAUDE.md to identify project root
+    for parent in current_dir.parents:
+        if (parent / "CLAUDE.md").exists():
+            return str(parent)
+    # Fallback to parent of automation directory
+    return str(current_dir.parent.parent)
+
+
+def format_timestamp(dt: datetime = None) -> str:
+    """Format datetime as ISO string"""
+    if dt is None:
+        dt = datetime.now()
+    return dt.isoformat()
+
+
+def parse_timestamp(timestamp_str: str) -> datetime:
+    """Parse ISO timestamp string to datetime"""
+    return datetime.fromisoformat(timestamp_str)
+
+
+def get_test_email_config() -> Dict[str, str]:
+    """Get standardized test email configuration"""
+    return {
+        'SMTP_SERVER': 'smtp.example.com',
+        'SMTP_PORT': '587',
+        'EMAIL_USER': 'test@example.com',
+        'EMAIL_PASS': 'testpass',
+        'EMAIL_TO': 'admin@example.com'
+    }

jleechanorg_pr_automation-0.1.0.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: jleechanorg-pr-automation
+Version: 0.1.0
+Summary: GitHub PR automation system with safety limits and actionable counting
+Author-email: jleechan <jlee@jleechan.org>
+License: MIT
+Project-URL: Homepage, https://github.com/jleechanorg/worldarchitect.ai
+Project-URL: Repository, https://github.com/jleechanorg/worldarchitect.ai
+Project-URL: Issues, https://github.com/jleechanorg/worldarchitect.ai/issues
+Keywords: github,automation,pr,pull-request,monitoring
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+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
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Provides-Extra: email
+Requires-Dist: keyring>=23.0.0; extra == "email"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+
+# jleechanorg-pr-automation
+
+A comprehensive GitHub PR automation system with safety limits, actionable counting, and intelligent filtering.
+
+## Features
+
+- **Actionable PR Counting**: Only processes PRs that need attention, excluding already-processed ones
+- **Safety Limits**: Built-in rate limiting and attempt tracking to prevent automation abuse
+- **Cross-Process Safety**: Thread-safe operations with file-based persistence
+- **Email Notifications**: Optional SMTP integration for automation alerts
+- **Commit-Based Tracking**: Avoids duplicate processing using commit SHAs
+- **Comprehensive Testing**: 200+ test cases with matrix-driven coverage
+
+## Installation
+
+```bash
+pip install jleechanorg-pr-automation
+```
+
+### Optional Dependencies
+
+For email notifications:
+```bash
+pip install jleechanorg-pr-automation[email]
+```
+
+For development:
+```bash
+pip install jleechanorg-pr-automation[dev]
+```
+
+## Quick Start
+
+### Basic PR Monitoring
+
+```python
+from jleechanorg_pr_automation import JleechanorgPRMonitor
+
+# Initialize monitor
+monitor = JleechanorgPRMonitor()
+
+# Process up to 20 actionable PRs
+result = monitor.run_monitoring_cycle_with_actionable_count(target_actionable_count=20)
+
+print(f"Processed {result['actionable_processed']} actionable PRs")
+print(f"Skipped {result['skipped_count']} non-actionable PRs")
+```
+
+### Safety Management
+
+```python
+from jleechanorg_pr_automation import AutomationSafetyManager
+
+# Initialize safety manager with data directory
+safety = AutomationSafetyManager(data_dir="/tmp/automation_safety")
+
+# Limits are configured via automation_safety_config.json inside the data directory
+# or the AUTOMATION_PR_LIMIT / AUTOMATION_GLOBAL_LIMIT environment variables.
+
+# Check if PR can be processed
+if safety.can_process_pr(pr_number=123, repo="my-repo"):
+    # Process PR...
+    safety.record_pr_attempt(pr_number=123, result="success", repo="my-repo")
+```
+
+## Configuration
+
+### Environment Variables
+
+- `GITHUB_TOKEN`: GitHub personal access token (required)
+- `PR_AUTOMATION_WORKSPACE`: Custom workspace directory (optional)
+- `AUTOMATION_PR_LIMIT`: Maximum attempts per PR (default: 5)
+- `AUTOMATION_GLOBAL_LIMIT`: Maximum global automation runs (default: 50)
+- `AUTOMATION_APPROVAL_HOURS`: Hours before approval expires (default: 24)
+
+### Email Configuration (Optional)
+
+- `SMTP_SERVER`: SMTP server hostname
+- `SMTP_PORT`: SMTP server port (default: 587)
+- `EMAIL_USER`: SMTP username
+- `EMAIL_PASS`: SMTP password
+- `EMAIL_TO`: Notification recipient
+- `EMAIL_FROM`: Sender address (defaults to EMAIL_USER)
+
+## Command Line Interface
+
+### PR Monitor
+
+```bash
+# Monitor all repositories
+jleechanorg-pr-monitor
+
+# Process specific repository
+jleechanorg-pr-monitor --single-repo worldarchitect.ai
+
+# Process specific PR
+jleechanorg-pr-monitor --target-pr 123 --target-repo jleechanorg/worldarchitect.ai
+
+# Dry run (discovery only)
+jleechanorg-pr-monitor --dry-run
+```
+
+### Safety Manager CLI
+
+```bash
+# Check current status
+automation-safety-cli status
+
+# Clear all safety data
+automation-safety-cli clear
+
+# Check specific PR
+automation-safety-cli check-pr 123 --repo my-repo
+```
+
+## Architecture
+
+### Actionable PR Logic
+
+The system implements intelligent PR filtering:
+
+1. **State Check**: Only processes open PRs
+2. **Commit Tracking**: Skips PRs already processed with current commit SHA
+3. **Safety Limits**: Respects per-PR and global automation limits
+4. **Ordering**: Processes most recently updated PRs first
+
+### Safety Features
+
+- **Dual Limiting**: Per-PR consecutive failure limits + global run limits
+- **Cross-Process Safety**: File-based locking for concurrent automation instances
+- **Attempt Tracking**: Full history of success/failure with timestamps
+- **Graceful Degradation**: Continues processing other PRs if one fails
+
+### Testing
+
+The library includes comprehensive test coverage:
+
+- **Matrix Testing**: All PR state combinations (Open/Closed × New/Old Commits × Processed/Fresh)
+- **Actionable Counting**: Batch processing with skip exclusion
+- **Safety Limits**: Concurrent access and edge cases
+- **Integration Tests**: Real GitHub API interactions (optional)
+
+## Development
+
+```bash
+# Clone repository
+git clone https://github.com/jleechanorg/worldarchitect.ai.git
+cd worldarchitect.ai/automation
+
+# Install in development mode
+pip install -e .[dev]
+
+# Run tests
+pytest
+
+# Run tests with coverage
+pytest --cov=jleechanorg_pr_automation
+
+# Format code
+black .
+ruff check .
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass
+5. Submit a pull request
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Changelog
+
+### 0.1.0 (2025-09-28)
+
+- Initial release
+- Actionable PR counting system
+- Safety management with dual limits
+- Cross-process file-based persistence
+- Email notification support
+- Comprehensive test suite (200+ tests)
+- CLI interfaces for monitoring and safety management

jleechanorg_pr_automation-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+jleechanorg_pr_automation/__init__.py,sha256=qYUTmbETCH775SM_6ln8jX05WzAGPErD-JN7OTIzXrY,852
+jleechanorg_pr_automation/automation_safety_manager.py,sha256=La3GStljdkxsSJBklWVj8CKAx6ndCsyI_aS6tSBZGJ8,27531
+jleechanorg_pr_automation/automation_safety_wrapper.py,sha256=Oa88wGH7XKfOywVnDMxwL0EP_v5YHvkKaSHxTvyiR48,4059
+jleechanorg_pr_automation/automation_utils.py,sha256=MInKTLuQSPwIXga8em70JtgGED3KU_OsV3cvX-4tN-Y,11608
+jleechanorg_pr_automation/check_codex_comment.py,sha256=ccs4XjPLPnsuMiSS_pXo_u-EzNldR34PqyWTlu0U0H0,2221
+jleechanorg_pr_automation/codex_branch_updater.py,sha256=490tjJDOCm58LoRS3F7vslOINVBU4F2C__2dWYRKcFs,9135
+jleechanorg_pr_automation/codex_config.py,sha256=JOrAzVwdDac9gHdLFSYDco0fJ13pdOQT22kAiMYRHhg,2101
+jleechanorg_pr_automation/jleechanorg_pr_monitor.py,sha256=6WDl0zwbJJKrRrHLZQ87J-680FC2DbLCZJ4Q2Cn62dU,48700
+jleechanorg_pr_automation/utils.py,sha256=nhPyR7_wm2Bh-D2aE6ueqWVWLelzzXz_BCwkdC920ig,8168
+jleechanorg_pr_automation/tests/conftest.py,sha256=GVE-RLmzVM9yBNVgfZOHu39onmZPMPjN_vrIsmcWlvU,388
+jleechanorg_pr_automation/tests/test_actionable_counting_matrix.py,sha256=rQxFH6ontV3GpZigFRiHCXRkX0mEnespJv73L1DfPw0,12174
+jleechanorg_pr_automation/tests/test_automation_over_running_reproduction.py,sha256=X1sIKr-ZpAp-lks0wVGnNDM4Yas1uCrgSokW6rYGm38,5759
+jleechanorg_pr_automation/tests/test_automation_safety_limits.py,sha256=xFQIxLsXlP0VLnZRueFEUYOFhX1d9fxXXJf_1EzBY2Q,13340
+jleechanorg_pr_automation/tests/test_automation_safety_manager_comprehensive.py,sha256=CLyWuhl3TQrMKDoLxUikpuMtSotm6FZZZXT_WPBCI_w,22740
+jleechanorg_pr_automation/tests/test_codex_actor_matching.py,sha256=rY6AGM1DatKrYwGIryM36zYLBBK--ydOwJwkH2T7uRk,5252
+jleechanorg_pr_automation/tests/test_graphql_error_handling.py,sha256=Fv0BWLSF-eQ4n5gHwf_JSc42Y0RizrjPPlCB4THLzaI,6401
+jleechanorg_pr_automation/tests/test_pr_filtering_matrix.py,sha256=IBRn9APpNBSpedsvmKVb26ZRrHHj0EzE4F5AvCH9mP8,21415
+jleechanorg_pr_automation/tests/test_pr_targeting.py,sha256=YXyWUGQj2LzUDyZ1NU57SoRXtNcUCuRNMtgCcqrcoGU,3798
+jleechanorg_pr_automation-0.1.0.dist-info/METADATA,sha256=IUHkLXylUcpFalTqBYu82Rk35s1XmHYTSB-0_lHWUOQ,6333
+jleechanorg_pr_automation-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jleechanorg_pr_automation-0.1.0.dist-info/entry_points.txt,sha256=QD8UUHJ4H09_beMvHzZ5SOy5cRbthvD11mXLzaWjwrg,178
+jleechanorg_pr_automation-0.1.0.dist-info/top_level.txt,sha256=1DJKrq0Be2B5_NL5jTICV1rvnqaMXFmyJpuOTUatcig,26
+jleechanorg_pr_automation-0.1.0.dist-info/RECORD,,

jleechanorg_pr_automation-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jleechanorg_pr_automation-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+automation-safety-cli = jleechanorg_pr_automation.automation_safety_manager:main
+jleechanorg-pr-monitor = jleechanorg_pr_automation.jleechanorg_pr_monitor:main

jleechanorg_pr_automation-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+jleechanorg_pr_automation