mcp-ticketer 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

mcp_ticketer/__version__.py

@@ -1,6 +1,6 @@
 """Version information for mcp-ticketer package."""
 
-__version__ = "0.4.2"
+__version__ = "0.4.4"
 __version_info__ = tuple(int(part) for part in __version__.split("."))
 
 # Package metadata

mcp_ticketer/adapters/aitrackdown.py

@@ -2,12 +2,23 @@
 
 import builtins
 import json
+import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 
 from ..core.adapter import BaseAdapter
-from ..core.models import Comment, Epic, Priority, SearchQuery, Task, TicketState
+
+logger = logging.getLogger(__name__)
+from ..core.models import (
+    Attachment,
+    Comment,
+    Epic,
+    Priority,
+    SearchQuery,
+    Task,
+    TicketState,
+)
 from ..core.registry import AdapterRegistry
 
 # Import ai-trackdown-pytools when available
@@ -80,7 +91,7 @@ class AITrackdownAdapter(BaseAdapter[Task]):
             TicketState.CLOSED: "closed",
         }
 
-    def _priority_to_ai(self, priority: Union[Priority, str]) -> str:
+    def _priority_to_ai(self, priority: Priority | str) -> str:
         """Convert universal priority to AI-Trackdown priority."""
         if isinstance(priority, Priority):
             return priority.value
@@ -219,7 +230,7 @@ class AITrackdownAdapter(BaseAdapter[Task]):
             "type": "epic",
         }
 
-    def _read_ticket_file(self, ticket_id: str) -> Optional[dict[str, Any]]:
+    def _read_ticket_file(self, ticket_id: str) -> dict[str, Any] | None:
         """Read ticket from file system."""
         ticket_file = self.tickets_dir / f"{ticket_id}.json"
         if ticket_file.exists():
@@ -233,7 +244,7 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         with open(ticket_file, "w") as f:
             json.dump(data, f, indent=2, default=str)
 
-    async def create(self, ticket: Union[Task, Epic]) -> Union[Task, Epic]:
+    async def create(self, ticket: Task | Epic) -> Task | Epic:
         """Create a new task."""
         # Generate ID if not provided
         if not ticket.id:
@@ -324,7 +335,7 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         )
         return await self.create(task)
 
-    async def read(self, ticket_id: str) -> Optional[Union[Task, Epic]]:
+    async def read(self, ticket_id: str) -> Task | Epic | None:
         """Read a task by ID."""
         if self.tracker:
             ai_ticket = self.tracker.get_ticket(ticket_id)
@@ -340,8 +351,8 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         return None
 
     async def update(
-        self, ticket_id: str, updates: Union[dict[str, Any], Task]
-    ) -> Optional[Union[Task, Epic]]:
+        self, ticket_id: str, updates: dict[str, Any] | Task
+    ) -> Task | Epic | None:
         """Update a task or epic.
 
         Args:
@@ -403,7 +414,7 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         return False
 
     async def list(
-        self, limit: int = 10, offset: int = 0, filters: Optional[dict[str, Any]] = None
+        self, limit: int = 10, offset: int = 0, filters: dict[str, Any] | None = None
     ) -> list[Task]:
         """List tasks with pagination."""
         tasks = []
@@ -487,7 +498,7 @@ class AITrackdownAdapter(BaseAdapter[Task]):
 
     async def transition_state(
         self, ticket_id: str, target_state: TicketState
-    ) -> Optional[Task]:
+    ) -> Task | None:
         """Transition task to new state."""
         # Validate transition
         if not await self.validate_transition(ticket_id, target_state):
@@ -534,7 +545,7 @@ class AITrackdownAdapter(BaseAdapter[Task]):
         # Apply limit and offset AFTER filtering
         return comments[offset : offset + limit]
 
-    async def get_epic(self, epic_id: str) -> Optional[Epic]:
+    async def get_epic(self, epic_id: str) -> Epic | None:
         """Get epic by ID.
 
         Args:
@@ -612,6 +623,238 @@ class AITrackdownAdapter(BaseAdapter[Task]):
                 tasks.append(ticket)
         return tasks
 
