polycoding 0.1.0__py3-none-any.whl

project_manager/flow_runner.py

@@ -0,0 +1,160 @@
+"""Flow runner for managing issue processing."""
+
+import logging
+from typing import Callable
+
+from .base import ProjectManager
+from .types import IssueStatus, ProjectItem
+
+log = logging.getLogger(__name__)
+
+
+class FlowRunner:
+    """Manages flow execution using project manager as source of truth."""
+
+    def __init__(
+        self,
+        manager: ProjectManager,
+        on_issue_ready: Callable[[ProjectItem], None] | None = None,
+    ) -> None:
+        """Initialize flow runner.
+
+        Args:
+            manager: Project manager instance
+            on_issue_ready: Callback when an issue is ready to process
+        """
+        self.manager = manager
+        self.on_issue_ready = on_issue_ready
+
+    def is_flow_running(self) -> bool:
+        """Check if a flow is currently running.
+
+        Uses project manager as single source of truth - checks if any
+        item has "In Progress" status.
+
+        Returns:
+            True if a flow is running, False otherwise
+        """
+        if not self.manager.has_project:
+            return False  # No project configured = no flow running
+
+        items = self.manager.get_project_items()
+        in_progress_status = self.manager.config.status_mapping.to_provider_status(IssueStatus.IN_PROGRESS)
+
+        in_progress_items = [item for item in items if item.status == in_progress_status]
+        return len(in_progress_items) > 0
+
+    def get_running_flow(self) -> ProjectItem | None:
+        """Get the currently running flow.
+
+        Returns:
+            ProjectItem if a flow is running, None otherwise
+        """
+        if not self.manager.has_project:
+            return None  # No project = no running flow
+
+        items = self.manager.get_project_items()
+        in_progress_status = self.manager.config.status_mapping.to_provider_status(IssueStatus.IN_PROGRESS)
+
+        for item in items:
+            if item.status == in_progress_status:
+                return item
+
+        return None
+
+    def trigger_flow(self, issue_number: int | None = None) -> bool | str:
+        """Trigger a flow for an issue.
+
+        If issue_number is provided, processes that specific issue.
+        Otherwise, finds the next ready issue.
+
+        When Celery is available, returns task ID for async processing.
+        When Celery is not available, returns bool for sync processing.
+
+        Args:
+            issue_number: Optional specific issue to process
+            None for finding next ready issue
+
+        Returns:
+            True/task_id if flow was triggered, False if already running or no issue found
+        """
+        if not self.manager.has_project:
+            log.warning("trigger_flow called without project configuration")
+            return False
+
+        if self.is_flow_running():
+            current = self.get_running_flow()
+            if current:
+                log.info(f"Flow already running for issue #{current.issue_number}")
+                return False
+
+        if issue_number:
+            return self._process_specific_issue(issue_number)
+        else:
+            return self._process_next_ready_issue()
+
+    def _process_specific_issue(self, issue_number: int) -> bool | str:
+        """Process a specific issue.
+
+        Args:
+            issue_number: Issue number to process
+
+        Returns:
+            True/task_id if flow was triggered, False otherwise
+        """
+        item = self.manager.find_project_item(issue_number)
+        if not item:
+            log.warning(f"Issue #{issue_number} not found in project")
+            return False
+
+        ready_status = self.manager.config.status_mapping.to_provider_status(IssueStatus.READY)
+        in_progress_status = self.manager.config.status_mapping.to_provider_status(IssueStatus.IN_PROGRESS)
+
+        if item.status != ready_status:
+            log.info(f"Issue #{issue_number} not ready (status: {item.status}), skipping")
+            return False
+
+        success = self.manager.update_issue_status(issue_number, in_progress_status)
+        if not success:
+            log.error(f"Failed to move issue #{issue_number} to {in_progress_status}")
+            return False
+
+        log.info(f"Started flow for issue #{issue_number}: {item.title}")
+
+        try:
+            from tasks.tasks import kickoff_task
+
+            task_result = kickoff_task.apply_async(args=[self.manager.config.model_dump(), issue_number])  # type: ignore
+            log.info(f"Queued Celery task for issue #{issue_number}: {task_result.id}")
+            return task_result.id
+        except Exception as e:
+            log.error(f"Failed to queue Celery task: {e}")
+            log.warning("Falling back to synchronous processing")
+
+        if self.on_issue_ready:
+            try:
+                self.on_issue_ready(item)
+            except Exception as e:
+                log.error(f"Error processing issue #{issue_number}: {e}")
+                raise
+        else:
+            log.info(f"No callback configured for issue #{issue_number}")
+
+        return True
+
+    def _process_next_ready_issue(self) -> bool:
+        """Process the next ready issue.
+
+        Returns:
+            True if flow was triggered, False if no ready issues
+        """
+        items = self.manager.get_project_items()
+        ready_status = self.manager.config.status_mapping.to_provider_status(IssueStatus.READY)
+
+        ready_items = [item for item in items if item.status == ready_status]
+        if not ready_items:
+            log.info("No ready items to process")
+            return False
+
+        top_item = ready_items[0]
+        return bool(self._process_specific_issue(top_item.issue_number))

