polycoding 0.1.0__py3-none-any.whl

cli/utils.py

@@ -0,0 +1,70 @@
+"""Shared utilities for CLI commands."""
+
+import logging
+from typing import Any
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+console = Console()
+
+NOISY_LOGGERS = [
+    "urllib3.connectionpool",
+    "httpcore.connection",
+    "httpcore",
+    "openai._base_client",
+]
+
+
+def setup_logging(level: int | str = logging.INFO) -> None:
+    """Configure Rich logging.
+
+    Args:
+        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL) as int or str
+    """
+    if isinstance(level, str):
+        level = getattr(logging, level.upper(), logging.INFO)
+
+    logging.basicConfig(
+        level=level,
+        format="%(name)s - %(message)s",
+        handlers=[
+            RichHandler(
+                console=console,
+                rich_tracebacks=True,
+            )
+        ],
+    )
+
+    for logger_name in NOISY_LOGGERS:
+        logging.getLogger(logger_name).setLevel(logging.WARNING)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get logger instance.
+
+    Args:
+        name: Logger name (typically __name__)
+
+    Returns:
+        Logger instance
+    """
+    return logging.getLogger(f"polycode.{name}")
+
+
+def load_bootstrap() -> Any:
+    """Load bootstrap system for full runtime initialization.
+
+    Returns:
+        ModuleContext with engine, hook manager, and config
+    """
+    from bootstrap import bootstrap
+
+    log = get_logger("cli.utils")
+    log.debug("🔧 Loading bootstrap system...")
+
+    context = bootstrap()
+
+    log.debug(f"✅ Bootstrap loaded: {len(context.config)} modules configured")
+
+    return context

cli/worker.py

@@ -0,0 +1,124 @@
+"""Worker commands for Polycode CLI."""
+
+import sys
+
+import typer
+from rich.console import Console
+
+from cli import print_error, print_info, print_success
+from cli.utils import get_logger
+
+log = get_logger(__name__)
+console = Console()
+
+worker_app = typer.Typer(help="Celery worker management commands")
+
+
+@worker_app.command("start")
+def worker_start(
+    queues: str = typer.Option("celery,default", "--queues", "-q", help="Comma-separated queue names"),
+    concurrency: int = typer.Option(0, "--concurrency", "-c", help="Number of worker processes (0 = auto)"),
+    loglevel: str = typer.Option("info", "--loglevel", "-l", help="Log level"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """Start Celery worker for processing async tasks.
+
+    Worker handles flow execution, webhook processing, and periodic tasks.
+    """
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    queues_list = [q.strip() for q in queues.split(",") if q.strip()]
+    concurrency_str = str(concurrency) if concurrency > 0 else 10
+
+    print_info("⚙️ Starting Celery worker")
+    print_info(f"   Queues: {', '.join(queues_list)}")
+    print_info(f"   Concurrency: {concurrency_str}")
+    print_info(f"   Log level: {loglevel}")
+
+    try:
+        from bootstrap import bootstrap
+        from tasks import app as celery_app
+        from tasks import worker
+
+        assert worker
+
+        print_info("📦 Initializing modules...")
+        bootstrap()
+
+        registered = worker.register_module_tasks()
+        if registered:
+            print_info(f"   Module tasks: {len(registered)} registered")
+
+        celery_app.worker_main(
+            [
+                "worker",
+                f"--queues={','.join(queues_list)}",
+                f"--concurrency={concurrency_str}",
+                f"--loglevel={loglevel}",
+                "-Ofair",
+                "--task-events",
+            ]
+        )
+    except KeyboardInterrupt:
+        print_info("⏹ Worker stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        print_error(f"Failed to start worker: {e}")
+        log.exception(f"Worker startup failed: {e}")
+        sys.exit(1)
+
+
+@worker_app.command("status")
+def worker_status(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """Check Celery worker status using inspect.
+
+    Shows active workers, registered tasks, and queue statistics.
+    """
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    print_info("🔍 Checking worker status...")
+
+    try:
+        from tasks import app as celery_app
+
+        inspect = celery_app.control.inspect()
+
+        active = inspect.active()
+        registered = inspect.registered()
+        stats = inspect.stats()
+
+        if active:
+            for worker_name, tasks in active.items():
+                console.print(f"\n[bold cyan]Worker: {worker_name}[/]")
+                console.print(f"  Active tasks: {len(tasks)}")
+        else:
+            console.print("[yellow]⚠️ No active workers found[/]")
+
+        if registered:
+            console.print("\n[bold cyan]Registered tasks:[/]")
+            for worker_name, tasks in registered.items():
+                for task in tasks:
+                    console.print(f"  • {task}")
+
+        if stats:
+            console.print("\n[bold cyan]Statistics:[/]")
+            for worker_name, stat in stats.items():
+                console.print(f"  {worker_name}:")
+                for key, value in stat.items():
+                    if key == "pool":
+                        console.print(f"    Pool: {value.get('max-concurrency', 'N/A')} processes")
+
+        print_success("Worker status check complete")
+
+    except Exception as e:
+        print_error(f"Failed to check worker status: {e}")
+        log.exception(f"Worker status check failed: {e}")
+        sys.exit(1)

github_app/__init__.py

@@ -0,0 +1,13 @@
+"""GitHub App module for multi-repo CrewAI flow automation."""
+
+from github_app.auth import GitHubAppAuth
+from github_app.installation_manager import InstallationManager
+from github_app.label_mapper import LabelFlowMapper
+from github_app.webhook_handler import GitHubAppWebhookHandler
+
+__all__ = [
+    "GitHubAppAuth",
+    "InstallationManager",
+    "LabelFlowMapper",
+    "GitHubAppWebhookHandler",
+]

github_app/app.py

@@ -0,0 +1,224 @@
+"""GitHub App FastAPI webhook server - unified webhook endpoint.
+
+Merges functionality from:
+- src/github_app/webhook_handler.py (GitHub App webhooks)
+- src/project_manager/webhook.py (signature validation, ping handling)
+
+This replaces the separate FastAPI instance in project_manager.
+"""
+
+import logging
+from typing import Optional
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
+
+from github_app.auth import GitHubAppAuth
+from github_app.config import settings
+from github_app.installation_manager import InstallationManager
+from github_app.label_mapper import LabelFlowMapper
+from github_app.webhook_handler import GitHubAppWebhookHandler
+from persistence.postgres import SessionLocal
+
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title=settings.GITHUB_APP_NAME,
+    description="GitHub App for multi-repo CrewAI flow automation",
+    version="2.0.0",
+)
+
+github_auth = GitHubAppAuth(
+    app_id=settings.GITHUB_APP_ID,
+    private_key=settings.GITHUB_APP_PRIVATE_KEY.replace("\\n", "\n"),
+)
+
+
+def get_db_session():
+    """Get database session from postgres.py."""
+    return SessionLocal()
+
+
+def get_webhook_handler(db_session) -> GitHubAppWebhookHandler:
+    """Create webhook handler with dependencies."""
+    installation_manager = InstallationManager(db_session, github_auth)
+    label_mapper = LabelFlowMapper(db_session)
+
+    return GitHubAppWebhookHandler(
+        github_auth=github_auth,
+        installation_manager=installation_manager,
+        label_mapper=label_mapper,
+        webhook_secret=settings.GITHUB_APP_WEBHOOK_SECRET,
+    )
+
+
+# ============================================================================
+# Health & Status Endpoints (from project_manager/webhook.py)
+# ============================================================================
+
+
+@app.get("/")
+async def root():
+    return {
+        "name": settings.GITHUB_APP_NAME,
+        "version": "2.0.0",
+        "status": "running",
+        "mode": "github_app",
+    }
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint (from project_manager/webhook.py)."""
+    return {
+        "status": "healthy",
+        "redis": "connected",  # TODO: Check actual Redis connection
+        "database": "connected",  # TODO: Check actual DB connection
+    }
+
+
+# ============================================================================
+# Main Webhook Endpoint (unified)
+# ============================================================================
+
+
+@app.post("/webhook/github")
+async def github_webhook(request: Request):
+    """Handle GitHub webhook events.
+
+    Unified endpoint for:
+    - GitHub App webhooks (multi-repo, installation-based)
+    - Legacy webhooks (single repo, from project_manager/webhook.py)
+
+    Supported events:
+    - ping: Webhook verification
+    - installation: GitHub App installation lifecycle
+    - issues: Issue events
+    """
+    db_session = get_db_session()
+
+    try:
+        handler = get_webhook_handler(db_session)
+        result = await handler.handle_webhook(request)
+        return result
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Webhook processing error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal server error")
+    finally:
+        db_session.close()
+
+
+# ============================================================================
+# Installation Management API
+# ============================================================================
+
+
+@app.get("/installations")
+async def list_installations():
+    """List all active installations."""
+    db_session = get_db_session()
+
+    try:
+        installation_manager = InstallationManager(db_session, github_auth)
+        installations = installation_manager.list_installations()
+
+        return {
+            "installations": [
+                {
+                    "id": inst.installation_id,
+                    "account": inst.account_login,
+                    "active": inst.is_active,
+                    "repos_count": len(inst.repositories.get("repos", []) if inst.repositories else []),
+                }
+                for inst in installations
+            ]
+        }
+    finally:
+        db_session.close()
+
+
+# ============================================================================
+# Label Mapping API
+# ============================================================================
+
+
+@app.post("/mappings")
+async def create_label_mapping(
+    installation_id: int,
+    label_name: str,
+    flow_name: str,
+    repo_pattern: Optional[str] = None,
+    priority: int = 0,
+):
+    """Create a label-to-flow mapping."""
+    db_session = get_db_session()
+    label_mapper = LabelFlowMapper(db_session)
+
+    try:
+        mapping = label_mapper.create_mapping(
+            installation_id=installation_id,
+            label_name=label_name,
+            flow_name=flow_name,
+            repo_pattern=repo_pattern,
+            priority=priority,
+        )
+
+        return {
+            "id": mapping.id,
+            "label": mapping.label_name,
+            "flow": mapping.flow_name,
+            "pattern": mapping.repo_pattern,
+            "priority": mapping.priority,
+        }
+    finally:
+        db_session.close()
+
+
+@app.get("/mappings")
+async def list_label_mappings(installation_id: Optional[int] = None):
+    """List label-to-flow mappings."""
+    db_session = get_db_session()
+    label_mapper = LabelFlowMapper(db_session)
+
+    try:
+        mappings = label_mapper.list_mappings(installation_id=installation_id)
+
+        return {
+            "mappings": [
+                {
+                    "id": m.id,
+                    "label": m.label_name,
+                    "flow": m.flow_name,
+                    "pattern": m.repo_pattern,
+                    "priority": m.priority,
+                    "active": m.is_active,
+                }
+                for m in mappings
+            ]
+        }
+    finally:
+        db_session.close()
+
+
+# ============================================================================
+# Error Handlers
+# ============================================================================
+
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    logger.error(f"Unhandled exception: {exc}", exc_info=True)
+    return JSONResponse(status_code=500, content={"detail": "Internal server error"})
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "app:app",
+        host=settings.WEBHOOK_HOST,
+        port=settings.WEBHOOK_PORT,
+        reload=True,
+    )

