pygitcode 0.1.0__py3-none-any.whl

gitcode_cli/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

gitcode_cli/cli.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import click
+
+from . import __version__
+from .commands.auth import auth_group
+from .commands.issue import issue_group
+from .commands.pr import pr_group
+from .config import get_token
+from .context import AppContext
+from .errors import GCError
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.version_option(version=__version__, prog_name="gc")
+@click.option("--repo", "repo_name", "-R", help="Select another repository using the [HOST/]OWNER/REPO format.")
+@click.option("--token", hidden=True, help="Override authentication token.")
+@click.pass_context
+def main(ctx: click.Context, repo_name: str | None, token: str | None) -> None:
+    ctx.ensure_object(dict)
+    try:
+        resolved_token = token or get_token()
+    except GCError:
+        resolved_token = token
+    ctx.obj["app"] = AppContext(token=resolved_token or "", repo=repo_name)
+
+
+@main.result_callback()
+def process_result(*_args: object, **_kwargs: object) -> None:
+    return None
+
+
+@main.command("version")
+def version_command() -> None:
+    click.echo(f"gc version {__version__}")
+
+
+main.add_command(auth_group)
+main.add_command(issue_group)
+main.add_command(pr_group)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

gitcode_cli/cli_compat.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+
+import click
+
+from .utils import get_current_git_branch, get_default_git_branch, read_body_file
+
+
+def get_body_from_options(body: str | None, body_file: str | None, editor: bool) -> str | None:
+    """Resolve body text from inline text, file/stdin, or editor."""
+    if body is not None:
+        return body
+    if body_file:
+        if body_file == "-":
+            return sys.stdin.read()
+        return read_body_file(body_file)
+    if editor:
+        return click.edit()
+    return None
+
+
+def get_default_base_branch() -> str:
+    """Return the detected default git branch for CLI base-branch inference."""
+    branch = get_default_git_branch()
+    if not branch:
+        raise click.ClickException("Unable to determine the default base branch. Use --base.")
+    return branch
+
+
+def normalize_multi_values(values: tuple[str, ...] | None) -> str | None:
+    """Normalize repeatable click option values for API calls."""
+    if not values:
+        return None
+    return ",".join(values)
+
+
+def resolve_pr_identifier_or_current_branch(identifier: str | None) -> str:
+    """Return the given PR identifier or fall back to the current branch name."""
+    if identifier is not None:
+        return identifier
+    branch = get_current_git_branch()
+    if not branch:
+        raise click.ClickException("Unable to detect current branch. Specify a PR or branch explicitly.")
+    return branch
+
+
+def get_fill_info(mode: str = "last") -> tuple[str, str]:
+    """Get title and body from git commits on current branch.
+
+    Args:
+        mode: "last" (latest commit), "first" (first commit), or "verbose" (all commits)
+
+    Returns:
+        (title, body) tuple
+    """
+    base_branch = get_default_git_branch() or "main"
+    current_branch = get_current_git_branch()
+    if not current_branch:
+        raise click.ClickException("Unable to detect current branch for --fill.")
+
+    try:
+        if mode == "last":
+            result = subprocess.run(
+                ["git", "log", "-1", "--format=%s%n%n%b", "--no-merges"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+        elif mode == "first":
+            result = subprocess.run(
+                ["git", "log", f"{base_branch}..{current_branch}", "--format=%s%n%n%b", "--no-merges", "--reverse"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            lines = result.stdout.strip().split("\n\n", 1)
+            result = subprocess.run(
+                ["echo", lines[0] if lines else ""],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+        else:
+            result = subprocess.run(
+                ["git", "log", f"{base_branch}..{current_branch}", "--format=%s%n%n%b", "--no-merges"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+    except subprocess.CalledProcessError as exc:
+        raise click.ClickException(f"Failed to get commit info: {exc}") from exc
+
+    output = result.stdout.strip()
+    if not output:
+        return "", ""
+
+    parts = output.split("\n\n", 1)
+    title = parts[0].strip()
+    body = parts[1].strip() if len(parts) > 1 else ""
+
+    if mode == "verbose" and body:
+        lines = []
+        commits = subprocess.run(
+            ["git", "log", f"{base_branch}..{current_branch}", "--format=%s", "--no-merges"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        for line in commits.stdout.strip().split("\n"):
+            if line:
+                lines.append(f"- {line}")
+        body = "\n".join(lines)
+
+    return title, body

gitcode_cli/client.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+from urllib.parse import urljoin
+
+import httpx
+
+from .errors import APIError
+
+BASE_URL = "https://api.gitcode.com/api/v5/"
+
+
+class GitCodeClient:
+    def __init__(self, token: str, base_url: str = BASE_URL):
+        self.token = token
+        self.base_url = base_url
+        self._client = httpx.Client(timeout=30.0)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        accept: str = "application/json",
+        response_format: Literal["json", "text"] = "json",
+    ) -> Any | None:
+        merged_params: dict[str, Any] = {"access_token": self.token}
+        if params:
+            merged_params.update({k: v for k, v in params.items() if v is not None})
+        response = self._client.request(
+            method,
+            urljoin(self.base_url, path.lstrip("/")),
+            params=merged_params,
+            json=json,
+            headers={"Accept": accept},
+        )
+        if response.status_code >= 400:
+            try:
+                data = response.json()
+                message = data.get("message") or str(data)
+            except Exception:
+                message = response.text
+            raise APIError(message or "GitCode API request failed", response.status_code)
+        if not response.content:
+            return None
+        if response_format == "text":
+            return response.text
+        return response.json()
+
+    def get(self, path: str, *, params: dict[str, Any] | None = None) -> Any | None:
+        return self.request("GET", path, params=params)
+
+    def post(
+        self, path: str, *, params: dict[str, Any] | None = None, json: dict[str, Any] | None = None
+    ) -> Any | None:
+        return self.request("POST", path, params=params, json=json)
+
+    def patch(
+        self, path: str, *, params: dict[str, Any] | None = None, json: dict[str, Any] | None = None
+    ) -> Any | None:
+        return self.request("PATCH", path, params=params, json=json)
+
+    def put(self, path: str, *, params: dict[str, Any] | None = None, json: dict[str, Any] | None = None) -> Any | None:
+        return self.request("PUT", path, params=params, json=json)
+
+    def delete(
+        self, path: str, *, params: dict[str, Any] | None = None, json: dict[str, Any] | None = None
+    ) -> Any | None:
+        return self.request("DELETE", path, params=params, json=json)

gitcode_cli/commands/auth.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import click
+
+from ..config import save_config
+
+
+@click.group("auth")
+def auth_group() -> None:
+    pass
+
+
+@auth_group.command("login")
+@click.option("--with-token", is_flag=True, help="Read token from stdin.")
+def auth_login(with_token: bool) -> None:
+    if with_token:
+        token = click.get_text_stream("stdin").read().strip()
+        if not token:
+            raise click.ClickException("No token provided on stdin.")
+    else:
+        token = click.prompt("GitCode token", hide_input=True)
+    save_config({"token": token})
+    click.echo("Authentication saved.")

gitcode_cli/commands/issue.py

@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+import click
+
+from ..cli_compat import get_body_from_options, normalize_multi_values
+from ..formatters import format_issue_detail, format_issue_list, output_result
+from ..repo import resolve_repo
+from ..services import IssueService
+from ..utils import open_in_browser, prompt_if_missing, read_body_file, resolve_issue_arg
+
+
+def _echo_issue_summary(items: list[dict]) -> None:
+    output = format_issue_list(items)
+    if output:
+        click.echo(output)
+
+
+@click.group("issue")
+def issue_group() -> None:
+    pass
+
+
+@issue_group.command("list")
+@click.option("-R", "--repo", "repo_name", help="Select another repository using the [HOST/]OWNER/REPO format.")
+@click.option("-s", "--state")
+@click.option("-l", "--label", "labels", multiple=True)
+@click.option("-A", "--author")
+@click.option("-a", "--assignee")
+@click.option("--milestone")
+@click.option("--mention")
+@click.option("-S", "--search")
+@click.option("-L", "--limit", type=int, default=30, show_default=True, help="Maximum number of items to fetch.")
+@click.option("-w", "--web", is_flag=True, help="Open the issue list in the web browser.")
+@click.option("--json", "json_fields", help="Output JSON. Optionally specify comma-separated fields.")
+@click.option("-q", "--jq", "jq_query", help="Filter JSON output using a jq expression.")
+@click.option("-t", "--template", help="Format output using a Go template string.")
+@click.pass_context
+def issue_list(
+    ctx: click.Context,
+    repo_name: str | None,
+    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,
+    web: bool,
+    json_fields: str | None,
+    jq_query: str | None,
+    template: str | None,
+) -> None:
+    app = ctx.obj["app"]
+    owner, repo = resolve_repo(repo_name or app.repo)
+    if web:
+        open_in_browser(f"https://gitcode.com/{owner}/{repo}/issues")
+        return
+    service = IssueService(app.client())
+    labels_str = normalize_multi_values(labels)
+    items = service.list(
+        owner,
+        repo,
+        state=state,
+        labels=labels_str,
+        creator=author,
+        assignee=assignee,
+        milestone=milestone,
+        mention=mention,
+        search=search,
+    )
+    if limit is not None:
+        items = items[:limit]
+    output_result(
+        items,
+        json_fields,
+        jq_query,
+        template,
+        default_formatter=_echo_issue_summary,
+    )
+
+
+@issue_group.command("view")
+@click.option("-R", "--repo", "repo_name", help="Select another repository using the [HOST/]OWNER/REPO format.")
+@click.argument("identifier")
+@click.option("-w", "--web", is_flag=True, help="Open the issue in the web browser.")
+@click.option("-c", "--comments", is_flag=True, help="View issue comments.")
+@click.option("--json", "json_fields", help="Output JSON. Optionally specify comma-separated fields.")
+@click.option("-q", "--jq", "jq_query", help="Filter JSON output using a jq expression.")
+@click.option("-t", "--template", help="Format output using a Go template string.")
+@click.pass_context
+def issue_view(
+    ctx: click.Context,
+    repo_name: str | None,
+    identifier: str,
+    web: bool,
+    comments: bool,
+    json_fields: str | None,
+    jq_query: str | None,
+    template: str | None,
+) -> None:
+    app = ctx.obj["app"]
+    url_owner, url_repo, number = resolve_issue_arg(identifier)
+    if url_owner:
+        assert url_repo is not None
+        owner, repo = url_owner, url_repo
+    else:
+        owner, repo = resolve_repo(repo_name or app.repo)
+    if web:
+        target_url = identifier if url_owner else f"https://gitcode.com/{owner}/{repo}/issues/{number}"
+        open_in_browser(target_url)
+        return
+    service = IssueService(app.client())
+    item = service.get(owner, repo, number)
+    if comments:
+        comment_items = service.list_comments(owner, repo, number)
+        data = dict(item) if item else {}
+        data["comments"] = comment_items
+
+        def default_formatter(data: dict) -> None:
+            click.echo(format_issue_detail(data))
+            if comment_items:
+                click.echo("\nComments:")
+                for comment in comment_items:
+                    click.echo(f"- {comment.get('body') or ''}")
+
+        output_result(
+            data,
+            json_fields,
+            jq_query,
+            template,
+            default_formatter=default_formatter,
+        )
+        return
+    output_result(
+        item,
+        json_fields,
+        jq_query,
+        template,
+        default_formatter=lambda data: click.echo(format_issue_detail(data)),
+    )
+
+
+@issue_group.command("create")
+@click.option("-R", "--repo", "repo_name", help="Select another repository using the [HOST/]OWNER/REPO format.")
+@click.option("-t", "--title")
+@click.option("-b", "--body")
+@click.option("-a", "--assignee")
+@click.option("-l", "--label", "labels")
+@click.option("-m", "--milestone")
+@click.option("-F", "--body-file")
+@click.option("-w", "--web", is_flag=True, help="Open the issue in the web browser.")
+@click.option("--json", "json_fields", help="Output JSON. Optionally specify comma-separated fields.")
+@click.option("-q", "--jq", "jq_query", help="Filter JSON output using a jq expression.")
+@click.option("--template", help="Format output using a Go template string.")
+@click.pass_context
+def issue_create(
+    ctx: click.Context,
+    repo_name: str | None,
+    title: str | None,
+    body: str | None,
+    assignee: str | None,
+    labels: str | None,
+    milestone: str | None,
+    body_file: str | None,
+    web: bool,
+    json_fields: str | None,
+    jq_query: str | None,
+    template: str | None,
+) -> None:
+    app = ctx.obj["app"]
+    owner, repo = resolve_repo(repo_name or app.repo)
+    if web:
+        open_in_browser(f"https://gitcode.com/{owner}/{repo}/issues/new")
+        return
+    title = prompt_if_missing(title, "Title")
+    if body_file:
+        body = read_body_file(body_file)
+    service = IssueService(app.client())
+    item = service.create(owner, repo, title=title, body=body, assignee=assignee, labels=labels, milestone=milestone)
+    output_result(
+        item,
+        json_fields,
+        jq_query,
+        template,
+        default_formatter=lambda data: click.echo(data["html_url"]),
+    )
+
+
+@issue_group.command("close")
+@click.option("-R", "--repo", "repo_name", help="Select another repository using the [HOST/]OWNER/REPO format.")
+@click.argument("identifier")
+@click.pass_context
+def issue_close(ctx: click.Context, repo_name: str | None, identifier: str) -> None:
+    app = ctx.obj["app"]
+    url_owner, url_repo, number = resolve_issue_arg(identifier)
+    if url_owner:
+        assert url_repo is not None
+        owner, repo = url_owner, url_repo
+    else:
+        owner, repo = resolve_repo(repo_name or app.repo)
+    service = IssueService(app.client())
+    item = service.update(owner, repo, number, state="closed")
+    click.echo(f"Closed issue #{item['number']}")
+
+
+@issue_group.command("comment")
+@click.option("-R", "--repo", "repo_name", help="Select another repository using the [HOST/]OWNER/REPO format.")
+@click.argument("identifier")
+@click.option("-b", "--body")
+@click.option("-F", "--body-file")
+@click.option("-e", "--editor", is_flag=True)
+@click.option("-w", "--web", is_flag=True, help="Open the issue in the web browser.")
+@click.pass_context
+def issue_comment(
+    ctx: click.Context,
+    repo_name: str | None,
+    identifier: str,
+    body: str | None,
+    body_file: str | None,
+    editor: bool,
+    web: bool,
+) -> None:
+    app = ctx.obj["app"]
+    url_owner, url_repo, number = resolve_issue_arg(identifier)
+    if url_owner:
+        assert url_repo is not None
+        owner, repo = url_owner, url_repo
+    else:
+        owner, repo = resolve_repo(repo_name or app.repo)
+    if web:
+        open_in_browser(f"https://gitcode.com/{owner}/{repo}/issues/{number}")
+        return
+    body = get_body_from_options(body=body, body_file=body_file, editor=editor)
+    body = prompt_if_missing(body, "Body")
+    service = IssueService(app.client())
+    item = service.comment(owner, repo, number, body)
+    click.echo(str(item["id"]))
+
+
+@issue_group.command("reopen")
+@click.option("-R", "--repo", "repo_name", help="Select another repository using the [HOST/]OWNER/REPO format.")
+@click.argument("identifier")
+@click.pass_context
+def issue_reopen(ctx: click.Context, repo_name: str | None, identifier: str) -> None:
+    app = ctx.obj["app"]
+    url_owner, url_repo, number = resolve_issue_arg(identifier)
+    if url_owner:
+        assert url_repo is not None
+        owner, repo = url_owner, url_repo
+    else:
+        owner, repo = resolve_repo(repo_name or app.repo)
+    service = IssueService(app.client())
+    item = service.update(owner, repo, number, state="open")
+    click.echo(f"Reopened issue #{item['number']}")
+
+
+@issue_group.command("edit")
+@click.option("-R", "--repo", "repo_name", help="Select another repository using the [HOST/]OWNER/REPO format.")
+@click.argument("identifier")
+@click.option("-t", "--title")
+@click.option("-b", "--body")
+@click.option("-a", "--add-assignee")
+@click.option("-l", "--add-label")
+@click.option("--remove-assignee")
+@click.option("--remove-label")
+@click.pass_context
+def issue_edit(
+    ctx: click.Context,
+    repo_name: str | None,
+    identifier: str,
+    title: str | None,
+    body: str | None,
+    add_assignee: str | None,
+    add_label: str | None,
+    remove_assignee: str | None,
+    remove_label: str | None,
+) -> None:
+    app = ctx.obj["app"]
+    url_owner, url_repo, number = resolve_issue_arg(identifier)
+    if url_owner:
+        assert url_repo is not None
+        owner, repo = url_owner, url_repo
+    else:
+        owner, repo = resolve_repo(repo_name or app.repo)
+    service = IssueService(app.client())
+    data = {
+        k: v
+        for k, v in {
+            "title": title,
+            "body": body,
+            "assignee": add_assignee,
+            "labels": add_label,
+            "unassignee": remove_assignee,
+            "unset_labels": remove_label,
+        }.items()
+        if v is not None
+    }
+    if not data:
+        raise click.UsageError("must specify at least one field to edit")
+    item = service.update(owner, repo, number, **data)
+    click.echo(f"Edited issue #{item['number']}")
+
+
+@issue_group.command("delete")
+@click.option("-R", "--repo", "repo_name", help="Select another repository using the [HOST/]OWNER/REPO format.")
+@click.argument("identifier")
+@click.confirmation_option(prompt="Are you sure you want to delete this issue?")
+@click.pass_context
+def issue_delete(ctx: click.Context, repo_name: str | None, identifier: str) -> None:
+    app = ctx.obj["app"]
+    url_owner, url_repo, number = resolve_issue_arg(identifier)
+    if url_owner:
+        assert url_repo is not None
+        owner, repo = url_owner, url_repo
+    else:
+        owner, repo = resolve_repo(repo_name or app.repo)
+    service = IssueService(app.client())
+    service.delete(owner, repo, number)
+    click.echo(f"Deleted issue #{number}")
+
+
+@issue_group.command("status")
+@click.option("-R", "--repo", "repo_name", help="Select another repository using the [HOST/]OWNER/REPO format.")
+@click.pass_context
+def issue_status(ctx: click.Context, repo_name: str | None) -> None:
+    app = ctx.obj["app"]
+    owner, repo = resolve_repo(repo_name or app.repo)
+    service = IssueService(app.client())
+    items = service.list(owner, repo, state="open")
+    click.echo("GitCode-limited approximation of gh issue status")
+    click.echo(f"Repository open issues for {owner}/{repo}:")
+    for item in items:
+        click.echo(f"  #{item['number']}\t{item['state']}\t{item['title']}")
+
+
+issue_group.add_command(issue_list, name="ls")
+issue_group.add_command(issue_create, name="new")