+    def _sanitize_filename(self, filename: str) -> str:
+        """Sanitize filename to prevent security issues.
+
+        Args:
+            filename: Original filename
+
+        Returns:
+            Sanitized filename safe for filesystem
+
+        """
+        # Remove path separators and other dangerous characters
+        safe_chars = set(
+            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._- "
+        )
+        sanitized = "".join(c if c in safe_chars else "_" for c in filename)
+
+        # Ensure filename is not empty
+        if not sanitized.strip():
+            return "unnamed_file"
+
+        return sanitized.strip()
+
+    def _guess_content_type(self, file_path: Path) -> str:
+        """Guess MIME type from file extension.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            MIME type string
+
+        """
+        import mimetypes
+
+        content_type, _ = mimetypes.guess_type(str(file_path))
+        return content_type or "application/octet-stream"
+
+    def _calculate_checksum(self, file_path: Path) -> str:
+        """Calculate SHA256 checksum of file.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            Hexadecimal checksum string
+
+        """
+        import hashlib
+
+        sha256 = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            # Read in chunks to handle large files
+            for chunk in iter(lambda: f.read(4096), b""):
+                sha256.update(chunk)
+
+        return sha256.hexdigest()
+
+    async def add_attachment(
+        self,
+        ticket_id: str,
+        file_path: str,
+        description: str | None = None,
+    ) -> Attachment:
+        """Attach a file to a ticket (local filesystem storage).
+
+        Args:
+            ticket_id: Ticket identifier
+            file_path: Local file path to attach
+            description: Optional attachment description
+
+        Returns:
+            Attachment metadata
+
+        Raises:
+            ValueError: If ticket doesn't exist
+            FileNotFoundError: If file doesn't exist
+
+        """
+        import shutil
+
+        # Validate ticket exists
+        ticket = await self.read(ticket_id)
+        if not ticket:
+            raise ValueError(f"Ticket {ticket_id} not found")
+
+        # Validate file exists
+        source_path = Path(file_path).resolve()
+        if not source_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        # Check file size (max 100MB for local storage)
+        size_mb = source_path.stat().st_size / (1024 * 1024)
+        if size_mb > 100:
+            raise ValueError(f"File too large: {size_mb:.2f}MB (max: 100MB)")
+
+        # Create attachments directory for this ticket
+        attachments_dir = self.base_path / "attachments" / ticket_id
+        attachments_dir.mkdir(parents=True, exist_ok=True)
+
+        # Generate unique filename with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S%f")
+        safe_filename = self._sanitize_filename(source_path.name)
+        attachment_id = f"{timestamp}-{safe_filename}"
+        dest_path = attachments_dir / attachment_id
+
+        # Copy file to attachments directory
+        shutil.copy2(source_path, dest_path)
+
+        # Create attachment metadata
+        attachment = Attachment(
+            id=attachment_id,
+            ticket_id=ticket_id,
+            filename=source_path.name,
+            url=f"file://{dest_path.absolute()}",
+            content_type=self._guess_content_type(source_path),
+            size_bytes=source_path.stat().st_size,
+            created_at=datetime.now(),
+            description=description,
+            metadata={
+                "original_path": str(source_path),
+                "storage_path": str(dest_path),
+                "checksum": self._calculate_checksum(dest_path),
+            },
+        )
+
+        # Save metadata to JSON file
+        metadata_file = attachments_dir / f"{attachment_id}.json"
+        with open(metadata_file, "w") as f:
+            # Convert to dict and handle datetime serialization
+            data = attachment.model_dump()
+            json.dump(data, f, indent=2, default=str)
+
+        return attachment
+
+    async def get_attachments(self, ticket_id: str) -> builtins.list[Attachment]:
+        """Get all attachments for a ticket with path traversal protection.
+
+        Args:
+            ticket_id: Ticket identifier
+
+        Returns:
+            List of attachments (empty if none)
+
+        """
+        # Resolve and validate attachments directory
+        attachments_dir = (self.base_path / "attachments" / ticket_id).resolve()
+
+        # CRITICAL SECURITY CHECK: Ensure ticket directory is within base attachments
+        base_attachments = (self.base_path / "attachments").resolve()
+        if not str(attachments_dir).startswith(str(base_attachments)):
+            raise ValueError("Invalid ticket_id: path traversal detected")
+
+        if not attachments_dir.exists():
+            return []
+
+        attachments = []
+        for metadata_file in attachments_dir.glob("*.json"):
+            try:
+                with open(metadata_file) as f:
+                    data = json.load(f)
+                    # Convert ISO datetime strings back to datetime objects
+                    if isinstance(data.get("created_at"), str):
+                        data["created_at"] = datetime.fromisoformat(
+                            data["created_at"].replace("Z", "+00:00")
+                        )
+                    attachment = Attachment(**data)
+                    attachments.append(attachment)
+            except (json.JSONDecodeError, ValueError) as e:
+                # Log error but continue processing other attachments
+                logger.warning(
+                    "Failed to load attachment metadata from %s: %s",
+                    metadata_file,
+                    e,
+                )
+                continue
+
+        # Sort by creation time (newest first)
+        return sorted(
+            attachments,
+            key=lambda a: a.created_at or datetime.min,
+            reverse=True,
+        )
+
+    async def delete_attachment(
+        self,
+        ticket_id: str,
+        attachment_id: str,
+    ) -> bool:
+        """Delete an attachment and its metadata with path traversal protection.
+
+        Args:
+            ticket_id: Ticket identifier
+            attachment_id: Attachment identifier
+
+        Returns:
+            True if deleted, False if not found
+
+        """
+        # Resolve base directory
+        attachments_dir = (self.base_path / "attachments" / ticket_id).resolve()
+
+        # Validate attachments directory exists
+        if not attachments_dir.exists():
+            return False
+
+        # Resolve file paths
+        attachment_file = (attachments_dir / attachment_id).resolve()
+        metadata_file = (attachments_dir / f"{attachment_id}.json").resolve()
+
+        # CRITICAL SECURITY CHECK: Ensure paths are within attachments_dir
+        base_resolved = attachments_dir.resolve()
+        if not str(attachment_file).startswith(str(base_resolved)):
+            raise ValueError(
+                "Invalid attachment path: path traversal detected in attachment_id"
+            )
+        if not str(metadata_file).startswith(str(base_resolved)):
+            raise ValueError(
+                "Invalid attachment path: path traversal detected in attachment_id"
+            )
+
+        # Delete files if they exist
+        deleted = False
+        if attachment_file.exists():
+            attachment_file.unlink()
+            deleted = True
+
+        if metadata_file.exists():
+            metadata_file.unlink()
+            deleted = True
+
+        return deleted
+
 
 # Register the adapter
 AdapterRegistry.register("aitrackdown", AITrackdownAdapter)

