polycoding 0.1.0__py3-none-any.whl

github_app/installation_manager.py

@@ -0,0 +1,194 @@
+"""GitHub App installation manager - manages installations and tokens."""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from sqlalchemy.orm import Session
+
+from github_app.auth import GitHubAppAuth
+from github_app.models import GitHubAppInstallation, GitHubWebhookRegistration
+
+logger = logging.getLogger(__name__)
+
+
+class InstallationManager:
+    """Manages GitHub App installations and their lifecycle."""
+
+    def __init__(self, db_session: Session, github_auth: GitHubAppAuth):
+        self.db_session = db_session
+        self.github_auth = github_auth
+
+    def register_installation(self, installation_data: Dict[str, Any]) -> GitHubAppInstallation:
+        """Register or update a GitHub App installation."""
+        installation_id = installation_data["id"]
+
+        existing = (
+            self.db_session.query(GitHubAppInstallation)
+            .filter(GitHubAppInstallation.installation_id == installation_id)
+            .first()
+        )
+
+        if existing:
+            result = self.update_installation(installation_id, installation_data)
+            assert result is not None, "Update should succeed for existing installation"
+            return result
+
+        installation = GitHubAppInstallation(
+            installation_id=installation_id,
+            account_id=installation_data["account"]["id"],
+            account_login=installation_data["account"]["login"],
+            account_type=installation_data["account"]["type"],
+            app_id=installation_data["app_id"],
+            permissions=installation_data.get("permissions", {}),
+            events=installation_data.get("events", []),
+            repositories={},
+        )
+
+        print("=" * 80)
+        print(
+            dict(
+                installation_id=installation_id,
+                account_id=installation_data["account"]["id"],
+                account_login=installation_data["account"]["login"],
+                account_type=installation_data["account"]["type"],
+                app_id=installation_data["app_id"],
+                permissions=installation_data.get("permissions", {}),
+                events=installation_data.get("events", []),
+                reposiutories={},
+            )
+        )
+        print("=" * 80)
+        self.db_session.add(installation)
+        self.db_session.commit()
+
+        logger.info(f"Registered installation {installation_id} for {installation_data['account']['login']}")
+
+        return installation
+
+    def update_installation(
+        self,
+        installation_id: int,
+        installation_data: Optional[Dict[str, Any]] = None,
+    ) -> Optional[GitHubAppInstallation]:
+        """Update an existing installation."""
+        installation = (
+            self.db_session.query(GitHubAppInstallation)
+            .filter(GitHubAppInstallation.installation_id == installation_id)
+            .first()
+        )
+
+        if not installation:
+            return None
+
+        if installation_data:
+            installation.account_id = installation_data["account"]["id"]
+            installation.account_login = installation_data["account"]["login"]
+            installation.account_type = installation_data["account"]["type"]
+            installation.permissions = installation_data.get("permissions", {})
+            installation.events = installation_data.get("events", [])
+
+        self.db_session.commit()
+        logger.info(f"Updated installation {installation_id}")
+
+        return installation
+
+    def deactivate_installation(self, installation_id: int) -> bool:
+        """Deactivate an installation (e.g., when uninstalled from GitHub)."""
+        installation = (
+            self.db_session.query(GitHubAppInstallation)
+            .filter(GitHubAppInstallation.installation_id == installation_id)
+            .first()
+        )
+
+        if not installation:
+            return False
+
+        installation.is_active = False
+        self.db_session.commit()
+
+        logger.info(f"Deactivated installation {installation_id}")
+        return True
+
+    def get_installation(self, installation_id: int) -> Optional[GitHubAppInstallation]:
+        """Get an active installation by ID."""
+        return (
+            self.db_session.query(GitHubAppInstallation)
+            .filter(
+                GitHubAppInstallation.installation_id == installation_id,
+                GitHubAppInstallation.is_active.is_(True),
+            )
+            .first()
+        )
+
+    def list_installations(self, active_only: bool = True) -> List[GitHubAppInstallation]:
+        """List all installations."""
+        query = self.db_session.query(GitHubAppInstallation)
+
+        if active_only:
+            query = query.filter(GitHubAppInstallation.is_active.is_(True))
+
+        return query.all()
+
+    def get_installation_token(self, installation_id: int) -> Optional[str]:
+        """Get an installation access token."""
+        return self.github_auth.get_installation_token(installation_id)
+
+    def register_webhook(
+        self,
+        installation_id: int,
+        target_repo: str,
+        events: List[str],
+        secret: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+    ) -> GitHubWebhookRegistration:
+        """Register a webhook for a specific repository."""
+        webhook = GitHubWebhookRegistration(
+            installation_id=installation_id,
+            target_repo=target_repo,
+            events=events,
+            secret=secret,
+            webhook_url=webhook_url,
+            is_active=True,
+        )
+
+        self.db_session.add(webhook)
+        self.db_session.commit()
+
+        logger.info(f"Registered webhook for {target_repo} (installation: {installation_id})")
+
+        return webhook
+
+    def list_webhooks(
+        self,
+        installation_id: Optional[int] = None,
+        target_repo: Optional[str] = None,
+        active_only: bool = True,
+    ) -> List[GitHubWebhookRegistration]:
+        """List webhooks, optionally filtered."""
+        query = self.db_session.query(GitHubWebhookRegistration)
+
+        if installation_id:
+            query = query.filter(GitHubWebhookRegistration.installation_id == installation_id)
+
+        if target_repo:
+            query = query.filter(GitHubWebhookRegistration.target_repo == target_repo)
+
+        if active_only:
+            query = query.filter(GitHubWebhookRegistration.is_active.is_(True))
+
+        return query.all()
+
+    def deactivate_webhook(self, webhook_id: int) -> bool:
+        """Deactivate a webhook."""
+        webhook = (
+            self.db_session.query(GitHubWebhookRegistration).filter(GitHubWebhookRegistration.id == webhook_id).first()
+        )
+
+        if not webhook:
+            return False
+
+        webhook.is_active = False
+        self.db_session.commit()
+
+        logger.info(f"Deactivated webhook {webhook_id}")
+        return True

