mcp-ticketer 0.1.8__py3-none-any.whl → 0.1.11__py3-none-any.whl

mcp_ticketer/__version__.py

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

mcp_ticketer/adapters/github.py

@@ -965,6 +965,269 @@ class GitHubAdapter(BaseAdapter[Task]):
 
         return response.status_code == 201
 
+    async def create_pull_request(
+        self,
+        ticket_id: str,
+        base_branch: str = "main",
+        head_branch: Optional[str] = None,
+        title: Optional[str] = None,
+        body: Optional[str] = None,
+        draft: bool = False,
+    ) -> Dict[str, Any]:
+        """Create a pull request linked to an issue.
+
+        Args:
+            ticket_id: Issue number to link the PR to
+            base_branch: Target branch for the PR (default: main)
+            head_branch: Source branch name (auto-generated if not provided)
+            title: PR title (uses ticket title if not provided)
+            body: PR description (auto-generated with issue link if not provided)
+            draft: Create as draft PR
+
+        Returns:
+            Dictionary with PR details including number, url, and branch
+        """
+        try:
+            issue_number = int(ticket_id)
+        except ValueError:
+            raise ValueError(f"Invalid issue number: {ticket_id}")
+
+        # Get the issue details
+        issue = await self.read(ticket_id)
+        if not issue:
+            raise ValueError(f"Issue #{ticket_id} not found")
+
+        # Auto-generate branch name if not provided
+        if not head_branch:
+            # Create branch name from issue number and title
+            # e.g., "123-fix-authentication-bug"
+            safe_title = "-".join(
+                issue.title.lower()
+                .replace("[", "")
+                .replace("]", "")
+                .replace("#", "")
+                .replace("/", "-")
+                .replace("\\", "-")
+                .split()[:5]  # Limit to 5 words
+            )
+            head_branch = f"{issue_number}-{safe_title}"
+
+        # Auto-generate title if not provided
+        if not title:
+            # Include issue number in PR title
+            title = f"[#{issue_number}] {issue.title}"
+
+        # Auto-generate body if not provided
+        if not body:
+            body = f"""## Summary
+
+This PR addresses issue #{issue_number}.
+
+**Issue:** #{issue_number} - {issue.title}
+**Link:** {issue.metadata.get('github', {}).get('url', '')}
+
+## Description
+
+{issue.description or 'No description provided.'}
+
+## Changes
+
+- [ ] Implementation details to be added
+
+## Testing
+
+- [ ] Tests have been added/updated
+- [ ] All tests pass
+
+## Checklist
+
+- [ ] Code follows project style guidelines
+- [ ] Self-review completed
+- [ ] Documentation updated if needed
+
+Fixes #{issue_number}
+"""
+
+        # Check if the head branch exists
+        try:
+            branch_response = await self.client.get(
+                f"/repos/{self.owner}/{self.repo}/branches/{head_branch}"
+            )
+            branch_exists = branch_response.status_code == 200
+        except httpx.HTTPError:
+            branch_exists = False
+
+        if not branch_exists:
+            # Get the base branch SHA
+            base_response = await self.client.get(
+                f"/repos/{self.owner}/{self.repo}/branches/{base_branch}"
+            )
+            base_response.raise_for_status()
+            base_sha = base_response.json()["commit"]["sha"]
+
+            # Create the new branch
+            ref_response = await self.client.post(
+                f"/repos/{self.owner}/{self.repo}/git/refs",
+                json={
+                    "ref": f"refs/heads/{head_branch}",
+                    "sha": base_sha,
+                }
+            )
+
+            if ref_response.status_code != 201:
+                # Branch might already exist on remote, try to use it
+                pass
+
+        # Create the pull request
+        pr_data = {
+            "title": title,
+            "body": body,
+            "head": head_branch,
+            "base": base_branch,
+            "draft": draft,
+        }
+
+        pr_response = await self.client.post(
+            f"/repos/{self.owner}/{self.repo}/pulls",
+            json=pr_data
+        )
+
+        if pr_response.status_code == 422:
+            # PR might already exist, try to get it
+            search_response = await self.client.get(
+                f"/repos/{self.owner}/{self.repo}/pulls",
+                params={
+                    "head": f"{self.owner}:{head_branch}",
+                    "base": base_branch,
+                    "state": "open",
+                }
+            )
+
+            if search_response.status_code == 200:
+                existing_prs = search_response.json()
+                if existing_prs:
+                    pr = existing_prs[0]
+                    return {
+                        "number": pr["number"],
+                        "url": pr["html_url"],
+                        "api_url": pr["url"],
+                        "branch": head_branch,
+                        "state": pr["state"],
+                        "draft": pr.get("draft", False),
+                        "title": pr["title"],
+                        "existing": True,
+                        "linked_issue": issue_number,
+                    }
+
+            raise ValueError(f"Failed to create PR: {pr_response.text}")
+
+        pr_response.raise_for_status()
+        pr = pr_response.json()
+
+        # Add a comment to the issue about the PR
+        await self.add_comment(
+            Comment(
+                ticket_id=ticket_id,
+                content=f"Pull request #{pr['number']} has been created: {pr['html_url']}",
+                author="system",
+            )
+        )
+
+        return {
+            "number": pr["number"],
+            "url": pr["html_url"],
+            "api_url": pr["url"],
+            "branch": head_branch,
+            "state": pr["state"],
+            "draft": pr.get("draft", False),
+            "title": pr["title"],
+            "linked_issue": issue_number,
+        }
+
+    async def link_existing_pull_request(
+        self,
+        ticket_id: str,
+        pr_url: str,
+    ) -> Dict[str, Any]:
+        """Link an existing pull request to a ticket.
+
+        Args:
+            ticket_id: Issue number to link the PR to
+            pr_url: GitHub PR URL to link
+
+        Returns:
+            Dictionary with link status and PR details
+        """
+        try:
+            issue_number = int(ticket_id)
+        except ValueError:
+            raise ValueError(f"Invalid issue number: {ticket_id}")
+
+        # Parse PR URL to extract owner, repo, and PR number
+        # Expected format: https://github.com/owner/repo/pull/123
+        import re
+        pr_pattern = r"github\.com/([^/]+)/([^/]+)/pull/(\d+)"
+        match = re.search(pr_pattern, pr_url)
+
+        if not match:
+            raise ValueError(f"Invalid GitHub PR URL format: {pr_url}")
+
+        pr_owner, pr_repo, pr_number = match.groups()
+
+        # Verify the PR is from the same repository
+        if pr_owner != self.owner or pr_repo != self.repo:
+            raise ValueError(
+                f"PR must be from the same repository ({self.owner}/{self.repo})"
+            )
+
+        # Get PR details
+        pr_response = await self.client.get(
+            f"/repos/{self.owner}/{self.repo}/pulls/{pr_number}"
+        )
+
+        if pr_response.status_code == 404:
+            raise ValueError(f"Pull request #{pr_number} not found")
+
+        pr_response.raise_for_status()
+        pr = pr_response.json()
+
+        # Update PR body to include issue reference if not already present
+        current_body = pr.get("body", "")
+        issue_ref = f"#{issue_number}"
+
+        if issue_ref not in current_body:
+            # Add issue reference to the body
+            updated_body = current_body or ""
+            if updated_body:
+                updated_body += "\n\n"
+            updated_body += f"Related to #{issue_number}"
+
+            # Update the PR
+            update_response = await self.client.patch(
+                f"/repos/{self.owner}/{self.repo}/pulls/{pr_number}",
+                json={"body": updated_body}
+            )
+            update_response.raise_for_status()
+
+        # Add a comment to the issue about the PR
+        await self.add_comment(
+            Comment(
+                ticket_id=ticket_id,
+                content=f"Linked to pull request #{pr_number}: {pr_url}",
+                author="system",
+            )
+        )
+
+        return {
+            "success": True,
+            "pr_number": pr["number"],
+            "pr_url": pr["html_url"],
+            "pr_title": pr["title"],
+            "pr_state": pr["state"],
+            "linked_issue": issue_number,
+            "message": f"Successfully linked PR #{pr_number} to issue #{issue_number}",
+        }
+
     async def close(self) -> None:
         """Close the HTTP client connection."""
         await self.client.aclose()

