mcp-ticketer 0.1.37__py3-none-any.whl → 0.1.39__py3-none-any.whl

mcp_ticketer/__version__.py

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

mcp_ticketer/adapters/github.py

@@ -4,13 +4,14 @@ import builtins
 import os
 import re
 from datetime import datetime
-from typing import Any, Optional
+from typing import Any, Dict, List, Optional
 
 import httpx
 
 from ..core.adapter import BaseAdapter
 from ..core.models import Comment, Epic, Priority, SearchQuery, Task, TicketState
 from ..core.registry import AdapterRegistry
+from ..core.env_loader import load_adapter_config, validate_adapter_config
 
 
 class GitHubStateMapping:
@@ -151,21 +152,22 @@ class GitHubAdapter(BaseAdapter[Task]):
         """
         super().__init__(config)
 
+        # Load configuration with environment variable resolution
+        full_config = load_adapter_config("github", config)
+
+        # Validate required configuration
+        missing_keys = validate_adapter_config("github", full_config)
+        if missing_keys:
+            raise ValueError(f"GitHub adapter missing required configuration: {', '.join(missing_keys)}")
+
         # Get authentication token - support both 'api_key' and 'token' for compatibility
         self.token = (
-            config.get("api_key") or config.get("token") or os.getenv("GITHUB_TOKEN")
+            full_config.get("api_key") or full_config.get("token") or full_config.get("token")
         )
-        if not self.token:
-            raise ValueError(
-                "GitHub token required (config.api_key, config.token or GITHUB_TOKEN env var)"
-            )
 
         # Get repository information
-        self.owner = config.get("owner") or os.getenv("GITHUB_OWNER")
-        self.repo = config.get("repo") or os.getenv("GITHUB_REPO")
-
-        if not self.owner or not self.repo:
-            raise ValueError("GitHub owner and repo are required")
+        self.owner = full_config.get("owner")
+        self.repo = full_config.get("repo")
 
         # API URLs
         self.api_url = config.get("api_url", "https://api.github.com")
@@ -1329,6 +1331,20 @@ Fixes #{issue_number}
             "message": f"Successfully linked PR #{pr_number} to issue #{issue_number}",
         }
 
+    async def get_collaborators(self) -> List[Dict[str, Any]]:
+        """Get repository collaborators."""
+        response = await self.client.get(
+            f"/repos/{self.owner}/{self.repo}/collaborators"
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def get_current_user(self) -> Optional[Dict[str, Any]]:
+        """Get current authenticated user information."""
+        response = await self.client.get("/user")
+        response.raise_for_status()
+        return response.json()
+
     async def close(self) -> None:
         """Close the HTTP client connection."""
         await self.client.aclose()

mcp_ticketer/adapters/jira.py

@@ -4,9 +4,10 @@ import asyncio
 import builtins
 import logging
 import os
+import re
 from datetime import datetime
 from enum import Enum
-from typing import Any, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 import httpx
 from httpx import AsyncClient, HTTPStatusError, TimeoutException
@@ -14,10 +15,79 @@ from httpx import AsyncClient, HTTPStatusError, TimeoutException
 from ..core.adapter import BaseAdapter
 from ..core.models import Comment, Epic, Priority, SearchQuery, Task, TicketState
 from ..core.registry import AdapterRegistry
+from ..core.env_loader import load_adapter_config, validate_adapter_config
 
 logger = logging.getLogger(__name__)
 
 
+def parse_jira_datetime(date_str: str) -> Optional[datetime]:
+    """
+    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: Union[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."""
 
@@ -60,21 +130,23 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         """
         super().__init__(config)
 
-        # Configuration
-        self.server = config.get("server") or os.getenv("JIRA_SERVER", "")
-        self.email = config.get("email") or os.getenv("JIRA_EMAIL", "")
-        self.api_token = config.get("api_token") or os.getenv("JIRA_API_TOKEN", "")
-        self.project_key = config.get("project_key") or os.getenv(
-            "JIRA_PROJECT_KEY", ""
-        )
-        self.is_cloud = config.get("cloud", True)
-        self.verify_ssl = config.get("verify_ssl", True)
-        self.timeout = config.get("timeout", 30)
-        self.max_retries = config.get("max_retries", 3)
+        # Load configuration with environment variable resolution
+        full_config = load_adapter_config("jira", config)
+
+        # Validate required configuration
+        missing_keys = validate_adapter_config("jira", full_config)
+        if missing_keys:
+            raise ValueError(f"JIRA adapter missing required configuration: {', '.join(missing_keys)}")
 
-        # Validate required fields
-        if not all([self.server, self.email, self.api_token]):
-            raise ValueError("JIRA adapter requires server, email, and api_token")
+        # Configuration
+        self.server = full_config.get("server", "")
+        self.email = full_config.get("email", "")
+        self.api_token = full_config.get("api_token", "")
+        self.project_key = full_config.get("project_key", "")
+        self.is_cloud = full_config.get("cloud", True)
+        self.verify_ssl = full_config.get("verify_ssl", True)
+        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("/")
@@ -382,16 +454,8 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
                 label.get("name", "") if isinstance(label, dict) else str(label)
                 for label in fields.get("labels", [])
             ],