project_manager/git_utils.py

@@ -0,0 +1,30 @@
+"""Git utilities for GitHub operations.
+
+Moved from github_issues/utils.py as part of refactoring.
+"""
+
+import os
+import re
+
+import git
+import github
+
+
+def get_github_repo_from_local(local_path):
+    """Auto-detect GitHub repo from local git checkout."""
+    repo = git.Repo(local_path)
+    origin_url = repo.remotes.origin.url
+
+    # Parse owner/repo
+    url = origin_url.rstrip("/").removesuffix(".git")
+    match = re.search(r"[:/](.+)/(.+)", url)
+    if not match:
+        raise ValueError(f"Not a GitHub remote: {origin_url}")
+
+    owner, repo_name = match.group(1), match.group(2)
+
+    # Connect to GitHub
+    g = github.Github(auth=github.Auth.Token(os.environ["GITHUB_TOKEN"]))
+    github_repo = g.get_repo(f"{owner}/{repo_name}")
+
+    return repo, github_repo, g

project_manager/github.py

@@ -0,0 +1,367 @@
+"""GitHub-specific project manager implementation."""
+
+import logging
+from typing import cast
+
+import github
+from github.Repository import Repository
+
+from .base import ProjectManager
+from .config import settings
+from .github_projects_client import GitHubProjectsClient
+from .types import Issue, ProjectConfig, ProjectItem
+
+log = logging.getLogger(__name__)
+
+
+class GitHubProjectManager(ProjectManager):
+    """GitHub Projects V2 implementation of ProjectManager."""
+
+    github_client: github.Github
+    repo: Repository
+
+    def __repr__(self):
+        return f"ProjectManager(github, repo={self.repo.url})"
+
+    def __init__(self, config: ProjectConfig) -> None:
+        """Initialize GitHub project manager.
+
+        Args:
+            config: Project configuration
+
+        Raises:
+            ValueError: If token is not provided
+        """
+        super().__init__(config)
+
+        token = config.token or settings.GITHUB_TOKEN
+        if not token:
+            raise ValueError("GitHub token must be provided via config or GITHUB_TOKEN env var")
+
+        self.token = token
+        self.github_client = github.Github(auth=github.Auth.Token(token))
+        self.projects_client = GitHubProjectsClient(token, config.repo_name)
+        self.repo = self.github_client.get_repo(f"{self.config.repo_owner}/{self.config.repo_name}")
+        self._project_id: str | None = None
+        self._status_field_id: str | None = None
+        self._status_options: dict[str, str] | None = None
+        self._bot_username: str | None = None
+
+    @property
+    def has_project(self) -> bool:
+        """Check if project integration is enabled for this manager."""
+        return self.config.project_identifier is not None
+
+    @property
+    def bot_username(self) -> str:
+        """Get the authenticated bot username."""
+        if self._bot_username is None:
+            self._bot_username = self.github_client.get_user().login
+        return self._bot_username
+
+    def get_comments(self, issue_number: int) -> list:
+        """Get all comments for an issue.
+
+        Args:
+            issue_number: Issue number
+
+        Returns:
+            List of comments
+        """
+        try:
+            issue = self.repo.get_issue(issue_number)
+            return list(issue.get_comments())
+        except Exception as e:
+            log.error(f"Failed to get comments for issue #{issue_number}: {e}")
+            return []
+
+    def get_last_comment_by_user(self, issue_number: int, username: str) -> int | None:
+        """Get the last comment ID by a specific user.
+
+        Args:
+            issue_number: Issue number
+            username: GitHub username
+
+        Returns:
+            Comment ID if found, None otherwise
+        """
+        try:
+            comments = self.get_comments(issue_number)
+            for comment in reversed(comments):
+                if comment.user and comment.user.login == username:
+                    return comment.id
+            return None
+        except Exception as e:
+            log.error(f"Failed to get last comment by {username} on issue #{issue_number}: {e}")
+            return None
+
+    def update_comment(self, issue_number: int, comment_id: int, body: str) -> bool:
+        """Update an existing comment.
+
+        Args:
+            issue_number: Issue number
+            comment_id: Comment ID to update
+            body: New comment body
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            issue = self.repo.get_issue(issue_number)
+            for comment in issue.get_comments():
+                if comment.id == comment_id:
+                    comment.edit(body)
+                    log.info(f"Updated comment {comment_id} on issue #{issue_number}")
+                    return True
+            log.warning(f"Comment {comment_id} not found on issue #{issue_number}")
+            return False
+        except Exception as e:
+            log.error(f"Failed to update comment {comment_id} on issue #{issue_number}: {e}")
+            return False
+
+    @property
+    def project_id(self) -> str | None:
+        """Lazy-load project ID. Returns None if not configured."""
+        if self.config.project_identifier is None:
+            return None
+
+        if self._project_id is None:
+            project_number = int(self.config.project_identifier)
+            self._project_id = self.projects_client.get_project_id(self.config.repo_owner, project_number)
+        return self._project_id
+
+    @property
+    def status_field_info(self) -> tuple[str, dict[str, str]]:
+        """Lazy-load status field ID and options."""
+        if not self.has_project:
+            return "", {}
+
+        if self._status_field_id is None or self._status_options is None:
+            pid = self._project_id
+            if pid is None:
+                return "", {}
+            self._status_field_id, self._status_options = self.projects_client.get_status_field_id(pid)
+        return self._status_field_id, self._status_options
+
+    def get_open_issues(self) -> list[Issue]:
+        """Get all open issues from the repository.
+
+        Returns:
+            List of open issues
+        """
+        issues: list[Issue] = []
+
+        for issue in self.repo.get_issues(state="open"):
+            issues.append(
+                Issue(
+                    id=issue.number,
+                    number=issue.number,
+                    title=issue.title,
+                    body=issue.body,
+                    node_id=issue.node_id,
+                    url=issue.html_url,
+                    labels=[label.name for label in issue.labels],
+                )
+            )
+
+        return issues
+
+    def get_project_items(self) -> list[ProjectItem]:
+        """Get all items in a project.
+
+        Returns:
+            List of project items
+        """
+        if self.project_id is None:  # New guard
+            return []  # Return empty list when no project
+
+        items = self.projects_client.get_project_items(self.project_id)
+        return [
+            ProjectItem(
+                id=item.project_item_id,
+                issue_number=item.issue_number,
+                title=item.title,
+                body=item.body,
+                status=item.status,
+            )
+            for item in items
+        ]
+
+    def add_issue_to_project(self, issue: Issue) -> str | None:
+        """Add an issue to a project.
+
+        Args:
+            issue: Issue to add
+
+        Returns:
+            Project item ID if successful, None otherwise
+        """
+        if not issue.node_id:
+            log.warning(f"Issue #{issue.number} has no node_id")
+            return None
+
+        if self.project_id is None:
+            log.warning("add_issue_to_project called without project configuration")
+            return None
+
+        try:
+            item_id = self.projects_client.add_issue_to_project(self.project_id, issue.node_id)
+            log.info(f"Added issue #{issue.number} to project")
+            return item_id
+        except Exception as e:
+            log.error(f"Failed to add issue #{issue.number} to project: {e}")
+            return None
+
+    def update_issue_status(self, issue_number: int, status: str) -> bool:
+        """Update the status of an issue in a project.
+
+        Args:
+            issue_number: Issue number
+            status: New status value (provider-specific)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        if self.project_id is None:  # New guard
+            log.warning("update_issue_status called without project configuration")
+            return False
+
+        item = self.find_project_item(issue_number)
+        if not item:
+            log.warning(f"Issue #{issue_number} not found in project")
+            return False
+
+        field_id, options = self.status_field_info
+        if status not in options:
+            log.warning(f"Status '{status}' not found in project options: {list(options.keys())}")
+            return False
+
+        success = self.projects_client.update_item_status(self.project_id, item.id, field_id, options[status])
+        if success:
+            log.info(f"Updated issue #{issue_number} to '{status}'")
+        return success
+
+    def get_issue(self, issue_number: int) -> Issue:
+        return cast(Issue, self.repo.get_issue(issue_number))
+
+    def add_comment(self, issue_number: int, comment: str) -> bool:
+        """Add a comment to an issue.
+
+        Args:
+            issue_number: Issue number
+            comment: Comment text
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            issue = self.repo.get_issue(issue_number)
+            issue.create_comment(comment)
+            log.info(f"Added comment to issue #{issue_number}")
+            return True
+        except Exception as e:
+            log.error(f"Failed to add comment to issue #{issue_number}: {e}")
+            return False
+
+    def has_label(self, issue_number: int, label_name: str) -> bool:
+        """Check if an issue/pull request has a specific label.
+
+        Args:
+            issue_numer: Issue/Pull request number
+            label_name: Name of the label to check for
+
+        Returns:
+            True if the label is present on the PR, False otherwise
+        """
+        try:
+            pr = self.repo.get_issue(issue_number)
+
+            # Check if any label matches the requested label name
+            for label in pr.labels:
+                if label.name == label_name:
+                    log.info(f"Pull request #{issue_number} has label '{label_name}'")
+                    return True
+
+            log.info(f"Pull request #{issue_number} does not have label '{label_name}'")
+            return False
+
+        except github.UnknownObjectException:
+            log.warning(f"Pull request #{issue_number} not found")
+            return False
+        except Exception as e:
+            log.error(f"Failed to check label on PR #{issue_number}: {e}")
+            return False
+
+    def create_pull_request(
+        self,
+        title: str,
+        body: str,
+        head: str,
+        base: str = "develop",
+    ) -> tuple[int, str] | None:
+        """Create a pull request.
+
+        Args:
+            title: PR title
+            body: PR body/description
+            head: Source branch name
+            base: Target branch name (default: "develop")
+
+        Returns:
+            Tuple of (pr_number, pr_url) if successful, None otherwise
+        """
+        try:
+            pr = self.repo.create_pull(
+                title=title,
+                body=body.strip(),
+                head=head,
+                base=base,
+            )
+            log.info(f"Created PR #{pr.number}: {pr.html_url}")
+            return pr.number, pr.html_url
+        except Exception as e:
+            log.error(f"Failed to create PR from {head} to {base}: {e}")
+            return None
+
+    def merge_pull_request(
+        self,
+        pr_number: int,
+        commit_message: str | None = None,
+        merge_method: str = "merge",
+    ) -> bool:
+        """Merge a pull request into its base branch (typically develop).
+
+        Args:
+            pr_number: Pull request number
+            commit_message: Optional custom commit message for the merge
+            merge_method: Merge method - "merge", "squash", or "rebase" (default: "merge")
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            pr = self.repo.get_pull(pr_number)
+
+            if pr.merged:
+                log.warning(f"Pull request #{pr_number} is already merged")
+                return True
+
+            if pr.state != "open":
+                log.error(f"Pull request #{pr_number} is not open (state: {pr.state})")
+                return False
+
+            if commit_message:
+                result = pr.merge(commit_message=commit_message, merge_method=merge_method)
+            else:
+                result = pr.merge(merge_method=merge_method)
+
+            if result.merged:
+                log.info(f"Successfully merged pull request #{pr_number} into {pr.base.ref} using {merge_method}")
+                return True
+            else:
+                log.error(f"Failed to merge pull request #{pr_number}: {result.message}")
+                return False
+
+        except Exception as e:
+            log.error(f"Failed to merge pull request #{pr_number}: {e}")
+            return False