github_app/label_mapper.py

@@ -0,0 +1,112 @@
+import fnmatch
+import logging
+from typing import Any, Dict, Optional
+
+from sqlalchemy.orm import Session
+
+from github_app.models import LabelFlowMapping
+
+logger = logging.getLogger(__name__)
+
+
+class LabelFlowMapper:
+    def __init__(self, db_session: Session):
+        self.db_session = db_session
+
+    def get_flow_for_label(self, installation_id: int, label_name: str, repo_slug: str) -> Optional[LabelFlowMapping]:
+        mappings = (
+            self.db_session.query(LabelFlowMapping)
+            .filter(
+                LabelFlowMapping.installation_id == installation_id,
+                LabelFlowMapping.label_name == label_name,
+                LabelFlowMapping.is_active.is_(True),
+            )
+            .order_by(LabelFlowMapping.priority.desc())
+            .all()
+        )
+
+        for mapping in mappings:
+            pattern: Optional[str] = mapping.repo_pattern  # type: ignore
+            if self._matches_repo_pattern(pattern, repo_slug):
+                logger.info(
+                    f"Matched label '{label_name}' to flow '{mapping.flow_name}' "
+                    f"for repo '{repo_slug}' (installation: {installation_id})"
+                )
+                return mapping
+
+        logger.debug(
+            f"No flow mapping found for label '{label_name}' in repo '{repo_slug}' (installation: {installation_id})"
+        )
+        return None
+
+    def _matches_repo_pattern(self, pattern: Optional[str], repo_slug: str) -> bool:
+        if not pattern:
+            return True
+
+        return fnmatch.fnmatch(repo_slug, pattern)
+
+    def create_mapping(
+        self,
+        installation_id: int,
+        label_name: str,
+        flow_name: str,
+        repo_pattern: Optional[str] = None,
+        priority: int = 0,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> LabelFlowMapping:
+        """Create a new label-to-flow mapping."""
+        mapping = LabelFlowMapping(
+            installation_id=installation_id,
+            label_name=label_name,
+            flow_name=flow_name,
+            repo_pattern=repo_pattern,
+            priority=priority,
+            config=config or {},
+        )
+
+        self.db_session.add(mapping)
+        self.db_session.commit()
+
+        logger.info(
+            f"Created label-flow mapping: '{label_name}' -> '{flow_name}' "
+            f"(installation: {installation_id}, pattern: {repo_pattern})"
+        )
+
+        return mapping
+
+    def update_mapping(self, mapping_id: int, **kwargs) -> Optional[LabelFlowMapping]:
+        """Update an existing mapping."""
+        mapping = self.db_session.query(LabelFlowMapping).filter(LabelFlowMapping.id == mapping_id).first()
+
+        if not mapping:
+            return None
+
+        for key, value in kwargs.items():
+            if hasattr(mapping, key):
+                setattr(mapping, key, value)
+
+        self.db_session.commit()
+        logger.info(f"Updated label-flow mapping {mapping_id}")
+        return mapping
+
+    def delete_mapping(self, mapping_id: int) -> bool:
+        """Delete a label-to-flow mapping."""
+        mapping = self.db_session.query(LabelFlowMapping).filter(LabelFlowMapping.id == mapping_id).first()
+
+        if not mapping:
+            return False
+
+        self.db_session.delete(mapping)
+        self.db_session.commit()
+
+        logger.info(f"Deleted label-flow mapping {mapping_id}")
+        return True
+
+    def list_mappings(self, installation_id: Optional[int] = None) -> list[LabelFlowMapping]:
+        """List all label-to-flow mappings, optionally filtered by installation."""
+        query = self.db_session.query(LabelFlowMapping).filter(LabelFlowMapping.is_active.is_(True))
+
+        if installation_id:
+            query = query.filter(LabelFlowMapping.installation_id == installation_id)
+
+        return query.order_by(LabelFlowMapping.priority.desc()).all()

github_app/models.py

@@ -0,0 +1,112 @@
+"""GitHub App database models using shared PostgreSQL base."""
+
+from datetime import UTC, datetime
+from typing import Any, Optional
+
+from sqlalchemy import Index
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.types import Boolean, DateTime, Integer, String, Text
+
+from persistence.postgres import Base, JSONType
+
+now = lambda: datetime.now(UTC)
+
+
+class GitHubAppInstallation(Base):
+    """GitHub App installation tracking."""
+
+    __tablename__ = "github_app_installations"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    installation_id: Mapped[int] = mapped_column(Integer, unique=True, nullable=False, index=True)
+    account_id: Mapped[int] = mapped_column(Integer, nullable=False)
+    account_login: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    account_type: Mapped[str] = mapped_column(String(50), nullable=False)
+    app_id: Mapped[int] = mapped_column(Integer, nullable=False)
+    installation_token: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    token_expires_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    repositories: Mapped[Optional[dict[str, Any]]] = mapped_column(JSONType, nullable=True)
+    permissions: Mapped[Optional[dict[str, Any]]] = mapped_column(JSONType, nullable=True)
+    events: Mapped[Optional[list[str]]] = mapped_column(JSONType, nullable=True)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=now, nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        default=now,
+        onupdate=now,
+        nullable=False,
+    )
+
+
+class GitHubWebhookRegistration(Base):
+    """Webhook registration tracking per installation."""
+
+    __tablename__ = "github_webhook_registrations"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    webhook_id: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
+    installation_id: Mapped[int] = mapped_column(Integer, nullable=False, index=True)
+    target_repo: Mapped[str] = mapped_column(String(500), nullable=False, index=True)
+    events: Mapped[Optional[list[str]]] = mapped_column(JSONType, nullable=True)
+    secret: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    webhook_url: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=now, nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        default=now,
+        onupdate=now,
+        nullable=False,
+    )
+
+
+class LabelFlowMapping(Base):
+    """Maps GitHub labels to CrewAI flow names."""
+
+    __tablename__ = "label_flow_mappings"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    installation_id: Mapped[int] = mapped_column(Integer, nullable=False, index=True)
+    label_name: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    flow_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    repo_pattern: Mapped[Optional[str]] = mapped_column(String(500), nullable=True)
+    priority: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    config: Mapped[Optional[dict[str, Any]]] = mapped_column(JSONType, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=now, nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        default=now,
+        onupdate=now,
+        nullable=False,
+    )
+
+
+class FlowExecution(Base):
+    """Flow execution tracking per installation."""
+
+    __tablename__ = "flow_executions"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    installation_id: Mapped[int] = mapped_column(Integer, nullable=False, index=True)
+    repo_slug: Mapped[str] = mapped_column(String(500), nullable=False, index=True)
+    issue_number: Mapped[int] = mapped_column(Integer, nullable=False, index=True)
+    flow_name: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    trigger_label: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    status: Mapped[str] = mapped_column(String(50), default="pending", nullable=False, index=True)
+    started_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    completed_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    error_message: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    flow_metadata: Mapped[Optional[dict[str, Any]]] = mapped_column(JSONType, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=now, nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        default=now,
+        onupdate=now,
+        nullable=False,
+    )
+
+    __table_args__ = (
+        Index("idx_flow_executions_installation", "installation_id"),
+        Index("idx_flow_executions_status", "status"),
+    )