mcp_ticketer/adapters/linear.py

@@ -1343,6 +1343,226 @@ class LinearAdapter(BaseAdapter[Task]):
 
         return result.get("reactionCreate", {}).get("success", False)
 
+    async def link_to_pull_request(
+        self,
+        ticket_id: str,
+        pr_url: str,
+        pr_number: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Link a Linear issue to a GitHub pull request.
+
+        Args:
+            ticket_id: Linear issue identifier (e.g., 'BTA-123')
+            pr_url: GitHub PR URL
+            pr_number: Optional PR number (extracted from URL if not provided)
+
+        Returns:
+            Dictionary with link status and details
+        """
+        # Parse PR URL to extract details
+        import re
+        pr_pattern = r"github\.com/([^/]+)/([^/]+)/pull/(\d+)"
+        match = re.search(pr_pattern, pr_url)
+
+        if not match:
+            raise ValueError(f"Invalid GitHub PR URL format: {pr_url}")
+
+        owner, repo, extracted_pr_number = match.groups()
+        if not pr_number:
+            pr_number = int(extracted_pr_number)
+
+        # Create an attachment to link the PR
+        create_query = gql("""
+            mutation CreateAttachment($input: AttachmentCreateInput!) {
+                attachmentCreate(input: $input) {
+                    attachment {
+                        id
+                        url
+                        title
+                        subtitle
+                        source
+                    }
+                    success
+                }
+            }
+        """)
+
+        # Get the issue ID from the identifier
+        issue = await self.read(ticket_id)
+        if not issue:
+            raise ValueError(f"Issue {ticket_id} not found")
+
+        # Create attachment input
+        attachment_input = {
+            "issueId": issue.metadata.get("linear", {}).get("id"),
+            "url": pr_url,
+            "title": f"Pull Request #{pr_number}",
+            "subtitle": f"{owner}/{repo}",
+            "source": {
+                "type": "githubPr",
+                "data": {
+                    "number": pr_number,
+                    "owner": owner,
+                    "repo": repo,
+                }
+            },
+        }
+
+        async with self.client as session:
+            result = await session.execute(
+                create_query,
+                variable_values={"input": attachment_input}
+            )
+
+        if result.get("attachmentCreate", {}).get("success"):
+            attachment = result["attachmentCreate"]["attachment"]
+
+            # Also add a comment about the PR link
+            comment_text = f"Linked to GitHub PR: {pr_url}"
+            await self.add_comment(
+                Comment(
+                    ticket_id=ticket_id,
+                    content=comment_text,
+                    author="system",
+                )
+            )
+
+            return {
+                "success": True,
+                "attachment_id": attachment["id"],
+                "pr_url": pr_url,
+                "pr_number": pr_number,
+                "linked_issue": ticket_id,
+                "message": f"Successfully linked PR #{pr_number} to issue {ticket_id}",
+            }
+        else:
+            return {
+                "success": False,
+                "pr_url": pr_url,
+                "pr_number": pr_number,
+                "linked_issue": ticket_id,
+                "message": "Failed to create attachment link",
+            }
+
+    async def create_pull_request_for_issue(
+        self,
+        ticket_id: str,
+        github_config: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Create a GitHub PR for a Linear issue using GitHub integration.
+
+        This requires GitHub integration to be configured in Linear.
+
+        Args:
+            ticket_id: Linear issue identifier
+            github_config: GitHub configuration including:
+                - owner: GitHub repository owner
+                - repo: GitHub repository name
+                - base_branch: Target branch (default: main)
+                - head_branch: Source branch (auto-generated if not provided)
+
+        Returns:
+            Dictionary with PR creation status
+        """
+        # Get the issue details
+        issue = await self.read(ticket_id)
+        if not issue:
+            raise ValueError(f"Issue {ticket_id} not found")
+
+        # Generate branch name if not provided
+        head_branch = github_config.get("head_branch")
+        if not head_branch:
+            # Use Linear's branch naming convention
+            # e.g., "bta-123-fix-authentication-bug"
+            safe_title = "-".join(
+                issue.title.lower()
+                .replace("[", "")
+                .replace("]", "")
+                .replace("#", "")
+                .replace("/", "-")
+                .replace("\\", "-")
+                .split()[:5]  # Limit to 5 words
+            )
+            head_branch = f"{ticket_id.lower()}-{safe_title}"
+
+        # Update the issue with the branch name
+        update_query = gql("""
+            mutation UpdateIssue($id: String!, $input: IssueUpdateInput!) {
+                issueUpdate(id: $id, input: $input) {
+                    issue {
+                        id
+                        identifier
+                        branchName
+                    }
+                    success
+                }
+            }
+        """)
+
+        linear_id = issue.metadata.get("linear", {}).get("id")
+        if not linear_id:
+            # Need to get the full issue ID
+            search_result = await self._search_by_identifier(ticket_id)
+            if not search_result:
+                raise ValueError(f"Could not find Linear ID for issue {ticket_id}")
+            linear_id = search_result["id"]
+
+        async with self.client as session:
+            result = await session.execute(
+                update_query,
+                variable_values={
+                    "id": linear_id,
+                    "input": {"branchName": head_branch}
+                }
+            )
+
+        if result.get("issueUpdate", {}).get("success"):
+            # Prepare PR metadata to return
+            pr_metadata = {
+                "branch_name": head_branch,
+                "issue_id": ticket_id,
+                "issue_title": issue.title,
+                "issue_description": issue.description,
+                "github_owner": github_config.get("owner"),
+                "github_repo": github_config.get("repo"),
+                "base_branch": github_config.get("base_branch", "main"),
+                "message": f"Branch name '{head_branch}' set for issue {ticket_id}. Use GitHub integration or API to create the actual PR.",
+            }
+
+            # Add a comment about the branch
+            await self.add_comment(
+                Comment(
+                    ticket_id=ticket_id,
+                    content=f"Branch created: `{head_branch}`\nReady for pull request to `{pr_metadata['base_branch']}`",
+                    author="system",
+                )
+            )
+
+            return pr_metadata
+        else:
+            raise ValueError(f"Failed to update issue {ticket_id} with branch name")
+
+    async def _search_by_identifier(self, identifier: str) -> Optional[Dict[str, Any]]:
+        """Search for an issue by its identifier."""
+        search_query = gql("""
+            query SearchIssue($identifier: String!) {
+                issue(id: $identifier) {
+                    id
+                    identifier
+                }
+            }
+        """)
+
+        try:
+            async with self.client as session:
+                result = await session.execute(
+                    search_query,
+                    variable_values={"identifier": identifier}
+                )
+            return result.get("issue")
+        except:
+            return None
+
     async def close(self) -> None:
         """Close the GraphQL client connection."""
         if hasattr(self.client, 'close_async'):

mcp_ticketer/cli/main.py

@@ -18,6 +18,7 @@ from ..core.models import SearchQuery
 from ..adapters import AITrackdownAdapter
 from ..queue import Queue, QueueStatus, WorkerManager
 from .queue_commands import app as queue_app
+from ..__version__ import __version__
 
 # Load environment variables
 load_dotenv()
@@ -29,6 +30,31 @@ app = typer.Typer(
 )
 console = Console()
 
+
+def version_callback(value: bool):
+    """Print version and exit."""
+    if value:
+        console.print(f"mcp-ticketer version {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main_callback(
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "-v",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit"
+    ),
+):
+    """
+    MCP Ticketer - Universal ticket management interface.
+    """
+    pass
+
+
 # Configuration file management
 CONFIG_FILE = Path.home() / ".mcp-ticketer" / "config.json"
 

