pygitcode 0.1.2a0__py3-none-any.whl → 0.1.4__py3-none-any.whl

gitcode_cli/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.1.2a0"
+__version__ = "0.1.4"

gitcode_cli/adapters/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from .base import AdapterActionResult
+from .issues import IssueAdapter
+from .pulls import PullRequestAdapter
+
+__all__ = ["AdapterActionResult", "IssueAdapter", "PullRequestAdapter"]

gitcode_cli/adapters/base.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class AdapterActionResult:
+    item: dict[str, Any] | None = None
+    items: list[dict[str, Any]] | None = None
+    message: str | None = None
+    warning: str | None = None
+    degraded: bool = False
+    approximated: bool = False

gitcode_cli/adapters/capabilities.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import click
+
+CAPABILITY_MESSAGES = {
+    "ISSUE_COMMENT_LAST_NOT_FOUND": "No editable issue comment from the current user was found.",
+    "ISSUE_COMMENT_OWNERSHIP_UNVERIFIABLE": (
+        "Unable to verify the current user's issue comments on GitCode; refusing to edit or delete comments safely."
+    ),
+    "ISSUE_CREATE_IF_NONE_REQUIRES_EDIT_LAST": "--create-if-none can only be used together with --edit-last.",
+    "ISSUE_DEVELOP_BASE": "--base and --name are not supported by 'gc issue develop'",
+    "ISSUE_DEVELOP_NAME": "--base and --name are not supported by 'gc issue develop'",
+    "ISSUE_LIST_APP": "GitCode issue API does not support --app filtering.",
+    "ISSUE_STATUS_GH_SEMANTICS": (
+        "GitCode-limited approximation of gh issue status: assigned and opened issues use user-level "
+        "GitCode results; mentioned issues use repository mention filtering."
+    ),
+    "PR_MERGE_AUTHOR_EMAIL": "GitCode merge API does not support --author-email.",
+    "PR_MERGE_AUTO": "GitCode merge API does not support --auto.",
+    "PR_EDIT_BASE": (
+        "GitCode's pull request update API does not support changing the base branch; "
+        "-B/--base cannot be used with 'gc pr edit'."
+    ),
+    "PR_REVIEW_REQUEST_CHANGES": (
+        "GitCode review API does not support request-changes reviews; the pull request comment was posted instead."
+    ),
+    "PR_STATUS_GH_SEMANTICS": ("GitCode API approximation -- user-specific filtering is not available"),
+}
+
+
+def capability_message(feature: str) -> str:
+    return CAPABILITY_MESSAGES[feature]
+
+
+def unsupported(feature: str) -> click.ClickException:
+    return click.ClickException(capability_message(feature))

gitcode_cli/adapters/issues.py

