bitbucket-jira-cli 1.0.0__py3-none-any.whl

bitbucket_jira_cli/__init__.py

@@ -0,0 +1,9 @@
+"""bitbucket-jira-cli: a gh-style CLI for Bitbucket and Jira."""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version
+
+try:
+    __version__ = version("bitbucket-jira-cli")
+except PackageNotFoundError:  # pragma: no cover - not installed (e.g. running from source)
+    __version__ = "0.0.0"

bitbucket_jira_cli/_async.py

@@ -0,0 +1,17 @@
+"""Bridge between Typer's sync commands and the async httpx clients."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+from typing import TypeVar
+
+if TYPE_CHECKING:
+    from collections.abc import Coroutine
+
+T = TypeVar("T")
+
+
+def run(coro: Coroutine[object, object, T]) -> T:
+    """Run an async command body to completion from a sync Typer callback."""
+    return asyncio.run(coro)

bitbucket_jira_cli/api/__init__.py

@@ -0,0 +1 @@
+"""Async HTTP clients for the Bitbucket Cloud and Jira Cloud REST APIs."""

bitbucket_jira_cli/api/adf.py

@@ -0,0 +1,45 @@
+"""Minimal Atlassian Document Format (ADF) helpers for Jira v3 bodies.
+
+Jira Cloud v3 requires ADF JSON (not plain text/wiki markup) for issue
+descriptions and comments. We accept plain text / light Markdown from the user
+and emit a valid ADF document: blank-line-separated paragraphs, preserving
+hard line breaks within a paragraph.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def text_to_adf(text: str) -> dict[str, Any]:
+    paragraphs = text.replace("\r\n", "\n").split("\n\n")
+    content: list[dict[str, Any]] = []
+    for para in paragraphs:
+        lines = para.split("\n")
+        nodes: list[dict[str, Any]] = []
+        for i, line in enumerate(lines):
+            if line:
+                nodes.append({"type": "text", "text": line})
+            if i < len(lines) - 1:
+                nodes.append({"type": "hardBreak"})
+        content.append({"type": "paragraph", "content": nodes or [{"type": "text", "text": ""}]})
+    if not content:
+        content = [{"type": "paragraph", "content": []}]
+    return {"type": "doc", "version": 1, "content": content}
+
+
+def adf_to_text(node: Any) -> str:
+    """Best-effort flatten of an ADF document back to plain text for display."""
+    if isinstance(node, str):
+        return node
+    if isinstance(node, list):
+        return "".join(adf_to_text(c) for c in node)
+    if not isinstance(node, dict):
+        return ""
+    node_type = node.get("type")
+    if node_type == "text":
+        return str(node.get("text", ""))
+    if node_type == "hardBreak":
+        return "\n"
+    children = "".join(adf_to_text(c) for c in node.get("content", []))
+    return children + "\n" if node_type == "paragraph" else children

bitbucket_jira_cli/api/base.py

