mcp-ticketer 2.0.1__py3-none-any.whl → 2.2.13__py3-none-any.whl

mcp_ticketer/adapters/{jira.py → jira/adapter.py}

@@ -2,20 +2,17 @@
 
 from __future__ import annotations
 
-import asyncio
 import builtins
 import logging
-import re
 from datetime import datetime
-from enum import Enum
+from pathlib import Path
 from typing import Any, Union
 
-import httpx
-from httpx import AsyncClient, HTTPStatusError, TimeoutException
+from httpx import HTTPStatusError
 
-from ..core.adapter import BaseAdapter
-from ..core.env_loader import load_adapter_config, validate_adapter_config
-from ..core.models import (
+from ...core.adapter import BaseAdapter
+from ...core.env_loader import load_adapter_config, validate_adapter_config
+from ...core.models import (
     Attachment,
     Comment,
     Epic,
@@ -24,102 +21,31 @@ from ..core.models import (
     Task,
     TicketState,
 )
-from ..core.registry import AdapterRegistry
+from ...core.registry import AdapterRegistry
+from .client import JiraClient
+from .mappers import (
+    issue_to_ticket,
+    map_epic_update_fields,
+    map_update_fields,
+    ticket_to_issue_fields,
+)
+from .queries import (
+    build_epic_list_jql,
+    build_list_jql,
+    build_project_labels_jql,
+    build_search_jql,
+    get_labels_search_params,
+    get_search_params,
+)
+from .types import (
+    extract_text_from_adf,
+    get_state_mapping,
+    parse_jira_datetime,
+)
 
 logger = logging.getLogger(__name__)
 
 
-def parse_jira_datetime(date_str: str) -> datetime | None:
-    """Parse JIRA datetime strings which can be in various formats.
-
-    JIRA can return dates in formats like:
-    - 2025-10-24T14:12:18.771-0400
-    - 2025-10-24T14:12:18.771Z
-    - 2025-10-24T14:12:18.771+00:00
-    """
-    if not date_str:
-        return None
-
-    try:
-        # Handle Z timezone
-        if date_str.endswith("Z"):
-            return datetime.fromisoformat(date_str.replace("Z", "+00:00"))
-
-        # Handle timezone formats like -0400, +0500 (need to add colon)
-        if re.match(r".*[+-]\d{4}$", date_str):
-            # Insert colon in timezone: -0400 -> -04:00
-            date_str = re.sub(r"([+-]\d{2})(\d{2})$", r"\1:\2", date_str)
-
-        return datetime.fromisoformat(date_str)
-
-    except (ValueError, TypeError) as e:
-        logger.warning(f"Failed to parse JIRA datetime '{date_str}': {e}")
-        return None
-
-
-def extract_text_from_adf(adf_content: str | dict[str, Any]) -> str:
-    """Extract plain text from Atlassian Document Format (ADF).
-
-    Args:
-    ----
-        adf_content: Either a string (already plain text) or ADF document dict
-
-    Returns:
-    -------
-        Plain text string extracted from the ADF content
-
-    """
-    if isinstance(adf_content, str):
-        return adf_content
-
-    if not isinstance(adf_content, dict):
-        return str(adf_content) if adf_content else ""
-
-    def extract_text_recursive(node: dict[str, Any]) -> str:
-        """Recursively extract text from ADF nodes."""
-        if not isinstance(node, dict):
-            return ""
-
-        # If this is a text node, return its text
-        if node.get("type") == "text":
-            return node.get("text", "")
-
-        # If this node has content, process it recursively
-        content = node.get("content", [])
-        if isinstance(content, list):
-            return "".join(extract_text_recursive(child) for child in content)
-
-        return ""
-
-    try:
-        return extract_text_recursive(adf_content)
-    except Exception as e:
-        logger.warning(f"Failed to extract text from ADF: {e}")
-        return str(adf_content) if adf_content else ""
-
-
-class JiraIssueType(str, Enum):
-    """Common JIRA issue types."""
-
-    EPIC = "Epic"
-    STORY = "Story"
-    TASK = "Task"
-    BUG = "Bug"
-    SUBTASK = "Sub-task"
-    IMPROVEMENT = "Improvement"
-    NEW_FEATURE = "New Feature"
-
-
-class JiraPriority(str, Enum):
-    """Standard JIRA priority levels."""
-
-    HIGHEST = "Highest"
-    HIGH = "High"
-    MEDIUM = "Medium"
-    LOW = "Low"
-    LOWEST = "Lowest"
-
-
 class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
     """Adapter for JIRA using REST API v3."""
 
@@ -152,7 +78,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             )
 
         # Configuration
-        self.server = full_config.get("server", "")
+        self.server = full_config.get("server", "").rstrip("/")
         self.email = full_config.get("email", "")
         self.api_token = full_config.get("api_token", "")
         self.project_key = full_config.get("project_key", "")
@@ -161,23 +87,17 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         self.timeout = full_config.get("timeout", 30)
         self.max_retries = full_config.get("max_retries", 3)
 
-        # Clean up server URL
-        self.server = self.server.rstrip("/")
-
-        # API base URL
-        self.api_base = (
-            f"{self.server}/rest/api/3"
-            if self.is_cloud
-            else f"{self.server}/rest/api/2"
+        # Initialize HTTP client
+        self.client = JiraClient(
+            server=self.server,
+            email=self.email,
+            api_token=self.api_token,
+            is_cloud=self.is_cloud,
+            verify_ssl=self.verify_ssl,
+            timeout=self.timeout,
+            max_retries=self.max_retries,
         )
 
-        # HTTP client setup
-        self.auth = httpx.BasicAuth(self.email, self.api_token)
-        self.headers = {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-        }
-
         # Cache for workflow states and transitions
         self._workflow_cache: dict[str, Any] = {}
         self._priority_cache: list[dict[str, Any]] = []
@@ -211,96 +131,12 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
     def _get_state_mapping(self) -> dict[TicketState, str]:
         """Map universal states to common JIRA workflow states."""
-        return {
-            TicketState.OPEN: "To Do",
-            TicketState.IN_PROGRESS: "In Progress",
-            TicketState.READY: "In Review",
-            TicketState.TESTED: "Testing",
-            TicketState.DONE: "Done",
-            TicketState.WAITING: "Waiting",
-            TicketState.BLOCKED: "Blocked",
-            TicketState.CLOSED: "Closed",
-        }
-
-    async def _get_client(self) -> AsyncClient:
-        """Get configured async HTTP client."""
-        return AsyncClient(
-            auth=self.auth,
-            headers=self.headers,
-            timeout=self.timeout,
-            verify=self.verify_ssl,
-        )
-
-    async def _make_request(
-        self,
-        method: str,
-        endpoint: str,
-        data: dict[str, Any] | None = None,
-        params: dict[str, Any] | None = None,
-        retry_count: int = 0,
-    ) -> dict[str, Any]:
-        """Make HTTP request to JIRA API with retry logic.
-
-        Args:
-        ----
-            method: HTTP method
-            endpoint: API endpoint
-            data: Request body data
-            params: Query parameters
-            retry_count: Current retry attempt
-
-        Returns:
-        -------
-            Response data
-
-        Raises:
-        ------
-            HTTPStatusError: On API errors
-            TimeoutException: On timeout
-
-        """
-        url = f"{self.api_base}/{endpoint.lstrip('/')}"
-
-        async with await self._get_client() as client:
-            try:
-                response = await client.request(
-                    method=method, url=url, json=data, params=params
-                )
-                response.raise_for_status()
-
-                # Handle empty responses
-                if response.status_code == 204:
-                    return {}
-
-                return response.json()
-
-            except TimeoutException as e:
-                if retry_count < self.max_retries:
-                    await asyncio.sleep(2**retry_count)  # Exponential backoff
-                    return await self._make_request(
-                        method, endpoint, data, params, retry_count + 1
-                    )
-                raise e
-
-            except HTTPStatusError as e:
-                # Handle rate limiting
-                if e.response.status_code == 429 and retry_count < self.max_retries:
-                    retry_after = int(e.response.headers.get("Retry-After", 5))
-                    await asyncio.sleep(retry_after)
-                    return await self._make_request(
-                        method, endpoint, data, params, retry_count + 1
-                    )
-
-                # Log error details
-                logger.error(
-                    f"JIRA API error: {e.response.status_code} - {e.response.text}"
-                )
-                raise e
+        return get_state_mapping()
 
     async def _get_priorities(self) -> list[dict[str, Any]]:
         """Get available priorities from JIRA."""
         if not self._priority_cache:
-            self._priority_cache = await self._make_request("GET", "priority")
+            self._priority_cache = await self.client.get("priority")
         return self._priority_cache
 
     async def _get_issue_types(
@@ -309,19 +145,19 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         """Get available issue types for a project."""
         key = project_key or self.project_key
         if key not in self._issue_types_cache:
-            data = await self._make_request("GET", f"project/{key}")
+            data = await self.client.get(f"project/{key}")
             self._issue_types_cache[key] = data.get("issueTypes", [])
         return self._issue_types_cache[key]
 
     async def _get_transitions(self, issue_key: str) -> list[dict[str, Any]]:
         """Get available transitions for an issue."""
-        data = await self._make_request("GET", f"issue/{issue_key}/transitions")
+        data = await self.client.get(f"issue/{issue_key}/transitions")
         return data.get("transitions", [])
 
     async def _get_custom_fields(self) -> dict[str, str]:
         """Get custom field definitions."""
         if not self._custom_fields_cache:
-            fields = await self._make_request("GET", "field")
+            fields = await self.client.get("field")
             self._custom_fields_cache = {
                 field["name"]: field["id"]
                 for field in fields
@@ -329,248 +165,6 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             }
         return self._custom_fields_cache
 
-    def _convert_from_adf(self, adf_content: Any) -> str:
-        """Convert Atlassian Document Format (ADF) to plain text.
-
-        This extracts text content from ADF structure for display.
-        """
-        if not adf_content:
-            return ""
-
-        # If it's already a string, return it (JIRA Server)
-        if isinstance(adf_content, str):
-            return adf_content
-
-        # Handle ADF structure
-        if not isinstance(adf_content, dict):
-            return str(adf_content)
-
-        content_nodes = adf_content.get("content", [])
-        lines = []
-
-        for node in content_nodes:
-            if node.get("type") == "paragraph":
-                paragraph_text = ""
-                for content_item in node.get("content", []):
-                    if content_item.get("type") == "text":
-                        paragraph_text += content_item.get("text", "")
-                lines.append(paragraph_text)
-            elif node.get("type") == "heading":
-                heading_text = ""
-                for content_item in node.get("content", []):
-                    if content_item.get("type") == "text":
-                        heading_text += content_item.get("text", "")
-                lines.append(heading_text)
-
-        return "\n".join(lines)
-
-    def _convert_to_adf(self, text: str) -> dict[str, Any]:
-        """Convert plain text to Atlassian Document Format (ADF).
-
-        ADF is required for JIRA Cloud description fields.
-        This creates a simple document with paragraphs for each line.
-        """
-        if not text:
-            return {"type": "doc", "version": 1, "content": []}
-
-        # Split text into lines and create paragraphs
-        lines = text.split("\n")
-        content = []
-
-        for line in lines:
-            if line.strip():  # Non-empty line
-                content.append(
-                    {"type": "paragraph", "content": [{"type": "text", "text": line}]}
-                )
-            else:  # Empty line becomes empty paragraph
-                content.append({"type": "paragraph", "content": []})
-
-        return {"type": "doc", "version": 1, "content": content}
-
-    def _map_priority_to_jira(self, priority: Priority) -> str:
-        """Map universal priority to JIRA priority."""
-        mapping = {
-            Priority.CRITICAL: JiraPriority.HIGHEST,
-            Priority.HIGH: JiraPriority.HIGH,
-            Priority.MEDIUM: JiraPriority.MEDIUM,
-            Priority.LOW: JiraPriority.LOW,
-        }
-        return mapping.get(priority, JiraPriority.MEDIUM)
-
-    def _map_priority_from_jira(self, jira_priority: dict[str, Any] | None) -> Priority:
-        """Map JIRA priority to universal priority."""
-        if not jira_priority:
-            return Priority.MEDIUM
-
-        name = jira_priority.get("name", "").lower()
-
-        if "highest" in name or "urgent" in name or "critical" in name:
-            return Priority.CRITICAL
-        elif "high" in name:
-            return Priority.HIGH
-        elif "low" in name:
-            return Priority.LOW
-        else:
-            return Priority.MEDIUM
-
-    def _map_state_from_jira(self, status: dict[str, Any]) -> TicketState:
-        """Map JIRA status to universal state."""
-        if not status:
-            return TicketState.OPEN
-
-        name = status.get("name", "").lower()
-        category = status.get("statusCategory", {}).get("key", "").lower()
-
-        # Try to match by category first (more reliable)
-        if category == "new":
-            return TicketState.OPEN
-        elif category == "indeterminate":
-            return TicketState.IN_PROGRESS
-        elif category == "done":
-            return TicketState.DONE
-
-        # Fall back to name matching
-        if "block" in name:
-            return TicketState.BLOCKED
-        elif "wait" in name:
-            return TicketState.WAITING
-        elif "progress" in name or "doing" in name:
-            return TicketState.IN_PROGRESS
-        elif "review" in name:
-            return TicketState.READY
-        elif "test" in name:
-            return TicketState.TESTED
-        elif "done" in name or "resolved" in name:
-            return TicketState.DONE
-        elif "closed" in name:
-            return TicketState.CLOSED
-        else:
-            return TicketState.OPEN
-
-    def _issue_to_ticket(self, issue: dict[str, Any]) -> Epic | Task:
-        """Convert JIRA issue to universal ticket model."""
-        fields = issue.get("fields", {})
-
-        # Determine ticket type
-        issue_type = fields.get("issuetype", {}).get("name", "").lower()
-        is_epic = "epic" in issue_type
-
-        # Extract common fields
-        # Convert ADF description back to plain text if needed
-        description = self._convert_from_adf(fields.get("description", ""))
-
-        base_data = {
-            "id": issue.get("key"),
-            "title": fields.get("summary", ""),
-            "description": description,
-            "state": self._map_state_from_jira(fields.get("status", {})),
-            "priority": self._map_priority_from_jira(fields.get("priority")),
-            "tags": [
-                label.get("name", "") if isinstance(label, dict) else str(label)
-                for label in fields.get("labels", [])
-            ],
-            "created_at": parse_jira_datetime(fields.get("created")),
-            "updated_at": parse_jira_datetime(fields.get("updated")),
-            "metadata": {
-                "jira": {
-                    "id": issue.get("id"),
-                    "key": issue.get("key"),
-                    "self": issue.get("self"),
-                    "url": f"{self.server}/browse/{issue.get('key')}",
-                    "issue_type": fields.get("issuetype", {}),
-                    "project": fields.get("project", {}),
-                    "components": fields.get("components", []),
-                    "fix_versions": fields.get("fixVersions", []),
-                    "resolution": fields.get("resolution"),
-                }
-            },
-        }
-
-        if is_epic:
-            # Create Epic
-            return Epic(
-                **base_data,
-                child_issues=[
-                    subtask.get("key") for subtask in fields.get("subtasks", [])
-                ],
-            )
-        else:
-            # Create Task
-            parent = fields.get("parent", {})
-            epic_link = fields.get("customfield_10014")  # Common epic link field
-
-            return Task(
-                **base_data,
-                parent_issue=parent.get("key") if parent else None,
-                parent_epic=epic_link if epic_link else None,
-                assignee=(
-                    fields.get("assignee", {}).get("displayName")
-                    if fields.get("assignee")
-                    else None
-                ),
-                estimated_hours=(
-                    fields.get("timetracking", {}).get("originalEstimateSeconds", 0)
-                    / 3600
-                    if fields.get("timetracking")
-                    else None
-                ),
-                actual_hours=(
-                    fields.get("timetracking", {}).get("timeSpentSeconds", 0) / 3600
-                    if fields.get("timetracking")
-                    else None
-                ),
-            )
-
-    def _ticket_to_issue_fields(
-        self, ticket: Epic | Task, issue_type: str | None = None
-    ) -> dict[str, Any]:
-        """Convert universal ticket to JIRA issue fields."""
-        # Convert description to ADF format for JIRA Cloud
-        description = (
-            self._convert_to_adf(ticket.description or "")
-            if self.is_cloud
-            else (ticket.description or "")
-        )
-
-        fields = {
-            "summary": ticket.title,
-            "description": description,
-            "labels": ticket.tags,
-        }
-
-        # Only add priority for Tasks, not Epics (some JIRA configurations don't allow priority on Epics)
-        if isinstance(ticket, Task):
-            fields["priority"] = {"name": self._map_priority_to_jira(ticket.priority)}
-
-        # Add project if creating new issue
-        if not ticket.id and self.project_key:
-            fields["project"] = {"key": self.project_key}
-
-        # Set issue type
-        if issue_type:
-            fields["issuetype"] = {"name": issue_type}
-        elif isinstance(ticket, Epic):
-            fields["issuetype"] = {"name": JiraIssueType.EPIC}
-        else:
-            fields["issuetype"] = {"name": JiraIssueType.TASK}
-
-        # Add task-specific fields
-        if isinstance(ticket, Task):
-            if ticket.assignee:
-                # Note: Need to resolve user account ID
-                fields["assignee"] = {"accountId": ticket.assignee}
-
-            if ticket.parent_issue:
-                fields["parent"] = {"key": ticket.parent_issue}
-
-            # Time tracking
-            if ticket.estimated_hours:
-                fields["timetracking"] = {
-                    "originalEstimate": f"{int(ticket.estimated_hours)}h"
-                }
-
-        return fields
-
     async def create(self, ticket: Epic | Task) -> Epic | Task:
         """Create a new JIRA issue."""
         # Validate credentials before attempting operation
@@ -579,17 +173,21 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             raise ValueError(error_message)
 
         # Prepare issue fields
-        fields = self._ticket_to_issue_fields(ticket)
+        fields = ticket_to_issue_fields(
+            ticket,
+            is_cloud=self.is_cloud,
+            project_key=self.project_key,
+        )
 
         # Create issue
-        data = await self._make_request("POST", "issue", data={"fields": fields})
+        data = await self.client.post("issue", data={"fields": fields})
 
         # Set the ID and fetch full issue data
         ticket.id = data.get("key")
 
         # Fetch complete issue data
-        created_issue = await self._make_request("GET", f"issue/{ticket.id}")
-        return self._issue_to_ticket(created_issue)
+        created_issue = await self.client.get(f"issue/{ticket.id}")
+        return issue_to_ticket(created_issue, self.server)
 
     async def read(self, ticket_id: str) -> Epic | Task | None:
         """Read a JIRA issue by key."""
@@ -599,10 +197,10 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             raise ValueError(error_message)
 
         try:
-            issue = await self._make_request(
-                "GET", f"issue/{ticket_id}", params={"expand": "renderedFields"}
+            issue = await self.client.get(
+                f"issue/{ticket_id}", params={"expand": "renderedFields"}
             )
-            return self._issue_to_ticket(issue)
+            return issue_to_ticket(issue, self.server)
         except HTTPStatusError as e:
             if e.response.status_code == 404:
                 return None
@@ -623,26 +221,11 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             return None
 
         # Prepare update fields
-        fields = {}
-
-        if "title" in updates:
-            fields["summary"] = updates["title"]
-        if "description" in updates:
-            fields["description"] = updates["description"]
-        if "priority" in updates:
-            fields["priority"] = {
-                "name": self._map_priority_to_jira(updates["priority"])
-            }
-        if "tags" in updates:
-            fields["labels"] = updates["tags"]
-        if "assignee" in updates:
-            fields["assignee"] = {"accountId": updates["assignee"]}
+        fields = map_update_fields(updates, is_cloud=self.is_cloud)
 
         # Apply update
         if fields:
-            await self._make_request(
-                "PUT", f"issue/{ticket_id}", data={"fields": fields}
-            )
+            await self.client.put(f"issue/{ticket_id}", data={"fields": fields})
 
         # Handle state transitions separately
         if "state" in updates:
@@ -659,7 +242,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             raise ValueError(error_message)
 
         try:
-            await self._make_request("DELETE", f"issue/{ticket_id}")
+            await self.client.delete(f"issue/{ticket_id}")
             return True
         except HTTPStatusError as e:
             if e.response.status_code == 404:
@@ -671,91 +254,40 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
     ) -> list[Epic | Task]:
         """List JIRA issues with pagination."""
         # Build JQL query
-        jql_parts = []
-
-        if self.project_key:
-            jql_parts.append(f"project = {self.project_key}")
-
-        if filters:
-            if "state" in filters:
-                status = self.map_state_to_system(filters["state"])
-                jql_parts.append(f'status = "{status}"')
-            if "priority" in filters:
-                priority = self._map_priority_to_jira(filters["priority"])
-                jql_parts.append(f'priority = "{priority}"')
-            if "assignee" in filters:
-                jql_parts.append(f'assignee = "{filters["assignee"]}"')
-            if "ticket_type" in filters:
-                jql_parts.append(f'issuetype = "{filters["ticket_type"]}"')
-
-        jql = " AND ".join(jql_parts) if jql_parts else "ORDER BY created DESC"
+        jql = build_list_jql(
+            self.project_key,
+            filters=filters,
+            state_mapper=self.map_state_to_system,
+        )
 
         # Search issues using the JIRA API endpoint
-        data = await self._make_request(
-            "GET",
-            "search/jql",  # JIRA search endpoint (new API v3)
-            params={
-                "jql": jql,
-                "startAt": offset,
-                "maxResults": limit,
-                "fields": "*all",
-                "expand": "renderedFields",
-            },
-        )
+        params = get_search_params(jql, start_at=offset, max_results=limit)
+        data = await self.client.get("search/jql", params=params)
 
         # Convert issues
         issues = data.get("issues", [])
-        return [self._issue_to_ticket(issue) for issue in issues]
+        return [issue_to_ticket(issue, self.server) for issue in issues]
 
     async def search(self, query: SearchQuery) -> builtins.list[Epic | Task]:
         """Search JIRA issues using JQL."""
         # Build JQL query
-        jql_parts = []
-
-        if self.project_key:
-            jql_parts.append(f"project = {self.project_key}")
-
-        # Text search
-        if query.query:
-            jql_parts.append(f'text ~ "{query.query}"')
-
-        # State filter
-        if query.state:
-            status = self.map_state_to_system(query.state)
-            jql_parts.append(f'status = "{status}"')
-
-        # Priority filter
-        if query.priority:
-            priority = self._map_priority_to_jira(query.priority)
-            jql_parts.append(f'priority = "{priority}"')
-
-        # Assignee filter
-        if query.assignee:
-            jql_parts.append(f'assignee = "{query.assignee}"')
-
-        # Tags/labels filter
-        if query.tags:
-            label_conditions = [f'labels = "{tag}"' for tag in query.tags]
-            jql_parts.append(f"({' OR '.join(label_conditions)})")
-
-        jql = " AND ".join(jql_parts) if jql_parts else "ORDER BY created DESC"
+        jql = build_search_jql(
+            self.project_key,
+            query,
+            state_mapper=self.map_state_to_system,
+        )
 
         # Execute search using the JIRA API endpoint
-        data = await self._make_request(
-            "GET",
-            "search/jql",  # JIRA search endpoint (new API v3)
-            params={
-                "jql": jql,
-                "startAt": query.offset,
-                "maxResults": query.limit,
-                "fields": "*all",
-                "expand": "renderedFields",
-            },
+        params = get_search_params(
+            jql,
+            start_at=query.offset,
+            max_results=query.limit,
         )
+        data = await self.client.get("search/jql", params=params)
 
         # Convert and return results
         issues = data.get("issues", [])
-        return [self._issue_to_ticket(issue) for issue in issues]
+        return [issue_to_ticket(issue, self.server) for issue in issues]
 
     async def transition_state(
         self, ticket_id: str, target_state: TicketState
@@ -799,8 +331,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             return None
 
         # Execute transition
-        await self._make_request(
-            "POST",
+        await self.client.post(
             f"issue/{ticket_id}/transitions",
             data={"transition": {"id": transition["id"]}},
         )
@@ -825,9 +356,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         }
 
         # Add comment
-        result = await self._make_request(
-            "POST", f"issue/{comment.ticket_id}/comment", data=data
-        )
+        result = await self.client.post(f"issue/{comment.ticket_id}/comment", data=data)
 
         # Update comment with JIRA data
         comment.id = result.get("id")
@@ -846,7 +375,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         # Fetch issue with comments
         params = {"expand": "comments", "fields": "comment"}
 
-        issue = await self._make_request("GET", f"issue/{ticket_id}", params=params)
+        issue = await self.client.get(f"issue/{ticket_id}", params=params)
 
         # Extract comments
         comments_data = issue.get("fields", {}).get("comment", {}).get("comments", [])
@@ -879,7 +408,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         if not key:
             raise ValueError("Project key is required")
 
-        project = await self._make_request("GET", f"project/{key}")
+        project = await self.client.get(f"project/{key}")
 
         # Get additional project details
         issue_types = await self._get_issue_types(key)
@@ -908,8 +437,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             List of matching tickets
 
         """
-        data = await self._make_request(
-            "POST",
+        data = await self.client.post(
             "search",
             data={
                 "jql": jql,
@@ -920,7 +448,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         )
 
         issues = data.get("issues", [])
-        return [self._issue_to_ticket(issue) for issue in issues]
+        return [issue_to_ticket(issue, self.server) for issue in issues]
 
     async def get_sprints(
         self, board_id: int | None = None
@@ -938,8 +466,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         """
         if not board_id:
             # Try to find a board for the project
-            boards_data = await self._make_request(
-                "GET",
+            boards_data = await self.client.get(
                 "/rest/agile/1.0/board",
                 params={"projectKeyOrId": self.project_key},
             )
@@ -949,8 +476,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             board_id = boards[0]["id"]
 
         # Get sprints for the board
-        sprints_data = await self._make_request(
-            "GET",
+        sprints_data = await self.client.get(
             f"/rest/agile/1.0/board/{board_id}/sprint",
             params={"state": "active,future"},
         )
@@ -964,9 +490,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
         try:
             # Get project role users
-            project_data = await self._make_request(
-                "GET", f"project/{self.project_key}"
-            )
+            project_data = await self.client.get(f"project/{self.project_key}")
 
             # Get users from project roles
             users = []
@@ -975,8 +499,8 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
                     # Extract role ID from URL
                     role_id = role_url.split("/")[-1]
                     try:
-                        role_data = await self._make_request(
-                            "GET", f"project/{self.project_key}/role/{role_id}"
+                        role_data = await self.client.get(
+                            f"project/{self.project_key}/role/{role_id}"
                         )
                         if "actors" in role_data:
                             for actor in role_data["actors"]:
@@ -1000,8 +524,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         except Exception:
             # Fallback: try to get assignable users for the project
             try:
-                users_data = await self._make_request(
-                    "GET",
+                users_data = await self.client.get(
                     "user/assignable/search",
                     params={"project": self.project_key, "maxResults": 50},
                 )
@@ -1012,7 +535,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
     async def get_current_user(self) -> dict[str, Any] | None:
         """Get current authenticated user information."""
         try:
-            return await self._make_request("GET", "myself")
+            return await self.client.get("myself")
         except Exception:
             return None
 
@@ -1030,15 +553,8 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         try:
             # Query recent issues to get labels in use
             jql = f"project = {self.project_key} ORDER BY updated DESC"
-            data = await self._make_request(
-                "GET",
-                "search/jql",
-                params={
-                    "jql": jql,
-                    "maxResults": 100,  # Sample from recent 100 issues
-                    "fields": "labels",
-                },
-            )
+            params = get_labels_search_params(jql, max_results=100)
+            data = await self.client.get("search/jql", params=params)
 
             # Collect unique labels
             unique_labels = set()
@@ -1138,16 +654,9 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
         try:
             # Query recent issues to get labels in use
-            jql = f"project = {key} ORDER BY updated DESC"
-            data = await self._make_request(
-                "GET",
-                "search/jql",
-                params={
-                    "jql": jql,
-                    "maxResults": 500,  # Sample from more issues for better coverage
-                    "fields": "labels",
-                },
-            )
+            jql = build_project_labels_jql(key, max_results=500)
+            params = get_labels_search_params(jql, max_results=500)
+            data = await self.client.get("search/jql", params=params)
 
             # Collect labels with usage count
             label_counts: dict[str, int] = {}
@@ -1211,8 +720,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         try:
             # If no board_id provided, try to find a board for the project
             if not board_id:
-                boards_data = await self._make_request(
-                    "GET",
+                boards_data = await self.client.get(
                     "/rest/agile/1.0/board",
                     params={"projectKeyOrId": self.project_key, "maxResults": 1},
                 )
@@ -1229,8 +737,8 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             if state:
                 params["state"] = state
 
-            sprints_data = await self._make_request(
-                "GET", f"/rest/agile/1.0/board/{board_id}/sprint", params=params
+            sprints_data = await self.client.get(
+                f"/rest/agile/1.0/board/{board_id}/sprint", params=params
             )
 
             sprints = sprints_data.get("values", [])
@@ -1292,9 +800,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             # Use project-specific statuses if project key provided
             if project_key:
                 # Get statuses for the project
-                data = await self._make_request(
-                    "GET", f"project/{project_key}/statuses"
-                )
+                data = await self.client.get(f"project/{project_key}/statuses")
 
                 # Extract unique statuses from all issue types
                 status_map: dict[str, dict[str, Any]] = {}
@@ -1307,7 +813,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
                 statuses = list(status_map.values())
             else:
                 # Get all statuses
-                statuses = await self._make_request("GET", "status")
+                statuses = await self.client.get("status")
 
             # Transform to standardized format
             return [
@@ -1358,8 +864,8 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
         try:
             # Get issue with status field
-            issue = await self._make_request(
-                "GET", f"issue/{issue_key}", params={"fields": "status"}
+            issue = await self.client.get(
+                f"issue/{issue_key}", params={"fields": "status"}
             )
 
             if not issue:
@@ -1368,9 +874,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             status = issue.get("fields", {}).get("status", {})
 
             # Get available transitions
-            transitions_data = await self._make_request(
-                "GET", f"issue/{issue_key}/transitions"
-            )
+            transitions_data = await self.client.get(f"issue/{issue_key}/transitions")
             transitions = transitions_data.get("transitions", [])
 
             # Transform transitions to simplified format
@@ -1517,34 +1021,19 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             raise ValueError(error_message)
 
         # Build JQL query for epics
-        jql_parts = [f"project = {self.project_key}", 'issuetype = "Epic"']
-
-        # Add state filter if provided
-        if state:
-            jql_parts.append(f'status = "{state}"')
-
-        jql = " AND ".join(jql_parts) + " ORDER BY updated DESC"
+        jql = build_epic_list_jql(self.project_key, state=state)
 
         try:
             # Execute search
-            data = await self._make_request(
-                "GET",
-                "search/jql",
-                params={
-                    "jql": jql,
-                    "startAt": offset,
-                    "maxResults": limit,
-                    "fields": "*all",
-                    "expand": "renderedFields",
-                },
-            )
+            params = get_search_params(jql, start_at=offset, max_results=limit)
+            data = await self.client.get("search/jql", params=params)
 
             # Convert issues to tickets
             issues = data.get("issues", [])
             epics = []
 
             for issue in issues:
-                ticket = self._issue_to_ticket(issue)
+                ticket = issue_to_ticket(issue, self.server)
                 # Only include if it's actually an Epic
                 if isinstance(ticket, Epic):
                     epics.append(ticket)
@@ -1577,37 +1066,14 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             HTTPStatusError: If update fails
 
         """
-        fields = {}
-
-        # Map title to summary
-        if "title" in updates:
-            fields["summary"] = updates["title"]
-
-        # Convert description to ADF format
-        if "description" in updates:
-            fields["description"] = self._convert_to_adf(updates["description"])
-
-        # Map tags to labels
-        if "tags" in updates:
-            fields["labels"] = updates["tags"]
-
-        # Map priority (some JIRA configs allow priority on Epics)
-        if "priority" in updates:
-            priority_value = updates["priority"]
-            if isinstance(priority_value, Priority):
-                fields["priority"] = {
-                    "name": self._map_priority_to_jira(priority_value)
-                }
-            else:
-                # String priority passed directly
-                fields["priority"] = {"name": priority_value}
+        fields = map_epic_update_fields(updates)
 
         if not fields and "state" not in updates:
             raise ValueError("At least one field must be updated")
 
         # Apply field updates if any
         if fields:
-            await self._make_request("PUT", f"issue/{epic_id}", data={"fields": fields})
+            await self.client.put(f"issue/{epic_id}", data={"fields": fields})
 
         # Handle state transitions separately (JIRA uses workflow transitions)
         if "state" in updates:
@@ -1638,8 +1104,6 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             HTTPStatusError: If upload fails
 
         """
-        from pathlib import Path
-
         # Validate credentials before attempting operation
         is_valid, error_message = self.validate_credentials()
         if not is_valid:
@@ -1649,40 +1113,28 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         if not file_path_obj.exists():
             raise FileNotFoundError(f"File not found: {file_path}")
 
-        # JIRA requires special header for attachment upload
-        headers = {
-            "X-Atlassian-Token": "no-check",
-            # Don't set Content-Type - let httpx handle multipart
-        }
-
-        # Prepare multipart file upload
-        with open(file_path_obj, "rb") as f:
-            files = {"file": (file_path_obj.name, f, "application/octet-stream")}
-
-            url = f"{self.api_base}/issue/{ticket_id}/attachments"
-
-            # Use existing client infrastructure
-            async with await self._get_client() as client:
-                response = await client.post(
-                    url, files=files, headers={**self.headers, **headers}
-                )
-                response.raise_for_status()
-
-                # JIRA returns array with single attachment
-                attachment_data = response.json()[0]
+        # Upload file
+        result = await self.client.upload_file(
+            f"issue/{ticket_id}/attachments",
+            str(file_path_obj),
+            file_path_obj.name,
+        )
 
-                return Attachment(
-                    id=attachment_data["id"],
-                    ticket_id=ticket_id,
-                    filename=attachment_data["filename"],
-                    url=attachment_data["content"],
-                    content_type=attachment_data["mimeType"],
-                    size_bytes=attachment_data["size"],
-                    created_at=parse_jira_datetime(attachment_data["created"]),
-                    created_by=attachment_data["author"]["displayName"],
-                    description=description,
-                    metadata={"jira": attachment_data},
-                )
+        # JIRA returns array with single attachment
+        attachment_data = result[0]
+
+        return Attachment(
+            id=attachment_data["id"],
+            ticket_id=ticket_id,
+            filename=attachment_data["filename"],
+            url=attachment_data["content"],
+            content_type=attachment_data["mimeType"],
+            size_bytes=attachment_data["size"],
+            created_at=parse_jira_datetime(attachment_data["created"]),
+            created_by=attachment_data["author"]["displayName"],
+            description=description,
+            metadata={"jira": attachment_data},
+        )
 
     async def get_attachments(self, ticket_id: str) -> builtins.list[Attachment]:
         """Get all attachments for a JIRA issue.
@@ -1707,8 +1159,8 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             raise ValueError(error_message)
 
         # Fetch issue with attachment field
-        issue = await self._make_request(
-            "GET", f"issue/{ticket_id}", params={"fields": "attachment"}
+        issue = await self.client.get(
+            f"issue/{ticket_id}", params={"fields": "attachment"}
         )
 
         attachments = []
@@ -1752,7 +1204,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             raise ValueError(error_message)
 
         try:
-            await self._make_request("DELETE", f"attachment/{attachment_id}")
+            await self.client.delete(f"attachment/{attachment_id}")
             return True
         except HTTPStatusError as e:
             if e.response.status_code == 404:
@@ -1774,6 +1226,126 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         self._issue_types_cache.clear()
         self._custom_fields_cache.clear()
 
+    # Milestone Methods (Not yet implemented)
+
+    async def milestone_create(
+        self,
+        name: str,
+        target_date: datetime | None = None,
+        labels: list[str] | None = None,
+        description: str = "",
+        project_id: str | None = None,
+    ) -> Any:
+        """Create milestone - not yet implemented for Jira.
+
+        Args:
+        ----
+            name: Milestone name
+            target_date: Target completion date
+            labels: Labels that define this milestone
+            description: Milestone description
+            project_id: Associated project ID
+
+        Raises:
+        ------
+            NotImplementedError: Milestone support coming in v2.1.0
+
+        """
+        raise NotImplementedError("Milestone support for Jira coming in v2.1.0")
+
+    async def milestone_get(self, milestone_id: str) -> Any:
+        """Get milestone - not yet implemented for Jira.
+
+        Args:
+        ----
+            milestone_id: Milestone identifier
+
+        Raises:
+        ------
+            NotImplementedError: Milestone support coming in v2.1.0
+
+        """
+        raise NotImplementedError("Milestone support for Jira coming in v2.1.0")
+
+    async def milestone_list(
+        self,
+        project_id: str | None = None,
+        state: str | None = None,
+    ) -> list[Any]:
+        """List milestones - not yet implemented for Jira.
+
+        Args:
+        ----
+            project_id: Filter by project
+            state: Filter by state
+
+        Raises:
+        ------
+            NotImplementedError: Milestone support coming in v2.1.0
+
+        """
+        raise NotImplementedError("Milestone support for Jira coming in v2.1.0")
+
+    async def milestone_update(
+        self,
+        milestone_id: str,
+        name: str | None = None,
+        target_date: datetime | None = None,
+        state: str | None = None,
+        labels: list[str] | None = None,
+        description: str | None = None,
+    ) -> Any:
+        """Update milestone - not yet implemented for Jira.
+
+        Args:
+        ----
+            milestone_id: Milestone identifier
+            name: New name
+            target_date: New target date
+            state: New state
+            labels: New labels
+            description: New description
+
+        Raises:
+        ------
+            NotImplementedError: Milestone support coming in v2.1.0
+
+        """
+        raise NotImplementedError("Milestone support for Jira coming in v2.1.0")
+
+    async def milestone_delete(self, milestone_id: str) -> bool:
+        """Delete milestone - not yet implemented for Jira.
+
+        Args:
+        ----
+            milestone_id: Milestone identifier
+
+        Raises:
+        ------
+            NotImplementedError: Milestone support coming in v2.1.0
+
+        """
+        raise NotImplementedError("Milestone support for Jira coming in v2.1.0")
+
+    async def milestone_get_issues(
+        self,
+        milestone_id: str,
+        state: str | None = None,
+    ) -> list[Any]:
+        """Get milestone issues - not yet implemented for Jira.
+
+        Args:
+        ----
+            milestone_id: Milestone identifier
+            state: Filter by issue state
+
+        Raises:
+        ------
+            NotImplementedError: Milestone support coming in v2.1.0
+
+        """
+        raise NotImplementedError("Milestone support for Jira coming in v2.1.0")
+
 
 # Register the adapter
 AdapterRegistry.register("jira", JiraAdapter)