polycoding 0.1.0__py3-none-any.whl

project_manager/base.py

@@ -0,0 +1,202 @@
+"""Abstract base class for project managers."""
+
+from abc import ABC, abstractmethod
+
+from .types import Issue, ProjectConfig, ProjectItem
+
+
+class ProjectManager(ABC):
+    """Abstract base class for project management providers."""
+
+    def __init__(self, config: ProjectConfig) -> None:
+        """Initialize project manager with configuration.
+
+        Args:
+            config: Project configuration
+        """
+        self.config = config
+
+    @property
+    @abstractmethod
+    def has_project(self) -> bool:
+        """Is a project configured that can be used for management, e.g.
+        Kanban?
+        """
+
+    @abstractmethod
+    def get_comments(self, issue_number: int) -> list:
+        """Get all comments for an issue.
+
+        Args:
+            issue_number: Issue number
+
+        Returns:
+            List of comments
+        """
+
+    @abstractmethod
+    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
+        """
+
+    @abstractmethod
+    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
+        """
+
+    @abstractmethod
+    def get_open_issues(self) -> list[Issue]:
+        """Get all open issues from the repository.
+
+        Returns:
+            List of open issues
+        """
+
+    @abstractmethod
+    def get_project_items(self) -> list[ProjectItem]:
+        """Get all items in the project.
+
+        Returns:
+            List of project items
+        """
+
+    @abstractmethod
+    def add_issue_to_project(self, issue: Issue) -> str | None:
+        """Add an issue to the project.
+
+        Args:
+            issue: Issue to add
+
+        Returns:
+            Project item ID if successful, None otherwise
+        """
+
+    @abstractmethod
+    def update_issue_status(self, issue_number: int, status: str) -> bool:
+        """Update the status of an issue in the project.
+
+        Args:
+            issue_number: Issue number
+            status: New status value
+
+        Returns:
+            True if successful, False otherwise
+        """
+
+    @abstractmethod
+    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
+        """
+
+    @abstractmethod
+    def has_label(self, issue_number: int, label_name: str) -> bool:
+        """Check if an issue/PR has a specific label.
+
+        Args:
+            issue_number: Issue or PR number
+            label_name: Name of the label to check for
+
+        Returns:
+            True if label is present
+        """
+
+    @abstractmethod
+    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
+        """
+
+    @abstractmethod
+    def merge_pull_request(
+        self,
+        pr_number: int,
+        commit_message: str | None = None,
+        merge_method: str = "merge",
+    ) -> bool:
+        """Merge a pull request.
+
+        Args:
+            pr_number: Pull request number
+            commit_message: Optional custom commit message for the merge
+            merge_method: Merge method - "merge", "squash", or "rebase"
+
+        Returns:
+            True if successful
+        """
+
+    @property
+    @abstractmethod
+    def bot_username(self) -> str:
+        """Get the authenticated bot username."""
+        ...
+
+    def find_project_item(self, issue_number: int) -> ProjectItem | None:
+        """Find a project item by issue number.
+
+        Args:
+            issue_number: Issue number
+
+        Returns:
+            Project item if found, None otherwise
+        """
+        items = self.get_project_items()
+        for item in items:
+            if item.issue_number == issue_number:
+                return item
+        return None
+
+    def sync_issues_to_project(self) -> int:
+        """Sync all open issues to the project.
+
+        Adds any issues that aren't already in the project.
+
+        Returns:
+            Number of issues added
+        """
+        issues = self.get_open_issues()
+        items = self.get_project_items()
+        existing_numbers = {item.issue_number for item in items}
+
+        added = 0
+        for issue in issues:
+            if issue.number not in existing_numbers:
+                if self.add_issue_to_project(issue):
+                    added += 1
+
+        return added

project_manager/config.py

