polycoding 0.1.0__py3-none-any.whl

project_manager/github_projects_client.py

@@ -0,0 +1,329 @@
+"""GitHub Projects V2 GraphQL API client with full type annotations.
+
+Moved from github_issues/github_project.py as part of refactoring.
+"""
+
+import logging
+
+import httpx
+from pydantic import BaseModel
+
+log = logging.getLogger(__name__)
+
+
+class GraphQLResponse(BaseModel):
+    """Generic GraphQL response structure."""
+
+    data: dict
+
+
+class StatusFieldOption(BaseModel):
+    """Status option with ID and name."""
+
+    id: str
+    name: str
+
+
+class StatusFieldData(BaseModel):
+    """Status field with ID and options."""
+
+    id: str
+    options: list[StatusFieldOption]
+
+
+class ProjectItemContent(BaseModel):
+    """Issue content in a project item."""
+
+    number: int
+    title: str
+    body: str | None
+
+
+class ProjectItemStatus(BaseModel):
+    """Status field value for a project item."""
+
+    name: str
+
+
+class ProjectItem(BaseModel):
+    """Item in a GitHub project."""
+
+    project_item_id: str
+    issue_number: int
+    title: str
+    body: str | None
+    status: str | None
+
+    class Config:
+        """Pydantic config for field aliases."""
+
+        populate_by_name = True
+
+
+class GitHubProjectsClient:
+    """Client for GitHub Projects V2 GraphQL API."""
+
+    def __init__(self, token: str, repo_name: str) -> None:
+        """Initialize the GitHub Projects client.
+
+        Args:
+            token: GitHub personal access token.
+            repo_name: Name of the repository.
+        """
+        self.repo_name = repo_name
+        self.token = token
+        self.headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
+        self.endpoint = "https://api.github.com/graphql"
+
+    def _query(self, query: str, variables: dict | None = None) -> GraphQLResponse:
+        """Execute a GraphQL query.
+
+        Args:
+            query: GraphQL query string.
+            variables: Optional variables for the query.
+
+        Returns:
+            GraphQL response with data.
+
+        Raises:
+            httpx.HTTPStatusError: If the request fails.
+        """
+        with httpx.Client() as client:
+            response = client.post(
+                self.endpoint,
+                headers=self.headers,
+                json={"query": query, "variables": variables or {}},
+                timeout=30,
+            )
+            response.raise_for_status()
+            return GraphQLResponse(**response.json())
+
+    def get_project_id(self, owner: str, project_number: int | None = None) -> str:
+        """Get the global ID for a project.
+        Args:
+            owner: Repository owner.
+            project_number: Project number. If None, returns the first project found.
+        Returns:
+            Global ID of the project.
+        """
+        project_id: str | None = None
+        if project_number is not None:
+            query = (
+                """
+            query($owner: String!, $projectNumber: Int!) {
+                repository(owner: $owner, name: "%s") {
+                    projectV2(number: $projectNumber) {
+                        id
+                    }
+                }
+            }
+            """
+                % self.repo_name
+            )
+            result = self._query(query, {"owner": owner, "projectNumber": project_number})
+            node = result.data["repository"].get("projectV2")
+            if node is not None:
+                project_id = node["id"]
+
+        if project_id is None:
+            # Try as organization first, then fall back to user
+            query = """
+            query($owner: String!) {
+                organization(login: $owner) {
+                    projectsV2(first: 1) {
+                        nodes {
+                            id
+                        }
+                    }
+                }
+            }
+            """
+            result = self._query(query, {"owner": owner})
+            if result.data.get("organization", {}):
+                nodes = result.data.get("organization", {}).get("projectsV2", {}).get("nodes")
+                if nodes:
+                    project_id = nodes[0]["id"]
+
+        if project_id is None:
+            # Fall back to user
+            query = """
+            query($owner: String!) {
+                user(login: $owner) {
+                    projectsV2(first: 1) {
+                        nodes {
+                            id
+                        }
+                    }
+                }
+            }
+            """
+            result = self._query(query, {"owner": owner})
+            if result.data.get("user", {}):
+                nodes = result.data.get("user", {}).get("projectsV2", {}).get("nodes")
+                if nodes:
+                    project_id = nodes[0]["id"]
+
+        if project_id is None:
+            raise ValueError("No projects found for this owner!")
+
+        return project_id
+
+    def get_project_items(self, project_id: str) -> list[ProjectItem]:
+        """Get all items in a project with their status.
+
+        Args:
+            project_id: Global ID of the project.
+
+        Returns:
+            List of project items with issue data and status.
+        """
+        query = """
+        query($projectId: ID!, $cursor: String) {
+            node(id: $projectId) {
+                ... on ProjectV2 {
+                    items(first: 100, after: $cursor) {
+                        pageInfo {
+                            hasNextPage
+                            endCursor
+                        }
+                        nodes {
+                            id
+                            content {
+                                ... on Issue {
+                                    number
+                                    title
+                                    body
+                                }
+                            }
+                            fieldValueByName(name: "Status") {
+                                ... on ProjectV2ItemFieldSingleSelectValue {
+                                    name
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        """
+        items: list[ProjectItem] = []
+        cursor: str | None = None
+        while True:
+            result = self._query(query, {"projectId": project_id, "cursor": cursor})
+            data = result.data["node"]["items"]
+            for node in data["nodes"]:
+                content = node.get("content")
+                if content:
+                    status_field = node.get("fieldValueByName")
+                    items.append(
+                        ProjectItem(
+                            project_item_id=node["id"],
+                            issue_number=content["number"],
+                            title=content["title"],
+                            body=content["body"],
+                            status=status_field["name"] if status_field else None,
+                        )
+                    )
+            if not data["pageInfo"]["hasNextPage"]:
+                break
+            cursor = data["pageInfo"]["endCursor"]
+        return items
+
+    def add_issue_to_project(self, project_id: str, issue_node_id: str) -> str | None:
+        """Add an issue to a project.
+
+        Args:
+            project_id: Global ID of the project.
+            issue_node_id: Global ID of the issue to add.
+
+        Returns:
+            Project item ID if successful, None otherwise.
+        """
+        query = """
+        mutation($projectId: ID!, $contentId: ID!) {
+            addProjectV2ItemById(input: {projectId: $projectId, contentId: $contentId}) {
+                item {
+                    id
+                }
+            }
+        }
+        """
+        result = self._query(query, {"projectId": project_id, "contentId": issue_node_id})
+        return result.data["addProjectV2ItemById"]["item"]["id"]
+
+    def get_status_field_id(self, project_id: str) -> tuple[str, dict[str, str]]:
+        """Get the ID and options of the Status field in a project.
+
+        Args:
+            project_id: Global ID of the project.
+
+        Returns:
+            Tuple of (field_id, dict mapping status names to option IDs).
+        """
+        query = """
+        query($projectId: ID!) {
+            node(id: $projectId) {
+                ... on ProjectV2 {
+                    field(name: "Status") {
+                        ... on ProjectV2SingleSelectField {
+                            id
+                            options {
+                                id
+                                name
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        """
+        result = self._query(query, {"projectId": project_id})
+        field = result.data["node"]["field"]
+        options = {opt["name"]: opt["id"] for opt in field["options"]}
+        return field["id"], options
+
+    def update_item_status(
+        self,
+        project_id: str,
+        item_id: str,
+        field_id: str,
+        option_id: str,
+    ) -> bool:
+        """Update the status of a project item.
+
+        Args:
+            project_id: Global ID of the project.
+            item_id: ID of the project item.
+            field_id: ID of the status field.
+            option_id: ID of the status option to set.
+
+        Returns:
+            True if successful, False otherwise.
+        """
+        query = """
+        mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+            updateProjectV2ItemFieldValue(input: {
+                projectId: $projectId,
+                itemId: $itemId,
+                fieldId: $fieldId,
+                value: { singleSelectOptionId: $optionId }
+            }) {
+                projectV2Item {
+                    id
+                }
+            }
+        }
+        """
+        result = self._query(
+            query,
+            {
+                "projectId": project_id,
+                "itemId": item_id,
+                "fieldId": field_id,
+                "optionId": option_id,
+            },
+        )
+        return "updateProjectV2ItemFieldValue" in result.data