github_app/webhook_handler.py

@@ -0,0 +1,217 @@
+"""GitHub App webhook handler - integrates with FlowRunner and existing system."""
+
+import hashlib
+import hmac
+import json
+import logging
+from typing import Any, Dict, Optional
+
+from fastapi import HTTPException, Request
+
+from github_app.auth import GitHubAppAuth
+from github_app.installation_manager import InstallationManager
+from github_app.label_mapper import LabelFlowMapper
+from project_manager.flow_runner import FlowRunner
+from project_manager.github import GitHubProjectManager
+from project_manager.types import ProjectConfig, StatusMapping
+
+logger = logging.getLogger(__name__)
+
+
+class GitHubAppWebhookHandler:
+    """Handles GitHub webhooks for GitHub App installations.
+
+    Integrates with existing system:
+    - Uses FlowRunner for concurrent flow management
+    - Delegates to existing Celery tasks (process_github_webhook_task, kickoff_task)
+    - Triggers CrewAI flows (ralph, etc.)
+    - Works with existing GitHubProjectManager
+    """
+
+    def __init__(
+        self,
+        github_auth: GitHubAppAuth,
+        installation_manager: InstallationManager,
+        label_mapper: LabelFlowMapper,
+        webhook_secret: Optional[str] = None,
+    ):
+        self.github_auth = github_auth
+        self.installation_manager = installation_manager
+        self.label_mapper = label_mapper
+        self.webhook_secret = webhook_secret
+
+    def validate_signature(self, payload: bytes, signature: str) -> bool:
+        """Validate GitHub webhook signature (from project_manager/webhook.py)."""
+        if not self.webhook_secret:
+            logger.warning("No webhook secret configured, skipping signature validation")
+            return True
+
+        if not signature.startswith("sha256="):
+            logger.error("Invalid signature format")
+            return False
+
+        expected_signature = signature[7:]
+
+        mac = hmac.new(self.webhook_secret.encode(), msg=payload, digestmod=hashlib.sha256)
+        computed_signature = mac.hexdigest()
+
+        return hmac.compare_digest(computed_signature, expected_signature)
+
+    async def handle_webhook(self, request: Request) -> Dict[str, Any]:
+        """Main webhook entry point."""
+        payload_bytes = await request.body()
+        payload_str = payload_bytes.decode("utf-8")
+        payload = json.loads(payload_str)
+
+        event_type = request.headers.get("X-GitHub-Event")
+        signature = request.headers.get("X-Hub-Signature-256", "")
+        delivery_id = request.headers.get("X-GitHub-Delivery", "")
+
+        logger.info(f"Received webhook: {event_type} (delivery: {delivery_id})")
+
+        if event_type == "ping":
+            return self._handle_ping(payload)
+
+        installation_id = self._extract_installation_id(payload)
+        if not installation_id:
+            raise HTTPException(status_code=400, detail="Missing installation ID")
+
+        if self.webhook_secret and signature:
+            if not self.validate_signature(payload_bytes, signature):
+                raise HTTPException(status_code=401, detail="Invalid webhook signature")
+
+        if event_type == "installation":
+            return await self._handle_installation_event(payload)
+        elif event_type == "issues":
+            return await self._handle_issue_event(installation_id, payload)
+        else:
+            logger.info(f"Unhandled event type: {event_type}")
+            return {"status": "ignored", "event": event_type}
+
+    def _extract_installation_id(self, payload: Dict[str, Any]) -> Optional[int]:
+        """Extract installation ID from payload."""
+        if "installation" in payload:
+            return payload["installation"].get("id")
+        return None
+
+    def _handle_ping(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle ping event (from project_manager/webhook.py)."""
+        logger.info("Received ping from GitHub")
+        logger.info(f"  Zen: {payload.get('zen')}")
+
+        hook = payload.get("hook", {})
+        if hook:
+            events = hook.get("events", [])
+            logger.info(f"  Events: {events}")
+            logger.info(f"  URL: {hook.get('config', {}).get('url')}")
+
+        return {
+            "status": "pong",
+            "zen": payload.get("zen"),
+            "hook_id": payload.get("hook_id"),
+            "events": hook.get("events", []) if hook else [],
+        }
+
+    async def _handle_installation_event(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle installation lifecycle events."""
+        action = payload.get("action")
+        installation = payload.get("installation", {})
+
+        if action == "created":
+            self.installation_manager.register_installation(installation)
+            logger.info(f"Installation created: {installation.get('id')}")
+        elif action == "deleted":
+            installation_id = installation.get("id")
+            if installation_id:
+                self.installation_manager.deactivate_installation(installation_id)
+                logger.info(f"Installation deleted: {installation_id}")
+
+        return {"status": "processed", "action": action}
+
+    async def _handle_issue_event(self, installation_id: int, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle issue events - uses FlowRunner for concurrent flow management.
+
+        This method:
+        1. Gets installation token and creates per-repo GitHubProjectManager
+        2. Creates FlowRunner to check if flow is already running
+        3. Delegates to existing process_github_webhook_task if flow can start
+        """
+        action = payload.get("action")
+        issue = payload.get("issue", {})
+        repo = payload.get("repository", {})
+        repo_slug = repo.get("full_name")
+        issue_number = issue.get("number")
+
+        logger.info(f"Processing issue event: {action} on {repo_slug}#{issue_number} (installation: {installation_id})")
+
+        if action not in ["opened", "reopened", "labeled"]:
+            return {
+                "status": "ignored",
+                "reason": f"action '{action}' not handled",
+                "issue": issue_number,
+            }
+
+        # Get installation token
+        token = self.installation_manager.get_installation_token(installation_id)
+        if not token:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Failed to get installation token for {installation_id}",
+            )
+
+        # Create per-repo project manager and flow runner
+        try:
+            owner, name = repo_slug.split("/", 1)
+
+            config = ProjectConfig(
+                provider="github",
+                repo_owner=owner,
+                repo_name=name,
+                project_identifier=None,
+                token=token,
+                status_mapping=StatusMapping(),
+            )
+
+            manager = GitHubProjectManager(config)
+            flow_runner = FlowRunner(manager=manager)
+
+            # Check if flow is already running for this repo
+            if flow_runner.is_flow_running():
+                current = flow_runner.get_running_flow()
+                return {
+                    "status": "already_running",
+                    "message": (
+                        f"Flow already running for issue #{current.issue_number}" if current else "Flow already running"
+                    ),
+                    "repo": repo_slug,
+                    "issue": issue_number,
+                }
+
+        except Exception as e:
+            import traceback
+
+            traceback.print_exc()
+            logger.error(f"Failed to create project manager for {repo_slug}: {e}")
+            # Fall back to delegating without flow runner check
+            return await self._delegate_to_celery(payload, installation_id)
+
+        # Delegate to existing Celery task which handles all the logic
+        return await self._delegate_to_celery(payload, installation_id)
+
+    async def _delegate_to_celery(self, payload: Dict[str, Any], installation_id: int) -> Dict[str, Any]:
+        """Delegate to existing process_github_webhook_task."""
+        from tasks.tasks import process_github_webhook_task
+
+        # Add installation context to payload
+        payload["installation_id"] = installation_id
+
+        # Use existing webhook processing task
+        result = process_github_webhook_task.delay(payload)  # type: ignore
+
+        logger.info(f"Delegated to process_github_webhook_task: {result.id}")
+
+        return {
+            "status": "queued",
+            "task_id": result.id,
+            "installation_id": installation_id,
+        }

persistence/__init__.py

@@ -0,0 +1,5 @@
+"""Flow persistence implementations."""
+
+from .postgres import PostgresFlowPersistence
+
+__all__ = ["PostgresFlowPersistence"]

persistence/config.py

@@ -0,0 +1,12 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class PersistenceSettings(BaseSettings):
+
+    # Database Configuration
+    DATABASE_URL: str = "sqlite:///polycode.db"
+
+    model_config = SettingsConfigDict(extra="ignore", env_file=".env", case_sensitive=True)
+
+
+settings = PersistenceSettings()  # pyright:ignore