@@ -0,0 +1,36 @@
+from typing import Optional
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class ProjectManagerSettings(BaseSettings):
+    DATA_PATH: str = "/data"
+
+    GITHUB_APP_ID: Optional[str] = None
+    GITHUB_TOKEN: str
+
+    # Redis Configuration
+    REDIS_URL: str = "redis://localhost:6379/0"
+    REDIS_HOST: str = "localhost"
+    REDIS_PORT: int = 6379
+    REDIS_DB: int = 0
+
+    PROJECT_PROVIDER: Optional[str] = None
+    REPO_OWNER: Optional[str] = None
+    REPO_NAME: Optional[str] = None
+    PROJECT_IDENTIFIER: Optional[str] = None
+
+    # Label that must be present before merging a PR
+    MERGE_REQUIRED_LABEL: str = "polycode:automerge"
+    WORK_FLOW_START_LABEL: str = "polycode:implement"
+
+    # Label prefix for flow-triggering labels
+    FLOW_LABEL_PREFIX: str = "polycode:"
+
+    # Database Configuration
+    DATABASE_URL: str = "sqlite:///polycode.db"
+
+    model_config = SettingsConfigDict(extra="ignore", env_file=".env", case_sensitive=True)
+
+
+settings = ProjectManagerSettings()  # pyright:ignore # ty:ignore

project_manager/conversation/__init__.py

@@ -0,0 +1,19 @@
+"""Conversation-driven specification flow module."""
+
+from .flow import ConversationFlow
+from .types import (
+    ConversationFlowState,
+    ConversationMessage,
+    ConversationStage,
+    NewCommentInput,
+    ReactionInput,
+)
+
+__all__ = [
+    "ConversationFlow",
+    "ConversationFlowState",
+    "ConversationStage",
+    "ConversationMessage",
+    "NewCommentInput",
+    "ReactionInput",
+]

project_manager/conversation/flow.py