mcp_ticketer/adapters/github.py

@@ -3,7 +3,7 @@
 import builtins
 import re
 from datetime import datetime
-from typing import Any, Optional
+from typing import Any
 
 import httpx
 
@@ -198,8 +198,8 @@ class GitHubAdapter(BaseAdapter[Task]):
         )
 
         # Cache for labels and milestones
-        self._labels_cache: Optional[list[dict[str, Any]]] = None
-        self._milestones_cache: Optional[list[dict[str, Any]]] = None
+        self._labels_cache: list[dict[str, Any]] | None = None
+        self._milestones_cache: list[dict[str, Any]] | None = None
         self._rate_limit: dict[str, Any] = {}
 
     def validate_credentials(self) -> tuple[bool, str]:
@@ -239,7 +239,7 @@ class GitHubAdapter(BaseAdapter[Task]):
             TicketState.CLOSED: GitHubStateMapping.CLOSED,
         }
 
-    def _get_state_label(self, state: TicketState) -> Optional[str]:
+    def _get_state_label(self, state: TicketState) -> str | None:
         """Get the label name for extended states."""
         return GitHubStateMapping.STATE_LABELS.get(state)
 
@@ -508,7 +508,7 @@ class GitHubAdapter(BaseAdapter[Task]):
 
         return self._task_from_github_issue(created_issue)
 
