Merge pull request #11 from geekbot-com/feature/polls

Feature/polls

Author: sabpap

.github/workflows/test.yml

@@ -0,0 +1,46 @@
+name: Python Tests
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10' # You might want to adjust this or use a matrix strategy
+
+      - name: Verify Python version compatibility
+        run: |
+          PYTHON_REQUIREMENT=$(grep "requires-python" pyproject.toml | sed -E 's/.*requires-python = "(.*)".*$/\1/')
+          CURRENT_PYTHON_VERSION=$(python --version | cut -d ' ' -f 2)
+          echo "Checking if Python $CURRENT_PYTHON_VERSION satisfies requirement: $PYTHON_REQUIREMENT"
+
+          pip install packaging
+
+          python -c "from packaging.specifiers import SpecifierSet; import sys; requirement='$PYTHON_REQUIREMENT'; version='$CURRENT_PYTHON_VERSION'; exit(0 if SpecifierSet(requirement).contains(version) else 1)"
+
+          if [ $? -eq 0 ]; then
+            echo "✅ Python version $CURRENT_PYTHON_VERSION is compatible with requirement $PYTHON_REQUIREMENT"
+          else
+            echo "❌ Python version $CURRENT_PYTHON_VERSION is NOT compatible with requirement $PYTHON_REQUIREMENT"
+            exit 1
+          fi
+
+      - name: Install uv
+        run: |
+          pip install uv
+
+      - name: Install dependencies
+        run: |
+          uv pip install --system .[dev]
+          uv pip install -r pyproject.toml --group dev --system
+
+      - name: Run Pytest
+        run: |
+          python -m pytest -vv

README.md

@@ -104,6 +104,22 @@ Once configured, your LLM client application will have access to the following t
 - `participants`: List of users participating in the standup.
 - `owner_id`: ID of the standup owner.
 
+- `list_polls`
+
+**Purpose:** Lists all the polls accessible via your API key. Useful for getting an overview or finding a specific poll ID.
+
+**Example Prompt:** "Hey, can you list my Geekbot polls?"
+
+**Data Fields Returned:**
+
+- `id`: Unique poll identifier.
+- `name`: Name of the poll.
+- `time`: Scheduled time for the poll.
+- `timezone`: Timezone for the scheduled time.
+- `questions`: List of questions asked in the poll.
+- `participants`: List of users participating in the poll.
+- `creator`: The poll creator.
+
 - `fetch_reports`
 
 **Purpose:** Retrieves specific standup reports. You can filter by standup, user, and date range.
@@ -143,6 +159,17 @@ Once configured, your LLM client application will have access to the following t
 - `email`: Member's email address.
 - `role`: Member's role within Geekbot (e.g., Admin, Member).
 
+- `fetch_poll_results`
+
+**Purpose:** Retrieves specific poll results. Requires a poll id and optionally a date range.
+
+**Example Prompt:** "Hey, what was decided about the new logo in Geekbot polls?"
+
+**Data Fields Returned:**
+
+- `total_results`: Total number of results.
+- `question_results`: List of question results.
+
 ### Prompts 💬
 
 - `weekly_rollup_report`

geekbot_mcp/gb_api.py