@@ -0,0 +1,233 @@
+"""Conversation-driven specification flow."""
+
+import logging
+from typing import List
+
+from crewai.flow.flow import listen, start
+
+from crews.conversation_crew import ConversationCrew
+from crews.plan_crew.types import Story
+from flows.base import FlowIssueManagement
+from project_manager.github_conversation import GitHubConversationManager
+
+from .types import (
+    ConversationFlowState,
+    ConversationMessage,
+    ConversationStage,
+    NewCommentInput,
+    ReactionInput,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ConversationFlow(FlowIssueManagement[ConversationFlowState]):
+    """Flow for conversation-driven specification via GitHub comments."""
+
+    conversation_crew: ConversationCrew | None = None
+
+    @property
+    def _github_manager(self) -> GitHubConversationManager:
+        if not self.state.project_config:
+            raise ValueError("project_config not specified!")
+        return GitHubConversationManager(self.state.project_config)
+
+    @start()
+    def initialize_conversation(self):
+        """Initialize conversation from issue opening."""
+        logger.info(f"🗣️ Starting conversation for issue #{self.state.issue_id}")
+
+        self.conversation_crew = ConversationCrew()
+
+        initial_message = (
+            "## 🤖 Specification Bot Activated\n\n"
+            "I'll help you refine this feature into a clear specification. "
+            "I'll ask questions to clarify requirements, then propose a specification for your approval.\n\n"
+            "**To approve a specification or story plan, add a 👍 reaction to my comment.**\n\n"
+            "Let's start!"
+        )
+        self._github_manager.add_comment(self.state.issue_id, initial_message)
+        self._ask_specification_question()
+
+    def _ask_specification_question(self):
+        """Generate and post a specification question."""
+        crew = self.conversation_crew
+        if not crew:
+            return
+
+        history = "\n\n".join(f"**{msg.author}**: {msg.content}" for msg in self.state.messages)
+
+        crew_instance = crew.crew()
+        result = crew_instance.kickoff(
+            inputs={
+                "title": self.state.task,
+                "body": self.state.commit_message or "",
+                "conversation_history": history or "No conversation yet",
+            }
+        )
+
+        response_text = str(result) if result else "No response"
+        self._github_manager.add_comment(self.state.issue_id, response_text)
+
+        self.state.messages.append(
+            ConversationMessage(
+                author="llm",
+                content=response_text,
+            )
+        )
+        self.state.stage = ConversationStage.SPEC_ELCITATION
+
+    @listen(initialize_conversation)
+    def handle_new_comment(self, input_data: NewCommentInput):
+        """Handle new comment from user."""
+        logger.info(f"💬 New comment from {input_data.author}")
+
+        self.state.messages.append(
+            ConversationMessage(
+                author=input_data.author,
+                content=input_data.content,
+            )
+        )
+
+        if input_data.thumbs_up:
+            logger.info("👍 Thumbs up detected, moving to next stage")
+            self._handle_approval()
+        else:
+            self._ask_specification_question()
+
+    @listen(handle_new_comment)
+    def handle_reaction(self, input_data: ReactionInput):
+        """Handle thumbs up reaction."""
+        if input_data.reaction == "+1":
+            logger.info("👍 Thumbs up reaction detected")
+            self.state.thumbs_up_given = True
+            self._handle_approval()
+
+    def _handle_approval(self):
+        """Handle specification approval and move to story planning."""
+        if self.state.stage == ConversationStage.SPEC_ELCITATION:
+            logger.info("✅ Specification approved, moving to story breakdown")
+            self.state.stage = ConversationStage.SPEC_APPROVAL
+            self._break_down_stories()
+        elif self.state.stage == ConversationStage.STORY_BREAKDOWN:
+            logger.info("✅ Stories approved, initializing Ralph loop")
+            self.state.stage = ConversationStage.STORY_APPROVAL
+            self._init_ralph_loop()
+
+    def _break_down_stories(self):
+        """Break down approved specification into stories."""
+        if not self.conversation_crew:
+            return
+
+        crew = self.conversation_crew
+        spec = self.state.specification or self.state.messages[-1].content
+
+        crew_instance = crew.crew()
+        result = crew_instance.kickoff(
+            inputs={
+                "specification": spec,
+            }
+        )
+
+        crew_output = result
+        if hasattr(result, "result"):
+            crew_output = result.result  # pyright: ignore
+
+        stories_text = "## 📋 Proposed Stories\n\n"
+
+        stories: List[Story] = crew_output.pydantic  # type: ignore[assignment]
+
+        for story in stories:
+            self.state.stories.append(story)
+            stories_text += f" - [{' ' if story.completed else 'x'}] {story.description}\n\n---\n\n"
+
+        stories_text += "\nPlease review these stories. **Add 👍 to this comment when you approve the plan.**"
+
+        self._github_manager.add_comment(self.state.issue_id, stories_text)
+        self.state.specification = spec
+        self.state.stage = ConversationStage.STORY_BREAKDOWN
+
+    def _init_ralph_loop(self):
+        """Initialize Ralph loop with approved stories."""
+        if not self.state.stories:
+            logger.warning("No stories to execute")
+            return
+
+        next_story = None
+        for story in self.state.stories:
+            if not story.completed:
+                next_story = story
+                self.state.approved_story_id = story.id
+                break
+
+        if not next_story:
+            logger.info("All stories completed!")
+            self.state.stage = ConversationStage.COMPLETED
+            return
+
+        logger.info(f"🚀 Initializing Ralph for story: {next_story.title}")
+
+        conversation_summary = "\n".join(f"- {msg.author}: {msg.content}" for msg in self.state.messages[-5:])
+
+        if self.conversation_crew:
+            crew_instance = self.conversation_crew.crew()
+            result = crew_instance.kickoff(
+                inputs={
+                    "specification": self.state.specification,
+                    "story": next_story.model_dump(),
+                    "conversation_summary": conversation_summary,
+                }
+            )
+
+            response_text = str(result) if result else "No response"
+            brief = (
+                f"## 🚀 Starting Development\n\n"
+                f"**Story:** {next_story.title}\n\n"
+                f"---\n\n"
+                f"{response_text}\n\n"
+                f"Development in progress..."
+            )
+            self._github_manager.add_comment(self.state.issue_id, brief)
+
+        logger.info("Transitioning to Ralph execution phase")
+        self.state.stage = ConversationStage.RALPH_INIT
+
+    def check_ralph_completion(self):
+        """Check if Ralph loop completed the current story."""
+        if self.state.build_success and self.state.test_success:
+            logger.info("✅ Story completed successfully")
+
+            for story in self.state.stories:
+                if story.id == self.state.approved_story_id:
+                    story.completed = True
+                    break
+
+            self._github_manager.add_comment(
+                self.state.issue_id,
+                f"## ✅ Story Completed\n\n"
+                f"Story {self.state.approved_story_id} completed successfully.\n\n"
+                f"Review the changes and provide feedback.",
+            )
+
+            self._break_down_stories()
+        elif self.state.stage == ConversationStage.RALPH_EXECUTION:
+            logger.info("⏳ Ralph execution in progress")
+            return "wait"
+        else:
+            logger.error("❌ Ralph execution failed")
+            return "error"
+
+    @listen("wait")
+    def wait_for_completion(self):
+        """Wait for Ralph to complete."""
+        return "continue"
+
+    @listen("error")
+    def handle_ralph_error(self):
+        """Handle Ralph execution errors."""
+        logger.error("Ralph execution error, requesting feedback")
+        self._github_manager.add_comment(
+            self.state.issue_id,
+            "## ❌ Error\n\nDevelopment encountered an error. Please review and provide guidance.",
+        )
+        self.state.stage = ConversationStage.INIT

project_manager/conversation/types.py

@@ -0,0 +1,64 @@
+"""Conversation-driven specification flow models."""
+
+from enum import Enum
+from typing import TYPE_CHECKING, Optional
+
+from pydantic import BaseModel, Field
+
+from flows.base import BaseFlowModel
+
+if TYPE_CHECKING:
+    from crews.plan_crew.types import Story
+
+
+class ConversationStage(str, Enum):
+    """Stages of the conversation flow."""
+
+    INIT = "init"
+    SPEC_ELCITATION = "spec_elicitation"
+    SPEC_APPROVAL = "spec_approval"
+    STORY_BREAKDOWN = "story_breakdown"
+    STORY_APPROVAL = "story_approval"
+    RALPH_INIT = "ralph_init"
+    RALPH_EXECUTION = "ralph_execution"
+    COMPLETED = "completed"
+
+
+class ConversationMessage(BaseModel):
+    """A message in the conversation."""
+
+    author: str = Field(description="Message author ('user' or 'llm')")
+    content: str = Field(description="Message content")
+    timestamp: Optional[str] = Field(default=None, description="ISO timestamp")
+
+
+class NewCommentInput(BaseModel):
+    """Input when a new comment is received."""
+
+    comment_id: int
+    author: str
+    content: str
+    thumbs_up: bool = False
+
+
+class ReactionInput(BaseModel):
+    """Input when a thumbs up reaction is detected."""
+
+    comment_id: int
+    reaction: str
+
+
+class ConversationFlowState(BaseFlowModel):
+    """State for conversation flow."""
+
+    stage: ConversationStage = Field(default=ConversationStage.INIT)
+    messages: list[ConversationMessage] = Field(default_factory=list, description="Conversation history")
+    specification: Optional[str] = Field(default=None, description="Final approved specification")
+    requirements: list[str] = Field(default_factory=list)
+    stories: list["Story"] = Field(default_factory=list, description="User stories")
+    approved_story_id: Optional[int] = Field(default=None, description="ID of story to execute next")
+    ralph_output: Optional[str] = Field(default=None, description="Ralph agent output")
+    build_success: bool = Field(default=False)
+    test_success: bool = Field(default=False)
+    last_comment_id: Optional[int] = Field(default=None, description="Last comment ID we posted")
+    thumbs_up_given: bool = Field(default=False, description="User gave thumbs up")