-    async def read(self, ticket_id: str) -> Optional[Task]:
+    async def read(self, ticket_id: str) -> Task | None:
         """Read a GitHub issue by number."""
         # Validate credentials before attempting operation
         is_valid, error_message = self.validate_credentials()
@@ -533,7 +533,7 @@ class GitHubAdapter(BaseAdapter[Task]):
         except httpx.HTTPError:
             return None
 
-    async def update(self, ticket_id: str, updates: dict[str, Any]) -> Optional[Task]:
+    async def update(self, ticket_id: str, updates: dict[str, Any]) -> Task | None:
         """Update a GitHub issue."""
         # Validate credentials before attempting operation
         is_valid, error_message = self.validate_credentials()
@@ -685,7 +685,7 @@ class GitHubAdapter(BaseAdapter[Task]):
             return False
 
     async def list(
-        self, limit: int = 10, offset: int = 0, filters: Optional[dict[str, Any]] = None
+        self, limit: int = 10, offset: int = 0, filters: dict[str, Any] | None = None
     ) -> list[Task]:
         """List GitHub issues with filters."""
         # Build query parameters
@@ -837,7 +837,7 @@ class GitHubAdapter(BaseAdapter[Task]):
 
     async def transition_state(
         self, ticket_id: str, target_state: TicketState
-    ) -> Optional[Task]:
+    ) -> Task | None:
         """Transition GitHub issue to a new state."""
         # Validate transition
         if not await self.validate_transition(ticket_id, target_state):
@@ -971,7 +971,7 @@ class GitHubAdapter(BaseAdapter[Task]):
             },
         )
 
-    async def get_milestone(self, milestone_number: int) -> Optional[Epic]:
+    async def get_milestone(self, milestone_number: int) -> Epic | None:
         """Get a GitHub milestone as an Epic."""
         try:
             response = await self.client.get(
@@ -1073,9 +1073,9 @@ class GitHubAdapter(BaseAdapter[Task]):
         self,
         ticket_id: str,
         base_branch: str = "main",
-        head_branch: Optional[str] = None,
-        title: Optional[str] = None,
-        body: Optional[str] = None,
+        head_branch: str | None = None,
+        title: str | None = None,
+        body: str | None = None,
         draft: bool = False,
     ) -> dict[str, Any]:
         """Create a pull request linked to an issue.
@@ -1342,7 +1342,7 @@ Fixes #{issue_number}
         response.raise_for_status()
         return response.json()
 
-    async def get_current_user(self) -> Optional[dict[str, Any]]:
+    async def get_current_user(self) -> dict[str, Any] | None:
         """Get current authenticated user information."""
         response = await self.client.get("/user")
         response.raise_for_status()

mcp_ticketer/adapters/hybrid.py

@@ -8,7 +8,7 @@ import builtins
 import json
 import logging
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 
 from ..core.adapter import BaseAdapter
 from ..core.models import Comment, Epic, SearchQuery, Task, TicketState
@@ -129,7 +129,7 @@ class HybridAdapter(BaseAdapter):
 
     def _get_adapter_ticket_id(
         self, universal_id: str, adapter_name: str
-    ) -> Optional[str]:
+    ) -> str | None:
         """Get adapter-specific ticket ID from universal ID.
 
         Args:
@@ -153,7 +153,7 @@ class HybridAdapter(BaseAdapter):
 
         return f"hybrid-{uuid.uuid4().hex[:12]}"
 
-    async def create(self, ticket: Union[Task, Epic]) -> Union[Task, Epic]:
+    async def create(self, ticket: Task | Epic) -> Task | Epic:
         """Create ticket in all configured adapters.
 
         Args:
@@ -208,7 +208,7 @@ class HybridAdapter(BaseAdapter):
         return primary_ticket
 
     def _add_cross_references(
-        self, ticket: Union[Task, Epic], results: list[tuple[str, Union[Task, Epic]]]
+        self, ticket: Task | Epic, results: list[tuple[str, Task | Epic]]
     ) -> None:
         """Add cross-references to ticket description.
 