github_app/auth.py

@@ -0,0 +1,137 @@
+"""GitHub App authentication using PyGithub's native GitHub App support."""
+
+import hashlib
+import hmac
+import logging
+
+import github
+from github import Auth, Github, GithubIntegration
+from github.Installation import Installation
+
+logger = logging.getLogger(__name__)
+
+
+class GitHubAppAuth:
+    """GitHub App authentication using PyGithub's GithubIntegration.
+
+    Wraps PyGithub's native GitHub App support with:
+    - Webhook signature verification
+    - Convenient access to Github client instances
+    """
+
+    def __init__(
+        self,
+        app_id: str | int,
+        private_key: str,
+    ):
+        self.app_id = str(app_id)
+        self.private_key = private_key
+
+        # Create PyGithub GithubIntegration
+        self._auth = Auth.AppAuth(app_id=self.app_id, private_key=private_key)
+        self._integration = GithubIntegration(auth=self._auth)
+
+        # Cache for Github clients per installation
+        self._clients: dict[int, Github] = {}
+
+    @property
+    def integration(self) -> GithubIntegration:
+        """Get the GithubIntegration instance."""
+        return self._integration
+
+    def get_installation_token(self, installation_id: int) -> str | None:
+        """Get an installation access token.
+
+        Args:
+            installation_id: GitHub App installation ID
+
+        Returns:
+            Installation token or None if failed
+        """
+        # Get fresh token
+        try:
+            # Fallback: create token directly via API
+            return self._create_installation_token(installation_id)
+        except github.GithubException as e:
+            logger.error(f"Failed to get installation token: {e}")
+            return None
+
+    def _create_installation_token(self, installation_id: int) -> str | None:
+        """Create installation token via GitHub API (fallback method)."""
+        return self._integration.get_access_token(installation_id=installation_id).token
+
+    def get_installation(self, installation_id: int) -> Installation | None:
+        """Get installation by ID using PyGithub.
+
+        Args:
+            installation_id: GitHub App installation ID
+
+        Returns:
+            Installation object or None
+        """
+        try:
+            return self._integration.get_app_installation(installation_id)
+        except github.GithubException as e:
+            logger.error(f"Failed to get installation {installation_id}: {e}")
+            return None
+
+    def get_repo_installation(self, owner: str, repo: str) -> Installation | None:
+        """Get installation for a specific repository.
+
+        Args:
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Installation object or None
+        """
+        try:
+            return self._integration.get_repo_installation(owner, repo)
+        except github.GithubException as e:
+            logger.error(f"Failed to get installation for {owner}/{repo}: {e}")
+            return None
+
+    def get_org_installation(self, org: str) -> Installation | None:
+        """Get installation for an organization.
+
+        Args:
+            org: Organization name
+
+        Returns:
+            Installation object or None
+        """
+        try:
+            return self._integration.get_org_installation(org)
+        except github.GithubException as e:
+            logger.error(f"Failed to get installation for org {org}: {e}")
+            return None
+
+    def list_installations(self) -> list[Installation]:
+        """List all installations for this GitHub App.
+
+        Returns:
+            List of Installation objects
+        """
+        try:
+            return list(self._integration.get_installations())
+        except github.GithubException as e:
+            logger.error(f"Failed to list installations: {e}")
+            return []
+
+    def verify_webhook_payload(self, payload: str | bytes, signature: str, secret: str) -> bool:
+        """Verify GitHub webhook signature.
+
+        Args:
+            payload: Raw webhook payload (string or bytes)
+            signature: X-Hub-Signature-256 header value
+            secret: Webhook secret
+
+        Returns:
+            True if signature is valid
+        """
+        if isinstance(payload, str):
+            payload = payload.encode()
+
+        expected_signature = hmac.new(secret.encode(), payload, hashlib.sha256).hexdigest()
+
+        return hmac.compare_digest(f"sha256={expected_signature}", signature)