@@ -0,0 +1,373 @@
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from ..errors import APIError
+from ..services import IssueService, UserService
+from .base import AdapterActionResult
+from .capabilities import capability_message
+
+
+def _normalize_multi_values(values: tuple[str, ...] | None) -> str | None:
+    if not values:
+        return None
+    return ",".join(values)
+
+
+def _normalize_labels(labels: tuple[str, ...] | None) -> tuple[str, ...] | None:
+    if not labels:
+        return None
+    normalized = tuple(label.strip() for label in labels if label.strip())
+    return normalized or None
+
+
+def _extract_label_names(issue: dict[str, Any] | None) -> list[str]:
+    labels = issue.get("labels") if isinstance(issue, dict) else None
+    if not labels:
+        return []
+    if isinstance(labels, str):
+        return [part.strip() for part in labels.split(",") if part.strip()]
+
+    names: list[str] = []
+    if isinstance(labels, list):
+        for label in labels:
+            if isinstance(label, dict):
+                name = label.get("name") or label.get("title")
+                if name:
+                    names.append(str(name))
+            elif label:
+                names.append(str(label))
+    return names
+
+
+def _extract_assignee_names(issue: dict[str, Any] | None) -> list[str]:
+    assignees = issue.get("assignees") if isinstance(issue, dict) else None
+    if isinstance(assignees, str):
+        return [part.strip() for part in assignees.split(",") if part.strip()]
+    if isinstance(assignees, list):
+        names: list[str] = []
+        for assignee in assignees:
+            if isinstance(assignee, dict):
+                name = _extract_login(assignee)
+                if name:
+                    names.append(name)
+            elif assignee:
+                names.append(str(assignee))
+        return names
+
+    assignee = issue.get("assignee") if isinstance(issue, dict) else None
+    if isinstance(assignee, str):
+        return [part.strip() for part in assignee.split(",") if part.strip()]
+    if isinstance(assignee, dict):
+        name = _extract_login(assignee)
+        return [name] if name else []
+    return []
+
+
+def _matches_all_labels(issue: dict[str, Any], labels: tuple[str, ...] | None) -> bool:
+    if not labels or len(labels) < 2:
+        return True
+    actual = {label.lower() for label in _extract_label_names(issue)}
+    return all(label.lower() in actual for label in labels)
+
+
+def _extract_login(data: dict[str, Any] | None) -> str | None:
+    if not isinstance(data, dict):
+        return None
+    for key in ("login", "username", "name"):
+        value = data.get(key)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    user = data.get("user")
+    if isinstance(user, dict):
+        return _extract_login(user)
+    author = data.get("author")
+    if isinstance(author, dict):
+        return _extract_login(author)
+    return None
+
+
+def _as_list(items: Any) -> list[Any]:
+    return items if isinstance(items, list) else []
+
+
+def _extract_label_options(items: list[Any]) -> set[str]:
+    names: set[str] = set()
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        name = item.get("name")
+        if isinstance(name, str) and name.strip():
+            names.add(name.strip())
+    return names
+
+
+def _resolve_milestone_number(items: list[Any], milestone: str | None) -> int | None:
+    if milestone is None:
+        return None
+    value = milestone.strip()
+    if not value:
+        return None
+    if value.isdigit():
+        return int(value)
+    matches: list[int] = []
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        title = item.get("title")
+        number = item.get("number")
+        if title != value:
+            continue
+        if isinstance(number, int):
+            matches.append(number)
+        elif isinstance(number, str) and number.isdigit():
+            matches.append(int(number))
+    if len(matches) == 1:
+        return matches[0]
+    if len(matches) > 1:
+        raise click.ClickException(f"could not resolve milestone: '{value}' matched multiple milestones")
+    raise click.ClickException(f"could not resolve milestone: '{value}' not found")
+
+
+class IssueAdapter:
+    def __init__(self, service: IssueService, user_service: UserService | None = None):
+        self.service = service
+        self.user_service = user_service
+
+    def _list_all_labels(self, owner: str, repo: str) -> list[Any]:
+        items: list[Any] = []
+        page = 1
+        while True:
+            page_items = _as_list(self.service.list_labels(owner, repo, page=page, per_page=100))
+            items.extend(page_items)
+            if len(page_items) < 100:
+                return items
+            page += 1
+
+    def _list_all_milestones(self, owner: str, repo: str) -> list[Any]:
+        items: list[Any] = []
+        page = 1
+        while True:
+            page_items = _as_list(self.service.list_milestones(owner, repo, state="all", page=page, per_page=100))
+            items.extend(page_items)
+            if len(page_items) < 100:
+                return items
+            page += 1
+
+    def list_issues(
+        self,
+        owner: str,
+        repo: str,
+        *,
+        state: str | None,
+        labels: tuple[str, ...] | None,
+        author: str | None,
+        assignee: str | None,
+        milestone: str | None,
+        mention: str | None,
+        search: str | None,
+        limit: int | None,
+    ) -> Any:
+        if author == "@me":
+            if self.user_service is None:
+                raise click.ClickException("failed to resolve @me: current user lookup is unavailable")
+            current_login = _extract_login(self.user_service.current())
+            if not current_login:
+                raise click.ClickException("failed to resolve @me: current user has no login")
+            author = current_login
+        items = self.service.list(
+            owner,
+            repo,
+            state=state,
+            labels=_normalize_multi_values(labels),
+            creator=author,
+            assignee=assignee,
+            milestone=milestone,
+            mention=mention,
+            search=search,
+        )
+        if isinstance(items, list) and labels and len(labels) > 1:
+            items = [item for item in items if _matches_all_labels(item, labels)]
+        if limit is not None:
+            return items[:limit]
+        return items
+
+    def create_issue(
+        self,
+        owner: str,
+        repo: str,
+        *,
+        title: str,
+        body: str | None,
+        assignee: str | None,
+        labels: tuple[str, ...] | None,
+        milestone: str | None,
+    ) -> dict[str, Any] | None:
+        normalized_labels = _normalize_labels(labels)
+        if normalized_labels:
+            available_labels = _extract_label_options(self._list_all_labels(owner, repo))
+            for label in normalized_labels:
+                if label not in available_labels:
+                    raise click.ClickException(f"could not add label: '{label}' not found")
+        milestone_number = None
+        if milestone is not None:
+            milestones = []
+            if not milestone.strip().isdigit():
+                milestones = self._list_all_milestones(owner, repo)
+            milestone_number = _resolve_milestone_number(milestones, milestone)
+        return self.service.create(
+            owner,
+            repo,
+            title=title,
+            body=body,
+            assignee=assignee,
+            labels=_normalize_multi_values(normalized_labels),
+            milestone=milestone_number,
+        )
+
+    def close_issue(
+        self,
+        owner: str,
+        repo: str,
+        number: str,
+        *,
+        comment: str | None,
+        reason: str | None,
+    ) -> AdapterActionResult:
+        current = self.service.get(owner, repo, number)
+        if current and current.get("state") == "closed":
+            if comment:
+                self.service.comment(owner, repo, number, comment)
+                return AdapterActionResult(item=current, message="already_closed_commented")
+            return AdapterActionResult(item=current, message="already_closed")
+        if comment:
+            self.service.comment(owner, repo, number, comment)
+        payload: dict[str, Any] = {"state": "close"}
+        if reason:
+            payload["state_reason"] = reason
+        item = self.service.update(owner, repo, number, **payload)
+        return AdapterActionResult(item=item, message="closed")
+
+    def comment_issue(self, owner: str, repo: str, number: str, *, body: str) -> dict[str, Any] | None:
+        return self.service.comment(owner, repo, number, body)
+
+    def manage_comment_history(
+        self,
+        owner: str,
+        repo: str,
+        number: str,
+        *,
+        body: str | None,
+        delete_last: bool,
+        create_if_none: bool,
+    ) -> AdapterActionResult:
+        comment = self._find_last_owned_comment(owner, repo, number)
+        if delete_last:
+            if comment is None:
+                raise click.ClickException(capability_message("ISSUE_COMMENT_LAST_NOT_FOUND"))
+            self.service.delete_comment(owner, repo, comment["id"])
+            return AdapterActionResult(item=comment, message="deleted")
+        if comment is None:
+            if create_if_none:
+                item = self.service.comment(owner, repo, number, body or "")
+                return AdapterActionResult(item=item, message="created")
+            raise click.ClickException(capability_message("ISSUE_COMMENT_LAST_NOT_FOUND"))
+        item = self.service.update_comment(owner, repo, comment["id"], body or "")
+        return AdapterActionResult(item=item, message="edited")
+
+    def _find_last_owned_comment(self, owner: str, repo: str, number: str) -> dict[str, Any] | None:
+        if self.user_service is None:
+            raise click.ClickException(capability_message("ISSUE_COMMENT_OWNERSHIP_UNVERIFIABLE"))
+        try:
+            current_user = self.user_service.current()
+        except APIError as exc:
+            raise click.ClickException(capability_message("ISSUE_COMMENT_OWNERSHIP_UNVERIFIABLE")) from exc
+        current_login = _extract_login(current_user)
+        if not current_login:
+            raise click.ClickException(capability_message("ISSUE_COMMENT_OWNERSHIP_UNVERIFIABLE"))
+        comments = self.service.list_comments(owner, repo, number) or []
+        for comment in reversed(comments):
+            if not isinstance(comment, dict):
+                continue
+            if _extract_login(comment) == current_login:
+                return comment
+        return None
+
+    def reopen_issue(self, owner: str, repo: str, number: str, *, comment: str | None = None) -> AdapterActionResult:
+        current = self.service.get(owner, repo, number)
+        if current and current.get("state") == "open":
+            return AdapterActionResult(item=current, message="already_open")
+        item = self.service.update(owner, repo, number, state="reopen")
+        if comment:
+            self.service.comment(owner, repo, number, comment)
+        return AdapterActionResult(item=item, message="reopened")
+
+    def delete_issue(self, owner: str, repo: str, number: str) -> AdapterActionResult:
+        item = self.service.delete(owner, repo, number)
+        return AdapterActionResult(item=item, message="deleted")
+
+    def edit_issue(
+        self,
+        owner: str,
+        repo: str,
+        number: str,
+        *,
+        title: str | None,
+        body: str | None,
+        add_assignee: str | None,
+        add_labels: tuple[str, ...] | None,
+        remove_assignee: str | None,
+        remove_labels: tuple[str, ...] | None,
+        milestone: int | None,
+        remove_milestone: bool,
+    ) -> dict[str, Any] | None:
+        data: dict[str, Any] = {k: v for k, v in {"title": title, "body": body}.items() if v is not None}
+
+        if add_assignee is not None:
+            data["assignee"] = add_assignee
+        if remove_assignee is not None:
+            current = self.service.get(owner, repo, number)
+            remaining = [name for name in _extract_assignee_names(current) if name != remove_assignee]
+            data["assignee"] = ",".join(remaining)
+
+        if add_labels or remove_labels:
+            current = self.service.get(owner, repo, number)
+            existing = _extract_label_names(current)
+            removed = {label.strip() for label in remove_labels or () if label.strip()}
+            merged: list[str] = []
+            seen: set[str] = set()
+            for label in [*existing, *list(add_labels or ())]:
+                normalized = label.strip()
+                if normalized and normalized not in removed and normalized not in seen:
+                    seen.add(normalized)
+                    merged.append(normalized)
+            data["labels"] = ",".join(merged)
+
+        if milestone is not None:
+            data["milestone"] = milestone
+        if remove_milestone:
+            data["milestone"] = 0
+        return self.service.update(owner, repo, number, **data)
+
+    def status(self, owner: str, repo: str) -> AdapterActionResult:
+        if self.user_service is None:
+            raise click.ClickException("failed to resolve current user: current user lookup is unavailable")
+        current_login = _extract_login(self.user_service.current())
+        if not current_login:
+            raise click.ClickException("failed to resolve current user: current user has no login")
+        assigned = self.service.list_user_issues(filter="assigned", state="open") or []
+        created = self.service.list_user_issues(filter="created", state="open") or []
+        mentioned = self.service.list(owner, repo, state="open", mention=current_login) or []
+        return AdapterActionResult(
+            item={"assigned": assigned, "mentioned": mentioned, "createdBy": created},
+            message=capability_message("ISSUE_STATUS_GH_SEMANTICS"),
+            approximated=True,
+        )
+
+    def develop(self, owner: str, repo: str, number: str, *, base: str | None, name: str | None) -> AdapterActionResult:  # noqa: ARG002
+        return AdapterActionResult(
+            message=f"Opening issue #{number} in the browser instead.",
+            warning="Note: 'issue develop' does not create a local branch on GitCode.",
+        )