@@ -20,6 +20,13 @@ async def get_standups(
         response.raise_for_status()
         return response.json()
 
+    async def get_polls(self) -> list:
+        """Get list of polls"""
+        endpoint = f"{self.base_url}/polls/"
+        response = await self._client.get(endpoint, headers=self.headers)
+        response.raise_for_status()
+        return response.json()
+
     async def get_reports(
         self,
         standup_id: int | None = None,
@@ -48,5 +55,20 @@ async def get_reports(
         response.raise_for_status()
         return response.json()
 
+    async def get_poll_results(
+        self, poll_id: int, after: int | None = None, before: int | None = None
+    ) -> dict:
+        """Fetch poll results"""
+        endpoint = f"{self.base_url}/polls/{poll_id}/votes/"
+        params = {}
+        if after:
+            params["after"] = after
+        if before:
+            params["before"] = before
+
+        response = await self._client.get(endpoint, headers=self.headers, params=params)
+        response.raise_for_status()
+        return response.json()
+
     def close(self):
         self._client.close()

geekbot_mcp/models.py

@@ -1,30 +1,28 @@
 from datetime import datetime
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 
-class Participant(BaseModel):
+class User(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
     id: str
     name: str
     username: str
     email: str
     role: str
 
-    class Config:
-        frozen = True
-
     def __hash__(self):
         return hash(self.id)
 
 
 class Reporter(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
     id: str
     name: str
     username: str
 
-    class Config:
-        frozen = True
-
     def __hash__(self):
         return hash(self.id)
 
@@ -37,43 +35,78 @@ class Question(BaseModel):
 
 
 class Standup(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
     id: int
     name: str
     channel: str
     time: str
     timezone: str
     questions: list[Question]
-    participants: list[Participant]
+    participants: list[User]
     owner_id: str
 
-    class Config:
-        frozen = True
+    def __hash__(self):
+        return hash(self.id)
+
+
+class Poll(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    id: int
+    name: str
+    time: str
+    timezone: str
+    questions: list[Question]
+    participants: list[User]
+    creator: User
 
     def __hash__(self):
         return hash(self.id)
 
 
 class Report(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
     id: int
     standup_id: int
     created_at: str
     reporter: Reporter
     content: str
 
-    class Config:
-        frozen = True
-
     def __hash__(self):
         return hash(self.id)
 
 
-def participant_from_json_response(p_res: dict) -> Participant:
-    return Participant(
-        id=p_res["id"],
-        name=p_res["realname"],
-        username=p_res["username"],
-        email=p_res["email"],
-        role=p_res["role"],
+class PollChoiceResult(BaseModel):
+    text: str
+    votes: int
+    percentage: float
+    users: list[User]
+
+
+class PollQuestionResult(BaseModel):
+    date: str
+    choices: list[PollChoiceResult]
+
+
+class PollQuestionResults(BaseModel):
+    question_text: str
+    results: list[PollQuestionResult]
+
+
+class PollResults(BaseModel):
+    num_poll_instances: int
+    question_results: list[PollQuestionResults]
+
+
+def user_from_json_response(u_res: dict) -> User:
+    return User(
+        id=u_res["id"],
+        name=u_res["realname"],
+        username=u_res["username"],
+        email=u_res["email"],
+        role=u_res["role"],
     )
 
 
@@ -90,6 +123,15 @@ def question_from_json_response(q_res: dict) -> Question:
     )
 
 
+def poll_question_from_json_response(q_res: dict) -> Question:
+    return Question(
+        text=q_res["text"],
+        answer_type=q_res["answer_type"],
+        answer_choices=q_res["answer_choices"],
+        is_random=False,
+    )
+
+
 def standup_from_json_response(s_res: dict) -> Standup:
     return Standup(
         id=s_res["id"],
@@ -98,11 +140,23 @@ def standup_from_json_response(s_res: dict) -> Standup:
         time=s_res["time"],
         timezone=s_res["timezone"],
         questions=[question_from_json_response(q) for q in s_res["questions"]],
-        participants=[participant_from_json_response(p) for p in s_res["users"]],
+        participants=[user_from_json_response(p) for p in s_res["users"]],
         owner_id=s_res["master"],
     )
 
 
+def poll_from_json_response(p_res: dict) -> Poll:
+    return Poll(
+        id=p_res["id"],
+        name=p_res["name"],
+        time=p_res["time"],
+        timezone=p_res["timezone"],
+        questions=[poll_question_from_json_response(q) for q in p_res["questions"]],
+        participants=[user_from_json_response(p) for p in p_res["users"]],
+        creator=user_from_json_response(p_res["creator"]),
+    )
+
+
 def reporter_from_json_response(r_res: dict) -> Reporter:
     return Reporter(
         id=r_res["id"],
@@ -129,3 +183,35 @@ def report_from_json_response(r_res: dict) -> Report:
         reporter=reporter_from_json_response(r_res["member"]),
         content=content_from_json_response(r_res["questions"]),
     )
+
+
+def poll_choice_result_from_json_response(c_res: dict) -> PollChoiceResult:
+    return PollChoiceResult(
+        text=c_res["text"],
+        votes=c_res["votes"],
+        percentage=c_res["percentage"],
+        users=[user_from_json_response(u) for u in c_res["users"]],
+    )
+
+
+def poll_question_result_from_json_response(q_res: dict) -> PollQuestionResult:
+    return PollQuestionResult(
+        date=q_res["date"],
+        choices=[poll_choice_result_from_json_response(c) for c in q_res["answers"]],
+    )
+
+
+def poll_question_results_from_json_response(q_res: dict) -> PollQuestionResults:
+    return PollQuestionResults(
+        question_text=q_res["text"],
+        results=[poll_question_result_from_json_response(r) for r in q_res["results"]],
+    )
+
+
+def poll_results_from_json_response(p_res: dict) -> PollResults:
+    return PollResults(
+        num_poll_instances=p_res["total_results"],
+        question_results=[
+            poll_question_results_from_json_response(q) for q in p_res["questions"]
+        ],
+    )

geekbot_mcp/tools/__init__.py

@@ -1,13 +1,24 @@
 from mcp import types
 
 from geekbot_mcp.gb_api import GeekbotClient
+from geekbot_mcp.tools.fetch_poll_results import (
+    fetch_poll_results,
+    handle_fetch_poll_results,
+)
 from geekbot_mcp.tools.fetch_reports import fetch_reports, handle_fetch_reports
 from geekbot_mcp.tools.list_members import handle_list_members, list_members
+from geekbot_mcp.tools.list_polls import handle_list_polls, list_polls
 from geekbot_mcp.tools.list_standups import handle_list_standups, list_standups
 
 
 def list_tools() -> list[types.Tool]:
-    return [fetch_reports, list_standups, list_members]
+    return [
+        list_members,
+        list_standups,
+        fetch_reports,
+        list_polls,
+        fetch_poll_results,
+    ]
 
 
 async def run_tool(
@@ -16,11 +27,15 @@ async def run_tool(
     arguments: dict[str, str] | None,
 ) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
     match name:
-        case "fetch_reports":
-            return await handle_fetch_reports(gb_client, **arguments)
-        case "list_standups":
-            return await handle_list_standups(gb_client)
         case "list_members":
             return await handle_list_members(gb_client)
+        case "list_standups":
+            return await handle_list_standups(gb_client)
+        case "fetch_reports":
+            return await handle_fetch_reports(gb_client, **arguments)
+        case "list_polls":
+            return await handle_list_polls(gb_client)
+        case "fetch_poll_results":
+            return await handle_fetch_poll_results(gb_client, **arguments)
         case _:
             raise ValueError(f"Tool {name} not found")