@@ -226,7 +226,7 @@ class HybridAdapter(BaseAdapter):
         else:
             ticket.description = cross_refs.strip()
 
-    async def read(self, ticket_id: str) -> Optional[Union[Task, Epic]]:
+    async def read(self, ticket_id: str) -> Task | Epic | None:
         """Read ticket from primary adapter.
 
         Args:
@@ -255,7 +255,7 @@ class HybridAdapter(BaseAdapter):
 
     async def update(
         self, ticket_id: str, updates: dict[str, Any]
-    ) -> Optional[Union[Task, Epic]]:
+    ) -> Task | Epic | None:
         """Update ticket across all adapters.
 
         Args:
@@ -300,7 +300,7 @@ class HybridAdapter(BaseAdapter):
 
         return None
 
-    def _find_universal_id(self, adapter_ticket_id: str) -> Optional[str]:
+    def _find_universal_id(self, adapter_ticket_id: str) -> str | None:
         """Find universal ID for an adapter-specific ticket ID.
 
         Args:
@@ -359,8 +359,8 @@ class HybridAdapter(BaseAdapter):
         return success_count > 0
 
     async def list(
-        self, limit: int = 10, offset: int = 0, filters: Optional[dict[str, Any]] = None
-    ) -> list[Union[Task, Epic]]:
+        self, limit: int = 10, offset: int = 0, filters: dict[str, Any] | None = None
+    ) -> list[Task | Epic]:
         """List tickets from primary adapter.
 
         Args:
@@ -375,7 +375,7 @@ class HybridAdapter(BaseAdapter):
         primary = self.adapters[self.primary_adapter_name]
         return await primary.list(limit, offset, filters)
 
-    async def search(self, query: SearchQuery) -> builtins.list[Union[Task, Epic]]:
+    async def search(self, query: SearchQuery) -> builtins.list[Task | Epic]:
         """Search tickets in primary adapter.
 
         Args:
@@ -390,7 +390,7 @@ class HybridAdapter(BaseAdapter):
 
     async def transition_state(
         self, ticket_id: str, target_state: TicketState
-    ) -> Optional[Union[Task, Epic]]:
+    ) -> Task | Epic | None:
         """Transition ticket state across all adapters.
 
         Args:

mcp_ticketer/adapters/jira.py

@@ -6,7 +6,7 @@ import logging
 import re
 from datetime import datetime
 from enum import Enum
-from typing import Any, Optional, Union
+from typing import Any, Union
 
 import httpx
 from httpx import AsyncClient, HTTPStatusError, TimeoutException
@@ -19,7 +19,7 @@ from ..core.registry import AdapterRegistry
 logger = logging.getLogger(__name__)
 
 
-def parse_jira_datetime(date_str: str) -> Optional[datetime]:
+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:
@@ -47,7 +47,7 @@ def parse_jira_datetime(date_str: str) -> Optional[datetime]:
         return None
 
 