project_manager/hooks.py

@@ -0,0 +1,377 @@
+"""Hook implementations for project management operations.
+
+This module contains hook implementations that handle GitHub-specific
+operations like PR creation, merging, and issue management.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any, Callable
+
+from modules.hooks import FlowEvent, hookimpl
+from project_manager import IssueStatus
+
+if TYPE_CHECKING:
+    from project_manager.base import ProjectManager
+    from project_manager.types import ProjectConfig
+
+log = logging.getLogger(__name__)
+
+
+class ProjectManagerHooks:
+    """Hook implementations for GitHub project management.
+
+    This class handles all GitHub-specific operations triggered by flow orchestration events.
+    It creates PRs, handles merges, posts comments, and updates issue status.
+    """
+
+    def __init__(
+        self,
+        project_manager_factory: Callable[["ProjectConfig"], "ProjectManager"],
+    ):
+        """Initialize hooks with a factory function.
+
+        Args:
+            project_manager_factory: Callable that creates a ProjectManager from ProjectConfig
+        """
+        self._pm_factory = project_manager_factory
+
+    def _get_pm(self, config: "ProjectConfig") -> "ProjectManager":
+        """Get project manager instance for the given config."""
+        return self._pm_factory(config)
+
+    @hookimpl
+    def on_flow_event(
+        self,
+        event: FlowEvent,
+        flow_id: str,
+        state: Any,
+        result: Any | None = None,
+        label: str = "",
+    ) -> None:
+        """Handle flow orchestration events for project management operations.
+
+        This is the main hook that dispatches to specific handlers based on event type.
+
+        Args:
+            event: Current flow event
+            flow_id: Unique flow identifier
+            state: Flow state model (mutable)
+            result: Event-specific result (e.g., commit sha, pr url)
+            label: Context label (e.g., "plan", "implement", "review")
+        """
+        log.info(f"🎣 Hook called in {__name__}")
+        if not hasattr(state, "project_config") or not state.project_config:
+            log.debug("No project_config in state, skipping project manager hooks")
+            return
+
+        pm = self._get_pm(state.project_config)
+
+        if event == FlowEvent.FLOW_STARTED:
+            self._handle_flow_started(state, pm)
+        elif event == FlowEvent.STORIES_PLANNED:
+            self._handle_planning_comment(state, pm)
+        elif event == FlowEvent.STORY_COMPLETED:
+            self._handle_story_completed(state, pm, result)
+        elif event == FlowEvent.FLOW_FINISHED:
+            self._handle_flow_finished(state, pm)
+
+    def _handle_review_start(self, state: Any, pm: "ProjectManager") -> None:
+        """Update issue status to 'In review' when review phase starts.
+
+        Args:
+            state: Flow state
+            pm: Project manager instance
+        """
+        issue_id = getattr(state, "issue_id", 0)
+        if not issue_id:
+            return
+
+        try:
+            pm.update_issue_status(issue_id, "In review")
+            log.info(f"🏹 Updated issue #{issue_id} status to In review")
+        except Exception as e:
+            log.warning(f"🚨 Failed to update project status to In review: {e}")
+
+    def _handle_create_pr(self, state: Any, pm: "ProjectManager") -> None:
+        """Create pull request.
+
+        Args:
+            state: Flow state (mutated with pr_number, pr_url)
+            pm: Project manager instance
+        """
+        if getattr(state, "pr_number", None):
+            log.info("PR already exists, skipping creation")
+            return
+
+        branch = getattr(state, "branch", "")
+        if not branch:
+            log.warning("No branch in state, cannot create PR")
+            return
+
+        title = getattr(state, "commit_title", None) or getattr(state, "task", "")
+        body = f"{getattr(state, 'commit_message', '') or ''}\n\n{getattr(state, 'commit_footer', '') or ''}"
+        base_branch = "develop"
+
+        result = pm.create_pull_request(
+            title=title,
+            body=body.strip(),
+            head=branch,
+            base=base_branch,
+        )
+
+        if not result:
+            log.warning("Failed to create PR")
+            return
+
+        state.pr_number, state.pr_url = result
+        log.info(f"🏹 PR {state.pr_number} created: {state.pr_url}")
+
+        issue_id = getattr(state, "issue_id", 0)
+        if issue_id:
+            pm.add_comment(
+                issue_id,
+                f"## 🔍 Review Started\n\n"
+                f"Pull request #{state.pr_number} is now under review.\n"
+                f"[View PR]({state.pr_url})",
+            )
+
+    def _handle_merge(self, state: Any, pm: "ProjectManager") -> None:
+        """Handle PR merge with label check.
+
+        Args:
+            state: Flow state
+            pm: Project manager instance
+        """
+        from project_manager.config import settings as project_settings
+
+        pr_number = getattr(state, "pr_number", None)
+        issue_id = getattr(state, "issue_id", 0)
+
+        if not pr_number:
+            log.warning("No PR number set, skipping merge")
+            return
+
+        required_label = project_settings.MERGE_REQUIRED_LABEL
+
+        if not pm.has_label(issue_id, required_label):
+            log.warning(f"⚠️ Issue #{issue_id} does not have required label '{required_label}'. Merge aborted.")
+            pm.add_comment(
+                issue_id,
+                f"## ⚠️ Merge Blocked\n\n"
+                f"Pull request #{pr_number} cannot be merged. "
+                f"Issue {issue_id} does not have the required label: `{required_label}`.\n\n"
+                f"Please add the label and try again.",
+            )
+            return
+
+        log.info(f"✅ PR #{pr_number} has required label '{required_label}', proceeding with merge")
+
+        success = pm.merge_pull_request(pr_number)
+
+        if success:
+            pr_url = getattr(state, "pr_url", "")
+            pm.add_comment(
+                issue_id,
+                f"## ✅ Task Completed\n\nPull request #{pr_number} has been merged.\n[View merged PR]({pr_url})",
+            )
+
+    def _handle_cleanup(self, state: Any, pm: "ProjectManager") -> None:
+        """Update issue status after cleanup.
+
+        Args:
+            state: Flow state
+            pm: Project manager instance
+        """
+        issue_id = getattr(state, "issue_id", 0)
+        if not issue_id:
+            return
+
+        try:
+            pm.update_issue_status(issue_id, "Done")
+            log.info(f"🏹 Updated issue #{issue_id} status to Done")
+        except Exception as e:
+            log.info(f"🚨 Failed to update project status to Done: {e}")
+
+    def _handle_planning_comment(self, state: Any, pm: "ProjectManager") -> None:
+        """Post planning checklist to issue.
+
+        Args:
+            state: Flow state (mutated with planning_comment_id)
+            pm: Project manager instance
+            stories: List of stories from planning phase
+        """
+        if getattr(state, "planning_comment_id"):
+            log.debug("Already have a reference comment id for planning")
+            return
+
+        stories = getattr(state, "stories", None)
+        if not stories:
+            log.debug("No stories to post in planning checklist")
+            return
+
+        issue_id = getattr(state, "issue_id", 0)
+        if not issue_id:
+            return
+
+        checklist_items = "\n".join(f"- [ ] {getattr(story, 'description', str(story))}" for story in stories)
+        comment = (
+            f"## 📋 Implementation Plan\n\n{checklist_items}\n\n_Progress will be updated as stories are implemented._"
+        )
+        pm.add_comment(issue_id, comment)
+
+        comment_id = pm.get_last_comment_by_user(issue_id, pm.bot_username)
+        if comment_id:
+            state.planning_comment_id = comment_id
+            log.info(f"🏹 Posted planning checklist, comment ID: {comment_id}")
+
+    def _handle_update_checklist(self, state: Any, pm: "ProjectManager", data: Any | None) -> None:
+        """Update planning checklist with progress.
+
+        Args:
+            state: Flow state
+            pm: Project manager instance
+            data: Tuple of (stories, completed_story_ids, pr_url, merged) or dict
+        """
+        planning_comment_id = getattr(state, "planning_comment_id", None)
+        if not planning_comment_id:
+            log.warning("No planning comment ID, cannot update checklist")
+            return
+
+        issue_id = getattr(state, "issue_id", 0)
+        if not issue_id:
+            return
+
+        if data is None:
+            return
+
+        if isinstance(data, dict):
+            stories = data.get("stories", [])
+            completed_ids = data.get("completed_ids", [])
+            pr_url = data.get("pr_url")
+            merged = data.get("merged", False)
+        elif isinstance(data, tuple) and len(data) >= 2:
+            stories, completed_ids = data[0], data[1]
+            pr_url = data[2] if len(data) > 2 else None
+            merged = data[3] if len(data) > 3 else False
+        else:
+            return
+
+        commit_urls = getattr(state, "commit_urls", {})
+        pr_number = getattr(state, "pr_number")
+
+        checklist_lines = []
+        for story in stories:
+            story_id = getattr(story, "id", None)
+            story_desc = getattr(story, "description", str(story))
+
+            if story_id in completed_ids:
+                commit_url = commit_urls.get(story_id)
+                if commit_url:
+                    checklist_lines.append(f"- [x] {story_desc} ([commit]({commit_url}))")
+                else:
+                    checklist_lines.append(f"- [x] {story_desc}")
+            else:
+                checklist_lines.append(f"- [ ] {story_desc}")
+
+        body = "## 📋 Implementation Plan\n\n" + "\n".join(checklist_lines)
+
+        if pr_url:
+            if merged:
+                body += f"\n\n---\n\n✅ **Merged** - [PR #{pr_number}]({pr_url})"
+            else:
+                body += f"\n\n---\n\n🔍 **Review in progress** - [PR #{pr_number}]({pr_url})"
+        else:
+            body += "\n\n_Progress will be updated as stories are implemented._"
+
+        pm.update_comment(issue_id, planning_comment_id, body)
+        log.info(f"🏹 Updated planning checklist for issue #{issue_id}")
+
+    def _handle_flow_started(self, state: Any, pm: "ProjectManager") -> None:
+        """Handle flow start - post initial planning checklist.
+
+        Args:
+            state: Flow state
+            pm: Project manager instance
+        """
+        issue_id = getattr(state, "issue_id", 0)
+        if not issue_id:
+            return
+
+        pm.update_issue_status(issue_id, pm.config.status_mapping.to_provider_status(IssueStatus.IN_PROGRESS))
+
+        log.info(f"🚀 Flow started for issue #{issue_id}")
+
+    def _handle_story_completed(self, state: Any, pm: "ProjectManager", story: Any) -> None:
+        """Handle story completion - update checklist item.
+
+        Args:
+            state: Flow state
+            pm: Project manager instance
+            story: Completed story object
+        """
+        issue_id = getattr(state, "issue_id", 0)
+        planning_comment_id = getattr(state, "planning_comment_id", None)
+
+        if not issue_id or not planning_comment_id:
+            self._handle_planning_comment(state, pm)
+
+        stories = getattr(state, "stories", [])
+        completed_ids = [s.id for s in stories if s.completed]
+
+        # Update checklist
+        self._handle_update_checklist(
+            state,
+            pm,
+            {
+                "stories": stories,
+                "completed_ids": completed_ids,
+                "pr_url": None,
+                "merged": False,
+            },
+        )
+
+        if story:
+            log.info(f"✅ Updated checklist for story: {story.title if hasattr(story, 'title') else 'unknown'}")
+        else:
+            log.info(f"✅ New checklist for all ({len(stories)})")
+
+    def _handle_flow_finished(self, state: Any, pm: "ProjectManager") -> None:
+        """Handle flow finish - create PR, merge, update final checklist, cleanup.
+
+        Args:
+            state: Flow state
+            pm: Project manager instance
+        """
+        issue_id = getattr(state, "issue_id", 0)
+        if not issue_id:
+            return
+
+        # Create PR
+        self._handle_create_pr(state, pm)
+
+        # Merge PR (if approved)
+        self._handle_merge(state, pm)
+
+        # Final checklist update with PR link
+        stories = getattr(state, "stories", [])
+        completed_ids = [s.id for s in stories if s.completed]
+        pr_url = getattr(state, "pr_url", None)
+
+        if pr_url:
+            self._handle_update_checklist(
+                state,
+                pm,
+                {
+                    "stories": stories,
+                    "completed_ids": completed_ids,
+                    "pr_url": pr_url,
+                    "merged": True,
+                },
+            )
+
+        # Update issue status to Done
+        self._handle_cleanup(state, pm)
+
+        pm.update_issue_status(issue_id, pm.config.status_mapping.to_provider_status(IssueStatus.DONE))
+
+        log.info(f"🏁 Flow finished for issue #{issue_id}")