@@ -0,0 +1,88 @@
+"""Shared async client plumbing: request, error mapping, JSON helpers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import Any
+
+import httpx
+
+from bitbucket_jira_cli.errors import ApiError
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+DEFAULT_TIMEOUT = 30.0
+
+
+class BaseAsyncClient:
+    """Thin wrapper over ``httpx.AsyncClient`` with error mapping.
+
+    Subclasses set ``backend`` (for error messages) and pass a base URL and
+    default headers (including ``Authorization``).
+    """
+
+    backend = "api"
+
+    def __init__(self, base_url: str, headers: dict[str, str]) -> None:
+        self._client = httpx.AsyncClient(
+            base_url=base_url,
+            headers={"Accept": "application/json", **headers},
+            timeout=DEFAULT_TIMEOUT,
+            follow_redirects=True,
+        )
+
+    async def __aenter__(self) -> BaseAsyncClient:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    def _raise(self, response: httpx.Response) -> None:
+        detail = self._error_detail(response)
+        raise ApiError(self.backend, response.status_code, detail)
+
+    @staticmethod
+    def _error_detail(response: httpx.Response) -> str:
+        try:
+            body = response.json()
+        except ValueError:
+            return response.text[:300] or response.reason_phrase
+        # Bitbucket: {"error": {"message": ...}}; Jira: {"errorMessages": [...]}
+        if isinstance(body, dict):
+            if isinstance(body.get("error"), dict) and body["error"].get("message"):
+                return str(body["error"]["message"])
+            if body.get("errorMessages"):
+                return "; ".join(body["errorMessages"])
+            if body.get("errors"):
+                return "; ".join(f"{k}: {v}" for k, v in body["errors"].items())
+        return response.text[:300] or response.reason_phrase
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any = None,
+        content: bytes | str | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> httpx.Response:
+        response = await self._client.request(
+            method, url, params=params, json=json, content=content, headers=headers
+        )
+        if response.status_code >= httpx.codes.BAD_REQUEST:
+            self._raise(response)
+        return response
+
+    async def get_json(self, url: str, *, params: dict[str, Any] | None = None) -> Any:
+        response = await self.request("GET", url, params=params)
+        return response.json()

bitbucket_jira_cli/api/bitbucket.py

@@ -0,0 +1,304 @@
+"""Bitbucket Cloud REST API v2.0 async client."""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from bitbucket_jira_cli.api.base import BaseAsyncClient
+
+BASE_URL = "https://api.bitbucket.org/2.0"
+
+
+class BitbucketClient(BaseAsyncClient):
+    backend = "Bitbucket"
+
+    def __init__(self, authorization: str) -> None:
+        super().__init__(BASE_URL, {"Authorization": authorization})
+
+    # -- identity -----------------------------------------------------------
+    async def current_user(self) -> dict[str, Any]:
+        return await self.get_json("/user")
+
+    # -- repositories -------------------------------------------------------
+    async def get_repo(self, workspace: str, repo_slug: str) -> dict[str, Any]:
+        return await self.get_json(f"/repositories/{workspace}/{repo_slug}")
+
+    async def list_repos(
+        self, workspace: str, *, query: str | None = None, role: str | None = None, limit: int = 30
+    ) -> list[dict[str, Any]]:
+        params: dict[str, Any] = {"pagelen": min(limit, 100)}
+        if query:
+            params["q"] = query
+        if role:
+            params["role"] = role
+        return await self._paginate(f"/repositories/{workspace}", params=params, limit=limit)
+
+    async def list_workspace_members(
+        self, workspace: str, *, limit: int = 100
+    ) -> list[dict[str, Any]]:
+        return await self._paginate(f"/workspaces/{workspace}/members", limit=limit)
+
+    # -- pull requests ------------------------------------------------------
+    def _pr_base(self, workspace: str, repo_slug: str) -> str:
+        return f"/repositories/{workspace}/{repo_slug}/pullrequests"
+
+    async def create_pr(
+        self, workspace: str, repo_slug: str, body: dict[str, Any]
+    ) -> dict[str, Any]:
+        response = await self.request("POST", self._pr_base(workspace, repo_slug), json=body)
+        return response.json()
+
+    async def list_prs(
+        self,
+        workspace: str,
+        repo_slug: str,
+        *,
+        state: str | None = None,
+        source_branch: str | None = None,
+        query: str | None = None,
+        limit: int = 30,
+    ) -> list[dict[str, Any]]:
+        clauses = []
+        if state:
+            clauses.append(f'state="{state}"')
+        if source_branch:
+            clauses.append(f'source.branch.name="{source_branch}"')
+        if query:
+            clauses.append(query)
+        params: dict[str, Any] = {"pagelen": min(limit, 50)}
+        if clauses:
+            params["q"] = " AND ".join(clauses)
+        return await self._paginate(self._pr_base(workspace, repo_slug), params=params, limit=limit)
+
+    async def get_pr(self, workspace: str, repo_slug: str, pr_id: int) -> dict[str, Any]:
+        return await self.get_json(f"{self._pr_base(workspace, repo_slug)}/{pr_id}")
+
+    async def update_pr(
+        self, workspace: str, repo_slug: str, pr_id: int, body: dict[str, Any]
+    ) -> dict[str, Any]:
+        response = await self.request(
+            "PUT", f"{self._pr_base(workspace, repo_slug)}/{pr_id}", json=body
+        )
+        return response.json()
+
+    async def merge_pr(
+        self, workspace: str, repo_slug: str, pr_id: int, body: dict[str, Any]
+    ) -> dict[str, Any]:
+        response = await self.request(
+            "POST", f"{self._pr_base(workspace, repo_slug)}/{pr_id}/merge", json=body
+        )
+        return response.json()
+
+    async def decline_pr(self, workspace: str, repo_slug: str, pr_id: int) -> dict[str, Any]:
+        response = await self.request(
+            "POST", f"{self._pr_base(workspace, repo_slug)}/{pr_id}/decline"
+        )
+        return response.json()
+
+    async def pr_diff(self, workspace: str, repo_slug: str, pr_id: int) -> str:
+        response = await self.request("GET", f"{self._pr_base(workspace, repo_slug)}/{pr_id}/diff")
+        return response.text
+
+    async def pr_diffstat(self, workspace: str, repo_slug: str, pr_id: int) -> list[dict[str, Any]]:
+        return await self._paginate(
+            f"{self._pr_base(workspace, repo_slug)}/{pr_id}/diffstat", params={"pagelen": 100}
+        )
+
+    async def approve_pr(self, workspace: str, repo_slug: str, pr_id: int) -> dict[str, Any]:
+        response = await self.request(
+            "POST", f"{self._pr_base(workspace, repo_slug)}/{pr_id}/approve"
+        )
+        return response.json()
+
+    async def unapprove_pr(self, workspace: str, repo_slug: str, pr_id: int) -> None:
+        await self.request("DELETE", f"{self._pr_base(workspace, repo_slug)}/{pr_id}/approve")
+
+    async def request_changes_pr(
+        self, workspace: str, repo_slug: str, pr_id: int
+    ) -> dict[str, Any]:
+        response = await self.request(
+            "POST", f"{self._pr_base(workspace, repo_slug)}/{pr_id}/request-changes"
+        )
+        return response.json()
+
+    async def list_pr_comments(
+        self, workspace: str, repo_slug: str, pr_id: int, *, limit: int = 100
+    ) -> list[dict[str, Any]]:
+        return await self._paginate(
+            f"{self._pr_base(workspace, repo_slug)}/{pr_id}/comments",
+            params={"pagelen": 100},
+            limit=limit,
+        )
+
+    async def add_pr_comment(
+        self,
+        workspace: str,
+        repo_slug: str,
+        pr_id: int,
+        text: str,
+        *,
+        inline: dict[str, Any] | None = None,
+        parent_id: int | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"content": {"raw": text}}
+        if inline:
+            body["inline"] = inline
+        if parent_id is not None:
+            body["parent"] = {"id": parent_id}
+        response = await self.request(
+            "POST", f"{self._pr_base(workspace, repo_slug)}/{pr_id}/comments", json=body
+        )
+        return response.json()
+
+    def _comment_base(self, workspace: str, repo_slug: str, pr_id: int) -> str:
+        return f"{self._pr_base(workspace, repo_slug)}/{pr_id}/comments"
+
+    async def update_pr_comment(
+        self, workspace: str, repo_slug: str, pr_id: int, comment_id: int, text: str
+    ) -> dict[str, Any]:
+        response = await self.request(
+            "PUT",
+            f"{self._comment_base(workspace, repo_slug, pr_id)}/{comment_id}",
+            json={"content": {"raw": text}},
+        )
+        return response.json()
+
+    async def delete_pr_comment(
+        self, workspace: str, repo_slug: str, pr_id: int, comment_id: int
+    ) -> None:
+        await self.request(
+            "DELETE", f"{self._comment_base(workspace, repo_slug, pr_id)}/{comment_id}"
+        )
+
+    async def set_pr_comment_resolved(
+        self, workspace: str, repo_slug: str, pr_id: int, comment_id: int, *, resolved: bool
+    ) -> None:
+        method = "POST" if resolved else "DELETE"
+        await self.request(
+            method, f"{self._comment_base(workspace, repo_slug, pr_id)}/{comment_id}/resolve"
+        )
+
+    # -- pull request tasks -------------------------------------------------
+    def _task_base(self, workspace: str, repo_slug: str, pr_id: int) -> str:
+        return f"{self._pr_base(workspace, repo_slug)}/{pr_id}/tasks"
+
+    async def list_pr_tasks(
+        self, workspace: str, repo_slug: str, pr_id: int, *, limit: int = 100
+    ) -> list[dict[str, Any]]:
+        return await self._paginate(
+            self._task_base(workspace, repo_slug, pr_id), params={"pagelen": 100}, limit=limit
+        )
+
+    async def add_pr_task(
+        self,
+        workspace: str,
+        repo_slug: str,
+        pr_id: int,
+        text: str,
+        *,
+        comment_id: int | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"content": {"raw": text}}
+        if comment_id is not None:
+            body["comment"] = {"id": comment_id}
+        response = await self.request(
+            "POST", self._task_base(workspace, repo_slug, pr_id), json=body
+        )
+        return response.json()
+
+    async def update_pr_task(
+        self,
+        workspace: str,
+        repo_slug: str,
+        pr_id: int,
+        task_id: int,
+        *,
+        state: str | None = None,
+        text: str | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {}
+        if state is not None:
+            body["state"] = state
+        if text is not None:
+            body["content"] = {"raw": text}
+        response = await self.request(
+            "PUT", f"{self._task_base(workspace, repo_slug, pr_id)}/{task_id}", json=body
+        )
+        return response.json()
+
+    async def delete_pr_task(
+        self, workspace: str, repo_slug: str, pr_id: int, task_id: int
+    ) -> None:
+        await self.request(
+            "DELETE", f"{self._task_base(workspace, repo_slug, pr_id)}/{task_id}"
+        )
+
+    # -- pipelines ----------------------------------------------------------
+    def _pipe_base(self, workspace: str, repo_slug: str) -> str:
+        return f"/repositories/{workspace}/{repo_slug}/pipelines"
+
+    async def list_pipelines(
+        self, workspace: str, repo_slug: str, *, limit: int = 30
+    ) -> list[dict[str, Any]]:
+        return await self._paginate(
+            self._pipe_base(workspace, repo_slug),
+            params={"pagelen": min(limit, 50), "sort": "-created_on"},
+            limit=limit,
+        )
+
+    async def run_pipeline(
+        self, workspace: str, repo_slug: str, body: dict[str, Any]
+    ) -> dict[str, Any]:
+        response = await self.request("POST", self._pipe_base(workspace, repo_slug), json=body)
+        return response.json()
+
+    async def get_pipeline(self, workspace: str, repo_slug: str, uuid: str) -> dict[str, Any]:
+        return await self.get_json(f"{self._pipe_base(workspace, repo_slug)}/{quote(uuid)}")
+
+    async def stop_pipeline(self, workspace: str, repo_slug: str, uuid: str) -> None:
+        await self.request(
+            "POST", f"{self._pipe_base(workspace, repo_slug)}/{quote(uuid)}/stopPipeline"
+        )
+
+    async def list_pipeline_steps(
+        self, workspace: str, repo_slug: str, uuid: str
+    ) -> list[dict[str, Any]]:
+        return await self._paginate(
+            f"{self._pipe_base(workspace, repo_slug)}/{quote(uuid)}/steps", params={"pagelen": 100}
+        )
+
+    async def pipeline_step_log(
+        self, workspace: str, repo_slug: str, uuid: str, step_uuid: str
+    ) -> str:
+        response = await self.request(
+            "GET",
+            f"{self._pipe_base(workspace, repo_slug)}/{quote(uuid)}/steps/{quote(step_uuid)}/log",
+        )
+        return response.text
+
+    # -- generic passthrough (bj api) --------------------------------------
+    async def raw(
+        self, method: str, path: str, *, params: dict[str, Any] | None = None, json: Any = None
+    ) -> Any:
+        response = await self.request(method, path, params=params, json=json)
+        try:
+            return response.json()
+        except ValueError:
+            return response.text
+
+    # -- pagination ---------------------------------------------------------
+    async def _paginate(
+        self, url: str, *, params: dict[str, Any] | None = None, limit: int | None = None
+    ) -> list[dict[str, Any]]:
+        results: list[dict[str, Any]] = []
+        next_url: str | None = url
+        next_params = params
+        while next_url:
+            payload = await self.get_json(next_url, params=next_params)
+            results.extend(payload.get("values", []))
+            if limit is not None and len(results) >= limit:
+                return results[:limit]
+            next_url = payload.get("next")
+            next_params = None  # `next` is an absolute URL with its own query
+        return results

bitbucket_jira_cli/api/jira.py

@@ -0,0 +1,147 @@
+"""Jira Cloud REST API v3 async client.
+
+Uses the current ``/search/jql`` endpoint (the old ``/search`` was removed).
+Bodies (comments, descriptions) are ADF documents — see ``api.adf``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from bitbucket_jira_cli.api.base import DEFAULT_TIMEOUT
+from bitbucket_jira_cli.api.base import BaseAsyncClient
+from bitbucket_jira_cli.errors import ApiError
+
+
+async def fetch_cloud_id(site: str) -> str:
+    """Resolve a site's cloudId from its public tenant_info endpoint.
+
+    Needed to address a site through the api.atlassian.com/ex/jira/{cloudId}
+    gateway (scoped-token mode). No authentication required.
+    """
+    backend = "Jira"
+    url = site.rstrip("/") + "/_edge/tenant_info"
+    async with httpx.AsyncClient(timeout=DEFAULT_TIMEOUT, follow_redirects=True) as client:
+        response = await client.get(url)
+    if response.status_code >= httpx.codes.BAD_REQUEST:
+        msg = f"could not resolve cloudId from {url}"
+        raise ApiError(backend, response.status_code, msg)
+    cloud_id = response.json().get("cloudId")
+    if not cloud_id:
+        msg = "tenant_info returned no cloudId"
+        raise ApiError(backend, response.status_code, msg)
+    return str(cloud_id)
+
+
+class JiraClient(BaseAsyncClient):
+    backend = "Jira"
+
+    def __init__(self, base_url: str, authorization: str) -> None:
+        super().__init__(base_url, {"Authorization": authorization})
+
+    # -- identity -----------------------------------------------------------
+    async def myself(self) -> dict[str, Any]:
+        return await self.get_json("/myself")
+
+    # -- issues -------------------------------------------------------------
+    async def get_issue(
+        self, key: str, *, fields: list[str] | None = None, expand: list[str] | None = None
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {}
+        if fields:
+            params["fields"] = ",".join(fields)
+        if expand:
+            params["expand"] = ",".join(expand)
+        return await self.get_json(f"/issue/{key}", params=params or None)
+
+    async def get_editmeta(self, key: str) -> dict[str, Any]:
+        data = await self.get_json(f"/issue/{key}/editmeta")
+        return data.get("fields", {})
+
+    async def search_assignable_users(
+        self, query: str, *, issue_key: str, limit: int = 10
+    ) -> list[dict[str, Any]]:
+        return await self.get_json(
+            "/user/assignable/search",
+            params={"query": query, "issueKey": issue_key, "maxResults": limit},
+        )
+
+    async def create_issue(self, body: dict[str, Any]) -> dict[str, Any]:
+        response = await self.request("POST", "/issue", json=body)
+        return response.json()
+
+    async def edit_issue(self, key: str, body: dict[str, Any]) -> None:
+        await self.request("PUT", f"/issue/{key}", json=body)
+
+    async def search(
+        self, jql: str, *, fields: list[str] | None = None, limit: int = 50
+    ) -> list[dict[str, Any]]:
+        issues: list[dict[str, Any]] = []
+        token: str | None = None
+        payload_fields = fields or [
+            "summary",
+            "status",
+            "assignee",
+            "issuetype",
+            "priority",
+            "updated",
+        ]
+        while True:
+            body: dict[str, Any] = {
+                "jql": jql,
+                "maxResults": min(limit - len(issues), 100),
+                "fields": payload_fields,
+            }
+            if token:
+                body["nextPageToken"] = token
+            response = await self.request("POST", "/search/jql", json=body)
+            data = response.json()
+            issues.extend(data.get("issues", []))
+            token = data.get("nextPageToken")
+            if not token or len(issues) >= limit:
+                break
+        return issues[:limit]
+
+    # -- comments -----------------------------------------------------------
+    async def add_comment(self, key: str, adf_body: dict[str, Any]) -> dict[str, Any]:
+        response = await self.request("POST", f"/issue/{key}/comment", json={"body": adf_body})
+        return response.json()
+
+    async def list_comments(self, key: str) -> list[dict[str, Any]]:
+        data = await self.get_json(f"/issue/{key}/comment")
+        return data.get("comments", [])
+
+    # -- transitions --------------------------------------------------------
+    async def get_transitions(self, key: str) -> list[dict[str, Any]]:
+        data = await self.get_json(f"/issue/{key}/transitions")
+        return data.get("transitions", [])
+
+    async def transition_issue(self, key: str, transition_id: str) -> None:
+        await self.request(
+            "POST", f"/issue/{key}/transitions", json={"transition": {"id": transition_id}}
+        )
+
+    # -- remote links (link a PR URL to an issue) ---------------------------
+    async def create_remote_link(
+        self, key: str, url: str, title: str, *, global_id: str | None = None
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"object": {"url": url, "title": title}}
+        if global_id:
+            body["globalId"] = global_id
+        response = await self.request("POST", f"/issue/{key}/remotelink", json=body)
+        return response.json()
+
+    async def get_remote_links(self, key: str) -> list[dict[str, Any]]:
+        return await self.get_json(f"/issue/{key}/remotelink")
+
+    # -- generic passthrough (bj api) --------------------------------------
+    async def raw(
+        self, method: str, path: str, *, params: dict[str, Any] | None = None, json: Any = None
+    ) -> Any:
+        response = await self.request(method, path, params=params, json=json)
+        try:
+            return response.json()
+        except ValueError:
+            return response.text

bitbucket_jira_cli/auth/__init__.py

@@ -0,0 +1 @@
+"""Authentication: credential storage and the `bj auth` command group."""