project_manager/github_conversation.py

@@ -0,0 +1,144 @@
+"""Enhanced GitHub manager with reaction support."""
+
+import logging
+from typing import Optional
+
+from .github import GitHubProjectManager
+
+log = logging.getLogger(__name__)
+
+
+class GitHubConversationManager(GitHubProjectManager):
+    """GitHub manager with conversation and reaction support."""
+
+    def get_comment_reactions(self, issue_number: int, comment_id: int) -> list[dict]:
+        """Get reactions on a specific comment.
+
+        Args:
+            issue_number: Issue number
+            comment_id: Comment ID
+
+        Returns:
+            List of reactions with user and content
+        """
+        try:
+            issue = self.repo.get_issue(issue_number)
+            comment = issue.get_comment(comment_id)
+            reactions = []
+
+            for reaction in comment.get_reactions():
+                reactions.append(
+                    {
+                        "user": reaction.user.login if reaction.user else None,
+                        "content": reaction.content,
+                        "created_at": (reaction.created_at.isoformat() if reaction.created_at else None),
+                    }
+                )
+
+            log.info(f"Found {len(reactions)} reactions on comment {comment_id}")
+            return reactions
+
+        except Exception as e:
+            log.error(f"Failed to get reactions on comment {comment_id}: {e}")
+            return []
+
+    def has_thumbs_up_reaction(self, issue_number: int, comment_id: int) -> bool:
+        """Check if a comment has a thumbs up reaction from the issue author.
+
+        Args:
+            issue_number: Issue number
+            comment_id: Comment ID
+
+        Returns:
+            True if thumbs up from issue author exists
+        """
+        try:
+            issue = self.repo.get_issue(issue_number)
+            issue_author = issue.user.login
+
+            reactions = self.get_comment_reactions(issue_number, comment_id)
+
+            for reaction in reactions:
+                if reaction["content"] == "+1" and reaction["user"] == issue_author:
+                    log.info(f"Thumbs up from {issue_author} detected")
+                    return True
+
+            return False
+
+        except Exception as e:
+            log.error(f"Failed to check thumbs up on comment {comment_id}: {e}")
+            return False
+
+    def get_latest_comments(self, issue_number: int, since_id: Optional[int] = None) -> list[dict]:
+        """Get latest comments on an issue.
+
+        Args:
+            issue_number: Issue number
+            since_id: Only return comments after this ID
+
+        Returns:
+            List of comment dictionaries
+        """
+        try:
+            issue = self.repo.get_issue(issue_number)
+            comments = []
+
+            for comment in issue.get_comments():
+                if since_id and comment.id <= since_id:
+                    continue
+
+                # Check for thumbs up reaction
+                has_thumbs_up = self.has_thumbs_up_reaction(issue_number, comment.id)
+
+                comments.append(
+                    {
+                        "id": comment.id,
+                        "user": comment.user.login if comment.user else None,
+                        "body": comment.body,
+                        "created_at": (comment.created_at.isoformat() if comment.created_at else None),
+                        "thumbs_up": has_thumbs_up,
+                    }
+                )
+
+            log.info(f"Retrieved {len(comments)} new comments")
+            return comments
+
+        except Exception as e:
+            log.error(f"Failed to get comments for issue {issue_number}: {e}")
+            return []
+
+    def get_issue_with_reactions(self, issue_number: int) -> dict:
+        """Get issue with reaction information.
+
+        Args:
+            issue_number: Issue number
+
+        Returns:
+            Dictionary with issue details and reaction info
+        """
+        try:
+            issue = self.repo.get_issue(issue_number)
+
+            # Get reactions on the issue itself
+            reactions = []
+            for reaction in issue.get_reactions():
+                reactions.append(
+                    {
+                        "user": reaction.user.login if reaction.user else None,
+                        "content": reaction.content,
+                        "created_at": (reaction.created_at.isoformat() if reaction.created_at else None),
+                    }
+                )
+
+            return {
+                "id": issue.number,
+                "title": issue.title,
+                "body": issue.body,
+                "author": issue.user.login if issue.user else None,
+                "state": issue.state,
+                "reactions": reactions,
+            }
+
+        except Exception as e:
+            log.error(f"Failed to get issue {issue_number}: {e}")
+            return {}