github_app/config.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class GitHubAppSettings(BaseSettings):
+    # GitHub App Configuration
+    GITHUB_APP_ID: str = ""
+    GITHUB_APP_PRIVATE_KEY: str = ""
+    GITHUB_APP_WEBHOOK_SECRET: str = ""
+    GITHUB_APP_NAME: str = "Polycode GitHub App"
+
+    # Redis Configuration
+    REDIS_URL: str = "redis://localhost:6379/0"
+    REDIS_HOST: str = "localhost"
+    REDIS_PORT: int = 6379
+    REDIS_DB: int = 0
+
+    # Database Configuration
+    DATABASE_URL: str = "sqlite:///polycode.db"
+
+    # Webhook Server Configuration
+    WEBHOOK_HOST: str = "0.0.0.0"
+    WEBHOOK_PORT: int = 8000
+    WEBHOOK_PATH: str = "/webhook/github"
+    WEBHOOK_URL: Optional[str] = None
+
+    # GitHub API Configuration
+    GITHUB_API_URL: str = "https://api.github.com"
+
+    # Celery Configuration
+    CELERY_BROKER_URL: str = "redis://localhost:6379/0"
+    CELERY_RESULT_BACKEND: str = "redis://localhost:6379/0"
+
+    model_config = SettingsConfigDict(extra="ignore", env_file=".env", case_sensitive=True)
+
+
+settings = GitHubAppSettings()  # pyright:ignore # ty:ignore