mcp_ticketer/mcp/server.py

@@ -63,6 +63,10 @@ class MCPTicketServer:
                 result = await self._handle_comment(params)
             elif method == "ticket/status":
                 result = await self._handle_queue_status(params)
+            elif method == "ticket/create_pr":
+                result = await self._handle_create_pr(params)
+            elif method == "ticket/link_pr":
+                result = await self._handle_link_pr(params)
             elif method == "tools/list":
                 result = await self._handle_tools_list()
             elif method == "tools/call":
@@ -134,11 +138,72 @@ class MCPTicketServer:
         manager = WorkerManager()
         manager.start_if_needed()
 
-        return {
-            "queue_id": queue_id,
-            "status": "queued",
-            "message": f"Ticket creation queued with ID: {queue_id}"
-        }
+        # Check if async mode is requested (for backward compatibility)
+        if params.get("async_mode", False):
+            return {
+                "queue_id": queue_id,
+                "status": "queued",
+                "message": f"Ticket creation queued with ID: {queue_id}"
+            }
+
+        # Poll for completion with timeout (default synchronous behavior)
+        max_wait_time = params.get("timeout", 30)  # seconds, allow override
+        poll_interval = 0.5  # seconds
+        start_time = asyncio.get_event_loop().time()
+
+        while True:
+            # Check queue status
+            item = queue.get_item(queue_id)
+
+            if not item:
+                return {
+                    "queue_id": queue_id,
+                    "status": "error",
+                    "error": f"Queue item {queue_id} not found"
+                }
+
+            # If completed, return with ticket ID
+            if item.status == QueueStatus.COMPLETED:
+                response = {
+                    "queue_id": queue_id,
+                    "status": "completed",
+                    "title": params["title"]
+                }
+
+                # Add ticket ID and other result data if available
+                if item.result:
+                    response["ticket_id"] = item.result.get("id")
+                    if "state" in item.result:
+                        response["state"] = item.result["state"]
+                    # Try to construct URL if we have enough information
+                    if response.get("ticket_id"):
+                        # This is adapter-specific, but we can add URL generation later
+                        response["id"] = response["ticket_id"]  # Also include as "id" for compatibility
+
+                response["message"] = f"Ticket created successfully: {response.get('ticket_id', queue_id)}"
+                return response
+
+            # If failed, return error
+            if item.status == QueueStatus.FAILED:
+                return {
+                    "queue_id": queue_id,
+                    "status": "failed",
+                    "error": item.error_message or "Ticket creation failed",
+                    "title": params["title"]
+                }
+
+            # Check timeout
+            elapsed = asyncio.get_event_loop().time() - start_time
+            if elapsed > max_wait_time:
+                return {
+                    "queue_id": queue_id,
+                    "status": "timeout",
+                    "message": f"Ticket creation timed out after {max_wait_time} seconds. Use ticket_status with queue_id to check status.",
+                    "title": params["title"]
+                }
+
+            # Wait before next poll
+            await asyncio.sleep(poll_interval)
 
     async def _handle_read(self, params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         """Handle ticket read."""
@@ -162,11 +227,60 @@ class MCPTicketServer:
         manager = WorkerManager()
         manager.start_if_needed()
 
-        return {
-            "queue_id": queue_id,
-            "status": "queued",
-            "message": f"Ticket update queued with ID: {queue_id}"
-        }
+        # Poll for completion with timeout
+        max_wait_time = 30  # seconds
+        poll_interval = 0.5  # seconds
+        start_time = asyncio.get_event_loop().time()
+
+        while True:
+            # Check queue status
+            item = queue.get_item(queue_id)
+
+            if not item:
+                return {
+                    "queue_id": queue_id,
+                    "status": "error",
+                    "error": f"Queue item {queue_id} not found"
+                }
+
+            # If completed, return with ticket ID
+            if item.status == QueueStatus.COMPLETED:
+                response = {
+                    "queue_id": queue_id,
+                    "status": "completed",
+                    "ticket_id": params["ticket_id"]
+                }
+
+                # Add result data if available
+                if item.result:
+                    if item.result.get("id"):
+                        response["ticket_id"] = item.result["id"]
+                    response["success"] = item.result.get("success", True)
+
+                response["message"] = f"Ticket updated successfully: {response['ticket_id']}"
+                return response
+
+            # If failed, return error
+            if item.status == QueueStatus.FAILED:
+                return {
+                    "queue_id": queue_id,
+                    "status": "failed",
+                    "error": item.error_message or "Ticket update failed",
+                    "ticket_id": params["ticket_id"]
+                }
+
+            # Check timeout
+            elapsed = asyncio.get_event_loop().time() - start_time
+            if elapsed > max_wait_time:
+                return {
+                    "queue_id": queue_id,
+                    "status": "timeout",
+                    "message": f"Ticket update timed out after {max_wait_time} seconds. Use ticket_status with queue_id to check status.",
+                    "ticket_id": params["ticket_id"]
+                }
+
+            # Wait before next poll
+            await asyncio.sleep(poll_interval)
 
     async def _handle_delete(self, params: Dict[str, Any]) -> Dict[str, Any]:
         """Handle ticket deletion."""
@@ -220,11 +334,61 @@ class MCPTicketServer:
         manager = WorkerManager()
         manager.start_if_needed()
 
-        return {
-            "queue_id": queue_id,
-            "status": "queued",
-            "message": f"State transition queued with ID: {queue_id}"
-        }
+        # Poll for completion with timeout
+        max_wait_time = 30  # seconds
+        poll_interval = 0.5  # seconds
+        start_time = asyncio.get_event_loop().time()
+
+        while True:
+            # Check queue status
+            item = queue.get_item(queue_id)
+
+            if not item:
+                return {
+                    "queue_id": queue_id,
+                    "status": "error",
+                    "error": f"Queue item {queue_id} not found"
+                }
+
+            # If completed, return with ticket ID
+            if item.status == QueueStatus.COMPLETED:
+                response = {
+                    "queue_id": queue_id,
+                    "status": "completed",
+                    "ticket_id": params["ticket_id"],
+                    "state": params["target_state"]
+                }
+
+                # Add result data if available
+                if item.result:
+                    if item.result.get("id"):
+                        response["ticket_id"] = item.result["id"]
+                    response["success"] = item.result.get("success", True)
+
+                response["message"] = f"State transition completed successfully: {response['ticket_id']} → {params['target_state']}"
+                return response
+
+            # If failed, return error
+            if item.status == QueueStatus.FAILED:
+                return {
+                    "queue_id": queue_id,
+                    "status": "failed",
+                    "error": item.error_message or "State transition failed",
+                    "ticket_id": params["ticket_id"]
+                }
+
+            # Check timeout
+            elapsed = asyncio.get_event_loop().time() - start_time
+            if elapsed > max_wait_time:
+                return {
+                    "queue_id": queue_id,
+                    "status": "timeout",
+                    "message": f"State transition timed out after {max_wait_time} seconds. Use ticket_status with queue_id to check status.",
+                    "ticket_id": params["ticket_id"]
+                }
+
+            # Wait before next poll
+            await asyncio.sleep(poll_interval)
 
     async def _handle_comment(self, params: Dict[str, Any]) -> Dict[str, Any]:
         """Handle comment operations."""
@@ -298,6 +462,144 @@ class MCPTicketServer:
 
         return response
 
+    async def _handle_create_pr(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle PR creation for a ticket."""
+        ticket_id = params.get("ticket_id")
+        if not ticket_id:
+            raise ValueError("ticket_id is required")
+
+        # Check if adapter supports PR creation
+        adapter_name = self.adapter.__class__.__name__.lower()
+
+        if "github" in adapter_name:
+            # GitHub adapter supports direct PR creation
+            from ..adapters.github import GitHubAdapter
+            if isinstance(self.adapter, GitHubAdapter):
+                try:
+                    result = await self.adapter.create_pull_request(
+                        ticket_id=ticket_id,
+                        base_branch=params.get("base_branch", "main"),
+                        head_branch=params.get("head_branch"),
+                        title=params.get("title"),
+                        body=params.get("body"),
+                        draft=params.get("draft", False),
+                    )
+                    return {
+                        "success": True,
+                        "pr_number": result.get("number"),
+                        "pr_url": result.get("url"),
+                        "branch": result.get("branch"),
+                        "linked_issue": result.get("linked_issue"),
+                        "message": f"Pull request created successfully: {result.get('url')}",
+                    }
+                except Exception as e:
+                    return {
+                        "success": False,
+                        "error": str(e),
+                        "ticket_id": ticket_id,
+                    }
+        elif "linear" in adapter_name:
+            # Linear adapter needs GitHub config for PR creation
+            from ..adapters.linear import LinearAdapter
+            if isinstance(self.adapter, LinearAdapter):
+                # For Linear, we prepare the branch and metadata but can't create the actual PR
+                # without GitHub integration configured
+                try:
+                    github_config = {
+                        "owner": params.get("github_owner"),
+                        "repo": params.get("github_repo"),
+                        "base_branch": params.get("base_branch", "main"),
+                        "head_branch": params.get("head_branch"),
+                    }
+
+                    # Validate GitHub config for Linear
+                    if not github_config.get("owner") or not github_config.get("repo"):
+                        return {
+                            "success": False,
+                            "error": "GitHub owner and repo are required for Linear PR creation",
+                            "ticket_id": ticket_id,
+                        }
+
+                    result = await self.adapter.create_pull_request_for_issue(
+                        ticket_id=ticket_id,
+                        github_config=github_config,
+                    )
+                    return {
+                        "success": True,
+                        "branch_name": result.get("branch_name"),
+                        "ticket_id": ticket_id,
+                        "message": result.get("message"),
+                        "github_config": {
+                            "owner": result.get("github_owner"),
+                            "repo": result.get("github_repo"),
+                            "base_branch": result.get("base_branch"),
+                        },
+                    }
+                except Exception as e:
+                    return {
+                        "success": False,
+                        "error": str(e),
+                        "ticket_id": ticket_id,
+                    }
+        else:
+            return {
+                "success": False,
+                "error": f"PR creation not supported for adapter: {adapter_name}",
+                "ticket_id": ticket_id,
+            }
+
+    async def _handle_link_pr(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle linking an existing PR to a ticket."""
+        ticket_id = params.get("ticket_id")
+        pr_url = params.get("pr_url")
+
+        if not ticket_id:
+            raise ValueError("ticket_id is required")
+        if not pr_url:
+            raise ValueError("pr_url is required")
+
+        adapter_name = self.adapter.__class__.__name__.lower()
+
+        if "github" in adapter_name:
+            from ..adapters.github import GitHubAdapter
+            if isinstance(self.adapter, GitHubAdapter):
+                try:
+                    result = await self.adapter.link_existing_pull_request(
+                        ticket_id=ticket_id,
+                        pr_url=pr_url,
+                    )
+                    return result
+                except Exception as e:
+                    return {
+                        "success": False,
+                        "error": str(e),
+                        "ticket_id": ticket_id,
+                        "pr_url": pr_url,
+                    }
+        elif "linear" in adapter_name:
+            from ..adapters.linear import LinearAdapter
+            if isinstance(self.adapter, LinearAdapter):
+                try:
+                    result = await self.adapter.link_to_pull_request(
+                        ticket_id=ticket_id,
+                        pr_url=pr_url,
+                    )
+                    return result
+                except Exception as e:
+                    return {
+                        "success": False,
+                        "error": str(e),
+                        "ticket_id": ticket_id,
+                        "pr_url": pr_url,
+                    }
+        else:
+            return {
+                "success": False,
+                "error": f"PR linking not supported for adapter: {adapter_name}",
+                "ticket_id": ticket_id,
+                "pr_url": pr_url,
+            }
+
     async def _handle_initialize(self, params: Dict[str, Any]) -> Dict[str, Any]:
         """Handle initialize request from MCP client.
 
@@ -324,6 +626,34 @@ class MCPTicketServer:
         """List available MCP tools."""
         return {
             "tools": [
+                {
+                    "name": "ticket_create_pr",
+                    "description": "Create a GitHub PR linked to a ticket",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "ticket_id": {"type": "string", "description": "Ticket ID to link the PR to"},
+                            "base_branch": {"type": "string", "description": "Target branch for the PR", "default": "main"},
+                            "head_branch": {"type": "string", "description": "Source branch name (auto-generated if not provided)"},
+                            "title": {"type": "string", "description": "PR title (uses ticket title if not provided)"},
+                            "body": {"type": "string", "description": "PR description (auto-generated with issue link if not provided)"},
+                            "draft": {"type": "boolean", "description": "Create as draft PR", "default": False},
+                        },
+                        "required": ["ticket_id"]
+                    }
+                },
+                {
+                    "name": "ticket_link_pr",
+                    "description": "Link an existing PR to a ticket",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "ticket_id": {"type": "string", "description": "Ticket ID to link the PR to"},
+                            "pr_url": {"type": "string", "description": "GitHub PR URL to link"},
+                        },
+                        "required": ["ticket_id", "pr_url"]
+                    }
+                },
                 {
                     "name": "ticket_create",
                     "description": "Create a new ticket",
@@ -428,6 +758,10 @@ class MCPTicketServer:
                 result = await self._handle_search(arguments)
             elif tool_name == "ticket_status":
                 result = await self._handle_queue_status(arguments)
+            elif tool_name == "ticket_create_pr":
+                result = await self._handle_create_pr(arguments)
+            elif tool_name == "ticket_link_pr":
+                result = await self._handle_link_pr(arguments)
             else:
                 return {
                     "content": [

{mcp_ticketer-0.1.8.dist-info → mcp_ticketer-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-ticketer
-Version: 0.1.8
+Version: 0.1.11
 Summary: Universal ticket management interface for AI agents with MCP support
 Author-email: MCP Ticketer Team <support@mcp-ticketer.io>
 Maintainer-email: MCP Ticketer Team <support@mcp-ticketer.io>
@@ -33,13 +33,14 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: gql[httpx]>=3.0.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: psutil>=5.9.0
 Requires-Dist: pydantic>=2.0
-Requires-Dist: typer>=0.9.0
+Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rich>=13.0.0
-Requires-Dist: httpx>=0.25.0
+Requires-Dist: typer>=0.9.0
 Requires-Dist: typing-extensions>=4.8.0
-Requires-Dist: python-dotenv>=1.0.0
-Requires-Dist: psutil>=5.9.0
 Provides-Extra: all
 Requires-Dist: mcp-ticketer[github,jira,linear,mcp]; extra == "all"
 Provides-Extra: dev

{mcp_ticketer-0.1.8.dist-info → mcp_ticketer-0.1.11.dist-info}/RECORD

@@ -1,15 +1,15 @@
 mcp_ticketer/__init__.py,sha256=ayPQdFr6msypD06_G96a1H0bdFCT1m1wDtv8MZBpY4I,496
-mcp_ticketer/__version__.py,sha256=xaUaMuuCEFDRyWYQ--OHg6JhbB17oO3kulskm7AkcVA,1114
+mcp_ticketer/__version__.py,sha256=Ym9ng_TEiLSfqVAhPCtwjrIqiM8S9cAUurRI6mpYEyg,1115
 mcp_ticketer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_ticketer/adapters/__init__.py,sha256=_QRLaX38EUsL-kMvJITY0lYHvrq_ip9Qw4Q1YLavJSo,283
 mcp_ticketer/adapters/aitrackdown.py,sha256=ICNimTtF6rPajuVoVEpmdw2TfjYjnWvao8prUwukNn0,15210
-mcp_ticketer/adapters/github.py,sha256=5vv_BwjPTJOY0sLFQv342Cz2u8PtS51RV7AK0-NEsLo,35357
+mcp_ticketer/adapters/github.py,sha256=onT8NhYaf9fIw2eCOTbZSkk7q4IoM7ZADRvRl9qrUz8,43850
 mcp_ticketer/adapters/jira.py,sha256=rd-8PseTsRyQNPjsrUJ8vJ8vfBpa6HWFBieOUyvw0Tg,28954
-mcp_ticketer/adapters/linear.py,sha256=PYqR30h223un50_Z-0lepPyIasK2uVHyL11mfPqtWV0,44119
+mcp_ticketer/adapters/linear.py,sha256=neTxVy-QD23tTI7XKtnc5CBCpm3yVCULlgxG5oFSQI4,51752
 mcp_ticketer/cache/__init__.py,sha256=MSi3GLXancfP2-edPC9TFAJk7r0j6H5-XmpMHnkGPbI,137
 mcp_ticketer/cache/memory.py,sha256=gTzv-xF7qGfiYVUjG7lnzo0ZcqgXQajMl4NAYUcaytg,5133
 mcp_ticketer/cli/__init__.py,sha256=YeljyLtv906TqkvRuEPhmKO-Uk0CberQ9I6kx1tx2UA,88
-mcp_ticketer/cli/main.py,sha256=sGQhyaPZhCZpHM5-1aqaW3KJTfkSv2LteIKlXdavkSQ,27774
+mcp_ticketer/cli/main.py,sha256=adz3YXGnw7GY1h9jYgmIfYizf-z4ddhx2adFjncpZ3A,28294
 mcp_ticketer/cli/queue_commands.py,sha256=f3pEHKZ43dBHEIoCBvdfvjfMB9_WJltps9ATwTzorY0,8160
 mcp_ticketer/cli/utils.py,sha256=NxsS91vKA8xZnDXKU2y0Gcyc4I_ctRyJj-wT7Xd1Q_Q,18589
 mcp_ticketer/core/__init__.py,sha256=NA-rDvwuAOZ9sUZVYJOWp8bR6mOBG8w_5lpWTT75JNI,318
@@ -20,16 +20,16 @@ mcp_ticketer/core/mappers.py,sha256=8I4jcqDqoQEdWlteDMpVeVF3Wo0fDCkmFPRr8oNv8gA,
 mcp_ticketer/core/models.py,sha256=K-bLuU_DNNVgjHnVFzAIbSa0kJwT2I3Hj24sCklwIYo,4374
 mcp_ticketer/core/registry.py,sha256=fwje0fnjp0YKPZ0SrVWk82SMNLs7CD0JlHQmx7SigNo,3537
 mcp_ticketer/mcp/__init__.py,sha256=Bvzof9vBu6VwcXcIZK8RgKv6ycRV9tDlO-9TUmd8zqQ,122
-mcp_ticketer/mcp/server.py,sha256=1sl_JZCwqlgOS53cisVNGIg6a2p7H2geC4c6h7g-UvA,19574
+mcp_ticketer/mcp/server.py,sha256=TDuU8ChZC2QYSRo0uGHkVReblTf--hriOjxo-pSAF_Y,34068
 mcp_ticketer/queue/__init__.py,sha256=xHBoUwor8ZdO8bIHc7nP25EsAp5Si5Co4g_8ybb7fes,230
 mcp_ticketer/queue/__main__.py,sha256=kQd6iOCKbbFqpRdbIRavuI4_G7-oE898JE4a0yLEYPE,108
 mcp_ticketer/queue/manager.py,sha256=79AH9oUxdBXH3lmJ3kIlFf2GQkWHL6XB6u5JqVWPq60,7571
 mcp_ticketer/queue/queue.py,sha256=UgbIChWPiyI7BJNQ9DYA92D2jVMMtmVWBzotI5ML51A,11394
 mcp_ticketer/queue/run_worker.py,sha256=HFoykfDpOoz8OUxWbQ2Fka_UlGrYwjPVZ-DEimGFH9o,802
 mcp_ticketer/queue/worker.py,sha256=cVjHR_kfnGKAkiUg0HuXCnbKeKNBBEuj0XZHgIuIn4k,14017
-mcp_ticketer-0.1.8.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
-mcp_ticketer-0.1.8.dist-info/METADATA,sha256=cD0ozxekpO4uT0ychGnrtCNJ7Tig8NwrotX-T2Ri_RA,11177
-mcp_ticketer-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_ticketer-0.1.8.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
-mcp_ticketer-0.1.8.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
-mcp_ticketer-0.1.8.dist-info/RECORD,,
+mcp_ticketer-0.1.11.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
+mcp_ticketer-0.1.11.dist-info/METADATA,sha256=GjLKPEBTziutLdEpztLyQkGvxMCpiHArYsdSKltJwwA,11211
+mcp_ticketer-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_ticketer-0.1.11.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
+mcp_ticketer-0.1.11.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
+mcp_ticketer-0.1.11.dist-info/RECORD,,