-            "created_at": (
-                datetime.fromisoformat(fields.get("created", "").replace("Z", "+00:00"))
-                if fields.get("created")
-                else None
-            ),
-            "updated_at": (
-                datetime.fromisoformat(fields.get("updated", "").replace("Z", "+00:00"))
-                if fields.get("updated")
-                else None
-            ),
+            "created_at": parse_jira_datetime(fields.get("created")),
+            "updated_at": parse_jira_datetime(fields.get("updated")),
             "metadata": {
                 "jira": {
                     "id": issue.get("id"),
@@ -457,9 +521,12 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
             "summary": ticket.title,
             "description": description,
             "labels": ticket.tags,
-            "priority": {"name": self._map_priority_to_jira(ticket.priority)},
         }
 
+        # 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}
@@ -608,16 +675,16 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
         jql = " AND ".join(jql_parts) if jql_parts else "ORDER BY created DESC"
 
-        # Search issues using the new API endpoint
+        # Search issues using the JIRA API endpoint
         data = await self._make_request(
-            "POST",
-            "search/jql",  # Updated to use new API endpoint
-            data={
+            "GET",
+            "search/jql",  # JIRA search endpoint (new API v3)
+            params={
                 "jql": jql,
                 "startAt": offset,
                 "maxResults": limit,
-                "fields": ["*all"],
-                "expand": ["renderedFields"],
+                "fields": "*all",
+                "expand": "renderedFields",
             },
         )
 
@@ -658,16 +725,16 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
         jql = " AND ".join(jql_parts) if jql_parts else "ORDER BY created DESC"
 
-        # Execute search using the new API endpoint
+        # Execute search using the JIRA API endpoint
         data = await self._make_request(
-            "POST",
-            "search/jql",  # Updated to use new API endpoint
-            data={
+            "GET",
+            "search/jql",  # JIRA search endpoint (new API v3)
+            params={
                 "jql": jql,
                 "startAt": query.offset,
                 "maxResults": query.limit,
-                "fields": ["*all"],
-                "expand": ["renderedFields"],
+                "fields": "*all",
+                "expand": "renderedFields",
             },
         )
 
@@ -728,8 +795,24 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
     async def add_comment(self, comment: Comment) -> Comment:
         """Add a comment to a JIRA issue."""
-        # Prepare comment data
-        data = {"body": comment.content}
+        # Prepare comment data in Atlassian Document Format
+        data = {
+            "body": {
+                "type": "doc",
+                "version": 1,
+                "content": [
+                    {
+                        "type": "paragraph",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": comment.content
+                            }
+                        ]
+                    }
+                ]
+            }
+        }
 
         # Add comment
         result = await self._make_request(
@@ -738,11 +821,7 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
         # Update comment with JIRA data
         comment.id = result.get("id")
-        comment.created_at = (
-            datetime.fromisoformat(result.get("created", "").replace("Z", "+00:00"))
-            if result.get("created")
-            else datetime.now()
-        )
+        comment.created_at = parse_jira_datetime(result.get("created")) or datetime.now()
         comment.author = result.get("author", {}).get("displayName", comment.author)
         comment.metadata["jira"] = result
 
@@ -766,18 +845,16 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
         # Convert to Comment objects
         comments = []
         for comment_data in paginated:
+            # Extract text content from ADF format
+            body_content = comment_data.get("body", "")
+            text_content = extract_text_from_adf(body_content)
+
             comment = Comment(
                 id=comment_data.get("id"),
                 ticket_id=ticket_id,
                 author=comment_data.get("author", {}).get("displayName", "Unknown"),
-                content=comment_data.get("body", ""),
-                created_at=(
-                    datetime.fromisoformat(
-                        comment_data.get("created", "").replace("Z", "+00:00")
-                    )
-                    if comment_data.get("created")
-                    else None
-                ),
+                content=text_content,
+                created_at=parse_jira_datetime(comment_data.get("created")),
                 metadata={"jira": comment_data},
             )
             comments.append(comment)
@@ -866,6 +943,61 @@ class JiraAdapter(BaseAdapter[Union[Epic, Task]]):
 
         return sprints_data.get("values", [])
 
+    async def get_project_users(self) -> List[Dict[str, Any]]:
+        """Get users who have access to the project."""
+        if not self.project_key:
+            return []
+
+        try:
+            # Get project role users
+            project_data = await self._make_request("GET", f"project/{self.project_key}")
+
+            # Get users from project roles
+            users = []
+            if "roles" in project_data:
+                for role_name, role_url in project_data["roles"].items():
+                    # 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}")
+                        if "actors" in role_data:
+                            for actor in role_data["actors"]:
+                                if actor.get("type") == "atlassian-user-role-actor":
+                                    users.append(actor.get("actorUser", {}))
+                    except Exception:
+                        # Skip if role access fails
+                        continue
+
+            # Remove duplicates based on accountId
+            seen_ids = set()
+            unique_users = []
+            for user in users:
+                account_id = user.get("accountId")
+                if account_id and account_id not in seen_ids:
+                    seen_ids.add(account_id)
+                    unique_users.append(user)
+
+            return unique_users
+
+        except Exception:
+            # Fallback: try to get assignable users for the project
+            try:
+                users_data = await self._make_request(
+                    "GET",
+                    "user/assignable/search",
+                    params={"project": self.project_key, "maxResults": 50}
+                )
+                return users_data if isinstance(users_data, list) else []
+            except Exception:
+                return []
+
+    async def get_current_user(self) -> Optional[Dict[str, Any]]:
+        """Get current authenticated user information."""
+        try:
+            return await self._make_request("GET", "myself")
+        except Exception:
+            return None
+
     async def close(self) -> None:
         """Close the adapter and cleanup resources."""
         # Clear caches

mcp_ticketer/adapters/linear.py

@@ -5,7 +5,7 @@ import builtins
 import os
 from datetime import date, datetime
 from enum import Enum
-from typing import Any, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from gql import Client, gql
 from gql.transport.exceptions import TransportQueryError
@@ -22,6 +22,7 @@ from ..core.models import (
     TicketType,
 )
 from ..core.registry import AdapterRegistry
+from ..core.env_loader import load_adapter_config, validate_adapter_config
 
 
 class LinearStateType(str, Enum):
@@ -295,24 +296,36 @@ class LinearAdapter(BaseAdapter[Task]):
         """
         super().__init__(config)
 
+        # Load configuration with environment variable resolution
+        full_config = load_adapter_config("linear", config)
+
         # Get API key from config or environment
-        self.api_key = config.get("api_key") or os.getenv("LINEAR_API_KEY")
+        self.api_key = full_config.get("api_key")
         if not self.api_key:
             raise ValueError(
                 "Linear API key required (config.api_key or LINEAR_API_KEY env var)"
             )
 
-        self.workspace = config.get("workspace")  # Optional, for documentation
+        self.workspace = full_config.get("workspace")  # Optional, for documentation
 
         # Support both team_key (short key) and team_id (UUID)
-        self.team_key = config.get("team_key")  # Short key like "BTA"
-        self.team_id_config = config.get("team_id")  # UUID like "02d15669-..."
+        self.team_key = full_config.get("team_key")  # Short key like "BTA"
+        self.team_id_config = full_config.get("team_id")  # UUID like "02d15669-..."
 
         # Require at least one team identifier
         if not self.team_key and not self.team_id_config:
             raise ValueError("Either team_key or team_id is required in configuration")
 
-        self.api_url = config.get("api_url", "https://api.linear.app/graphql")
+        self.api_url = full_config.get("api_url", "https://api.linear.app/graphql")
+
+        # DEBUG: Log API key details for debugging
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"LinearAdapter initialized with API key: {self.api_key[:20]}...")
+        logger.info(f"LinearAdapter config api_key: {config.get('api_key', 'Not set')[:20] if config.get('api_key') else 'Not set'}...")
+        logger.info(f"LinearAdapter env LINEAR_API_KEY: {os.getenv('LINEAR_API_KEY', 'Not set')[:20] if os.getenv('LINEAR_API_KEY') else 'Not set'}...")
+        logger.info(f"LinearAdapter team_id_config: {self.team_id_config}")
+        logger.info(f"LinearAdapter team_key: {self.team_key}")
 
         # Caches for frequently used data
         self._team_id: Optional[str] = None
@@ -839,13 +852,22 @@ class LinearAdapter(BaseAdapter[Task]):
             metadata=metadata,
         )
 
-    async def create(self, ticket: Task) -> Task:
-        """Create a new Linear issue with full field support."""
+    async def create(self, ticket: Union[Epic, Task]) -> Union[Epic, Task]:
+        """Create a new Linear issue or project with full field support."""
         # Validate credentials before attempting operation
         is_valid, error_message = self.validate_credentials()
         if not is_valid:
             raise ValueError(error_message)
 
+        # Handle Epic creation (Linear Projects)
+        if isinstance(ticket, Epic):
+            return await self.create_epic(
+                title=ticket.title,
+                description=ticket.description,
+                tags=ticket.tags,
+                priority=ticket.priority
+            )
+
         team_id = await self._ensure_team_id()
         states = await self._get_workflow_states()
 
@@ -1942,7 +1964,8 @@ class LinearAdapter(BaseAdapter[Task]):
         team_id = await self._ensure_team_id()
 
         create_query = gql(
-            PROJECT_FRAGMENT
+            TEAM_FRAGMENT
+            + PROJECT_FRAGMENT
             + """
             mutation CreateProject($input: ProjectCreateInput!) {
                 projectCreate(input: $input) {
@@ -2306,6 +2329,52 @@ class LinearAdapter(BaseAdapter[Task]):
         except TransportQueryError:
             return []
 
+    async def get_team_members(self) -> List[Dict[str, Any]]:
+        """Get team members for the current team."""
+        team_id = await self._ensure_team_id()
+
+        query = gql(
+            USER_FRAGMENT + """
+            query GetTeamMembers($teamId: String!) {
+                team(id: $teamId) {
+                    members {
+                        nodes {
+                            ...UserFields
+                        }
+                    }
+                }
+            }
+        """
+        )
+
+        client = self._create_client()
+        async with client as session:
+            result = await session.execute(
+                query, variable_values={"teamId": team_id}
+            )
+
+        if result.get("team", {}).get("members", {}).get("nodes"):
+            return result["team"]["members"]["nodes"]
+        return []
+
+    async def get_current_user(self) -> Optional[Dict[str, Any]]:
+        """Get current user information."""
+        query = gql(
+            USER_FRAGMENT + """
+            query GetCurrentUser {
+                viewer {
+                    ...UserFields
+                }
+            }
+        """
+        )
+
+        client = self._create_client()
+        async with client as session:
+            result = await session.execute(query)
+
+        return result.get("viewer")
+
     async def close(self) -> None:
         """Close the GraphQL client connection.