gitcode_cli/adapters/pulls.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..services import PullRequestService
+from .base import AdapterActionResult
+from .capabilities import capability_message
+
+
+def _normalize_multi_values(values: tuple[str, ...] | None) -> str | None:
+    if not values:
+        return None
+    return ",".join(values)
+
+
+def _normalize_limit(limit: int | None) -> tuple[int, int | None]:
+    if limit is None:
+        return 30, 30
+    if limit < 0:
+        return 100, None
+    if limit == 0:
+        return 0, 0
+    return min(limit, 100), limit
+
+
+class PullRequestAdapter:
+    def __init__(self, service: PullRequestService):
+        self.service = service
+
+    def list_prs(
+        self,
+        owner: str,
+        repo: str,
+        *,
+        state: str | None,
+        author: str | None,
+        base: str | None,
+        assignee: str | None,
+        draft: bool | None,
+        head: str | None,
+        labels: tuple[str, ...] | None,
+        search: str | None,
+        limit: int | None,
+        merged_after: str | None = None,
+        merged_before: str | None = None,
+    ) -> Any:
+        params = {
+            "state": state,
+            "author": author,
+            "base": base,
+            "assignee": assignee,
+            "draft": draft,
+            "head": head,
+            "labels": _normalize_multi_values(labels),
+        }
+        if search is not None:
+            params["search"] = search
+        if merged_after is not None:
+            params["merged_after"] = merged_after
+        if merged_before is not None:
+            params["merged_before"] = merged_before
+
+        per_page, remaining = _normalize_limit(limit)
+        if remaining == 0:
+            return []
+
+        items = []
+        page = 1
+        while True:
+            page_items = self.service.list(owner, repo, **params, page=page, per_page=per_page)
+            if not page_items:
+                break
+            items.extend(page_items)
+            if remaining is not None and len(items) >= remaining:
+                return items[:remaining]
+            if len(page_items) < per_page:
+                break
+            page += 1
+        return items
+
+    def create_pr(
+        self,
+        owner: str,
+        repo: str,
+        *,
+        title: str,
+        body: str | None,
+        base: str,
+        head: str,
+        draft: bool,
+        milestone: str | None,
+        labels: tuple[str, ...] | None,
+        reviewers: tuple[str, ...] | None,
+        assignees: tuple[str, ...] | None,
+        dry_run: bool,
+    ) -> AdapterActionResult:
+        payload = {
+            "title": title,
+            "body": body,
+            "base": base,
+            "head": head,
+            "draft": draft,
+            "labels": _normalize_multi_values(labels),
+            "assignees": _normalize_multi_values(assignees),
+            "reviewers": _normalize_multi_values(reviewers),
+            "milestone": milestone,
+        }
+        if dry_run:
+            return AdapterActionResult(item={k: v for k, v in payload.items() if v is not None})
+        return AdapterActionResult(item=self.service.create(owner, repo, **payload))
+
+    def merge_pr(
+        self,
+        owner: str,
+        repo: str,
+        number: int,
+        *,
+        merge_method: str,
+        body: str | None,
+        subject: str | None,
+        admin: bool,
+    ) -> dict[str, Any] | None:
+        payload = {
+            "merge_method": merge_method,
+            "description": body,
+            "title": subject,
+            "force_merge": True if admin else None,
+        }
+        return self.service.merge(owner, repo, number, **payload)
+
+    def review_pr(
+        self,
+        owner: str,
+        repo: str,
+        number: int,
+        *,
+        approve: bool,  # noqa: ARG002
+        body: str | None,
+        comment: bool,
+        request_changes: bool,
+        force: bool,
+    ) -> AdapterActionResult:
+        if comment:
+            item = self.service.comment(owner, repo, number, body=body or "")
+            return AdapterActionResult(item=item)
+        if request_changes:
+            item = self.service.comment(owner, repo, number, body=body or "")
+            return AdapterActionResult(
+                item=item,
+                message=capability_message("PR_REVIEW_REQUEST_CHANGES"),
+                degraded=True,
+            )
+        item = self.service.review(owner, repo, number, force=force)
+        return AdapterActionResult(item=item)
+
+    def edit_pr(
+        self,
+        owner: str,
+        repo: str,
+        number: int,
+        *,
+        title: str | None,
+        body: str | None,
+        add_assignee: str | None,
+        add_label: str | None,
+        add_reviewer: str | None,
+        remove_assignee: str | None,
+        remove_label: str | None,
+        remove_reviewer: str | None,
+        milestone: str | None,
+        remove_milestone: bool,
+    ) -> dict[str, Any] | None:
+        data = {
+            k: v
+            for k, v in {
+                "title": title,
+                "body": body,
+                "assignee": add_assignee,
+                "labels": add_label,
+                "reviewer": add_reviewer,
+                "unassignee": remove_assignee,
+                "unset_labels": remove_label,
+                "unset_reviewer": remove_reviewer,
+                "milestone": milestone,
+            }.items()
+            if v is not None
+        }
+        if remove_milestone:
+            data["milestone"] = ""
+        return self.service.update(owner, repo, number, **data)
+
+    def status(self, owner: str, repo: str) -> AdapterActionResult:
+        items = self.service.list(owner, repo, state="open")
+        return AdapterActionResult(
+            items=items,
+            message=capability_message("PR_STATUS_GH_SEMANTICS"),
+            approximated=True,
+        )