-def extract_text_from_adf(adf_content: Union[str, dict[str, Any]]) -> str:
+def extract_text_from_adf(adf_content: str | dict[str, Any]) -> str:
     """Extract plain text from Atlassian Document Format (ADF).
 
     Args:
@@ -221,8 +221,8 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         self,
         method: str,
         endpoint: str,
-        data: Optional[dict[str, Any]] = None,
-        params: Optional[dict[str, Any]] = None,
+        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.
@@ -287,7 +287,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         return self._priority_cache
 
     async def _get_issue_types(
-        self, project_key: Optional[str] = None
+        self, project_key: str | None = None
     ) -> list[dict[str, Any]]:
         """Get available issue types for a project."""
         key = project_key or self.project_key
@@ -380,9 +380,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         }
         return mapping.get(priority, JiraPriority.MEDIUM)
 
-    def _map_priority_from_jira(
-        self, jira_priority: Optional[dict[str, Any]]
-    ) -> Priority:
+    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
@@ -432,7 +430,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         else:
             return TicketState.OPEN
 
-    def _issue_to_ticket(self, issue: dict[str, Any]) -> Union[Epic, Task]:
+    def _issue_to_ticket(self, issue: dict[str, Any]) -> Epic | Task:
         """Convert JIRA issue to universal ticket model."""
         fields = issue.get("fields", {})
 
@@ -507,7 +505,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             )
 
     def _ticket_to_issue_fields(
-        self, ticket: Union[Epic, Task], issue_type: Optional[str] = None
+        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
@@ -556,7 +554,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
         return fields
 
-    async def create(self, ticket: Union[Epic, Task]) -> Union[Epic, Task]:
+    async def create(self, ticket: Epic | Task) -> Epic | Task:
         """Create a new JIRA issue."""
         # Validate credentials before attempting operation
         is_valid, error_message = self.validate_credentials()
@@ -576,7 +574,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         created_issue = await self._make_request("GET", f"issue/{ticket.id}")
         return self._issue_to_ticket(created_issue)
 
-    async def read(self, ticket_id: str) -> Optional[Union[Epic, Task]]:
+    async def read(self, ticket_id: str) -> Epic | Task | None:
         """Read a JIRA issue by key."""
         # Validate credentials before attempting operation
         is_valid, error_message = self.validate_credentials()
@@ -595,7 +593,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
     async def update(
         self, ticket_id: str, updates: dict[str, Any]
-    ) -> Optional[Union[Epic, Task]]:
+    ) -> Epic | Task | None:
         """Update a JIRA issue."""
         # Validate credentials before attempting operation
         is_valid, error_message = self.validate_credentials()
@@ -652,8 +650,8 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             raise
 
     async def list(
-        self, limit: int = 10, offset: int = 0, filters: Optional[dict[str, Any]] = None
-    ) -> list[Union[Epic, Task]]:
+        self, limit: int = 10, offset: int = 0, filters: dict[str, Any] | None = None
+    ) -> list[Epic | Task]:
         """List JIRA issues with pagination."""
         # Build JQL query
         jql_parts = []
@@ -692,7 +690,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         issues = data.get("issues", [])
         return [self._issue_to_ticket(issue) for issue in issues]
 
-    async def search(self, query: SearchQuery) -> builtins.list[Union[Epic, Task]]:
+    async def search(self, query: SearchQuery) -> builtins.list[Epic | Task]:
         """Search JIRA issues using JQL."""
         # Build JQL query
         jql_parts = []
@@ -744,7 +742,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
     async def transition_state(
         self, ticket_id: str, target_state: TicketState
-    ) -> Optional[Union[Epic, Task]]:
+    ) -> Epic | Task | None:
         """Transition JIRA issue to a new state."""
         # Get available transitions
         transitions = await self._get_transitions(ticket_id)
@@ -858,9 +856,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
         return comments
 
-    async def get_project_info(
-        self, project_key: Optional[str] = None
-    ) -> dict[str, Any]:
+    async def get_project_info(self, project_key: str | None = None) -> dict[str, Any]:
         """Get JIRA project information including workflows and fields."""
         key = project_key or self.project_key
         if not key:
@@ -882,7 +878,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
     async def execute_jql(
         self, jql: str, limit: int = 50
-    ) -> builtins.list[Union[Epic, Task]]:
+    ) -> builtins.list[Epic | Task]:
         """Execute a raw JQL query.
 
         Args:
@@ -908,7 +904,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         return [self._issue_to_ticket(issue) for issue in issues]
 
     async def get_sprints(
-        self, board_id: Optional[int] = None
+        self, board_id: int | None = None
     ) -> builtins.list[dict[str, Any]]:
         """Get active sprints for a board (requires JIRA Software).
 
@@ -992,7 +988,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             except Exception:
                 return []
 
-    async def get_current_user(self) -> Optional[dict[str, Any]]:
+    async def get_current_user(self) -> dict[str, Any] | None:
         """Get current authenticated user information."""
         try:
             return await self._make_request("GET", "myself")