codeberg-cli 0.1.0__py3-none-any.whl

codeberg_cli/__main__.py

@@ -0,0 +1,8 @@
+from xclif import Cli
+
+from . import routes
+
+cli = Cli.from_routes(routes)
+
+if __name__ == "__main__":
+    cli()

codeberg_cli/client.py

@@ -0,0 +1,70 @@
+import httpx
+from rich.status import Status
+from xclif.context import get_context
+
+BASE_URL = "https://codeberg.org/api/v1"
+
+_VERBS = {
+    "GET": "Fetching",
+    "POST": "Creating",
+    "PATCH": "Updating",
+    "DELETE": "Deleting",
+}
+
+
+class ClientError(RuntimeError):
+    """Raised when the API returns a non-2xx status."""
+
+
+class Client:
+    """HTTP client for the Codeberg API."""
+
+    def __init__(self, token: str | None = None) -> None:
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "codeberg-cli/0.1.0",
+            "Content-Type": "application/json",
+        }
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+        self._client = httpx.Client(base_url=BASE_URL, headers=headers, timeout=30.0)
+
+    def get(
+        self, path: str, params: dict | None = None, action: str | None = None
+    ) -> dict | list:
+        return self._request("GET", path, params=params, action=action)
+
+    def post(
+        self, path: str, data: dict | None = None, action: str | None = None
+    ) -> dict | list:
+        return self._request("POST", path, json=data, action=action)
+
+    def patch(
+        self, path: str, data: dict | None = None, action: str | None = None
+    ) -> dict | list:
+        return self._request("PATCH", path, json=data, action=action)
+
+    def delete(self, path: str, action: str | None = None) -> None:
+        self._request("DELETE", path, action=action)
+
+    def _request(
+        self, method: str, path: str, action: str | None = None, **kwargs
+    ) -> dict | list | None:
+        ctx = get_context()
+        label = action or (
+            f"{method} {path}"
+            if ctx.verbosity >= 2
+            else f"{_VERBS.get(method, method)} {path.split('/')[-1]}"
+        )
+        with Status(f"{label}..."):
+            response = self._client.request(method, path, **kwargs)
+        if not response.is_success:
+            msg = (
+                response.json().get("message", "unknown error")
+                if response.text
+                else "unknown error"
+            )
+            raise ClientError(f"{response.status_code} {msg}")
+        if response.status_code == 204:
+            return None
+        return response.json()

codeberg_cli/config.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+import tomlkit
+from platformdirs import user_config_path
+
+
+def get_config_path() -> Path:
+    """Return the config directory for codeberg-cli."""
+    return user_config_path("codeberg-cli", ensure_exists=False)
+
+
+def config_file_path() -> Path:
+    """Return the path to the config file."""
+    return get_config_path() / "config.toml"
+
+
+def load_config() -> dict:
+    """Load config from ~/.config/codeberg-cli/config.toml. Returns {} if missing."""
+    path = config_file_path()
+    if not path.exists():
+        return {}
+    return dict(tomlkit.parse(path.read_text()))
+
+
+def save_config(data: dict) -> None:
+    """Save config to ~/.config/codeberg-cli/config.toml."""
+    path = config_file_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(tomlkit.dumps(data))

codeberg_cli/git.py

@@ -0,0 +1,49 @@
+import re
+import subprocess
+from pathlib import Path
+
+
+def parse_repo_from_remote(remote_url: str) -> str:
+    """Extract owner/repo from a git remote URL."""
+    # HTTPS: https://codeberg.org/owner/repo.git
+    # SSH: git@codeberg.org:owner/repo.git
+    m = re.search(r"codeberg\.org[:/](.+?)(?:\.git)?/?$", remote_url)
+    if m:
+        return m.group(1)
+    raise ValueError(f"Could not parse repo from remote: {remote_url}")
+
+
+def get_default_branch(cwd: Path) -> str:
+    """Get the default branch name for a repo."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True, text=True, check=True, cwd=cwd,
+        )
+        return result.stdout.strip()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return "main"
+
+
+def get_repo_remote(cwd: Path | None = None) -> str | None:
+    """Get the 'origin' remote URL from a git repo, or None."""
+    try:
+        result = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            capture_output=True, text=True, check=True,
+            cwd=cwd or Path.cwd(),
+        )
+        return result.stdout.strip()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+
+def infer_repo(cwd: Path | None = None) -> str | None:
+    """Infer owner/repo from git remote origin."""
+    remote = get_repo_remote(cwd)
+    if remote is None:
+        return None
+    try:
+        return parse_repo_from_remote(remote)
+    except ValueError:
+        return None

codeberg_cli/helpers.py

@@ -0,0 +1,20 @@
+from codeberg_cli.client import Client, ClientError
+from codeberg_cli.config import load_config
+
+
+def get_authenticated_client() -> Client | None:
+    """Return a Client if token is stored, else None."""
+    config = load_config()
+    token = config.get("token")
+    if not token:
+        return None
+    return Client(token=token)
+
+
+def require_client() -> Client:
+    """Return an authenticated Client or print error and exit."""
+    client = get_authenticated_client()
+    if client is None:
+        from xclif.errors import UsageError
+        raise UsageError("Not logged in. Run 'cb auth login' first.")
+    return client

codeberg_cli/routes/__init__.py

@@ -0,0 +1,6 @@
+from xclif import command
+
+
+@command("cb")
+def _() -> None:
+    """A Codeberg CLI."""

codeberg_cli/routes/api.py

@@ -0,0 +1,23 @@
+import json
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.helpers import require_client
+from xclif import Arg, Option, command
+
+
+@command("api")
+def _(
+    method: Annotated[str, Arg(description="HTTP method (GET, POST, PATCH, DELETE)")],
+    path: Annotated[str, Arg(description="API path (e.g. /repos/owner/repo)")],
+    data: Annotated[str, Option(description="JSON body for POST/PATCH", name="data")] = "",
+) -> None:
+    """Make an authenticated API request to Codeberg."""
+    client = require_client()
+    kwargs = {}
+    if data:
+        kwargs["json"] = json.loads(data)
+    result = client._request(method.upper(), path, **kwargs)
+    if result is not None:
+        rich.print_json(data=result)

codeberg_cli/routes/auth/__init__.py

@@ -0,0 +1 @@
+# Namespace package for auth subcommands

codeberg_cli/routes/auth/login.py

@@ -0,0 +1,23 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.client import Client
+from codeberg_cli.config import save_config
+from xclif import Option, command
+
+
+@command("login")
+def _(
+    token: Annotated[str, Option(description="Codeberg access token", name="token")] = "",
+) -> None:
+    """Authenticate with Codeberg using a personal access token."""
+    if not token:
+        token = input("Enter your Codeberg access token: ").strip()
+
+    client = Client(token=token)
+    user = client.get("/user", action="Verifying token")
+    save_config({"token": token})
+    rich.print(f"[bold green]Logged in as[/bold green] [bold]{user['login']}[/bold]")
+
+

codeberg_cli/routes/auth/logout.py

@@ -0,0 +1,17 @@
+import rich
+
+from codeberg_cli.config import config_file_path
+from xclif import command
+
+
+@command("logout")
+def _() -> None:
+    """Remove stored Codeberg credentials."""
+    path = config_file_path()
+    if path.exists():
+        path.unlink()
+        rich.print("[dim]Logged out.[/dim]")
+    else:
+        rich.print("[dim]Not logged in.[/dim]")
+
+

codeberg_cli/routes/auth/status.py

@@ -0,0 +1,21 @@
+import rich
+
+from codeberg_cli.helpers import get_authenticated_client
+from xclif import command
+
+
+@command("status")
+def _() -> None:
+    """Show authentication status."""
+    client = get_authenticated_client()
+    if client is None:
+        rich.print("[yellow]Not logged in[/yellow]")
+        rich.print("Run [bold]cb auth login[/bold] to authenticate.")
+        return
+
+    user = client.get("/user", action="Checking authentication")
+    rich.print(f"Logged in to [cyan]Codeberg[/cyan] as [bold]{user['login']}[/bold]")
+    rich.print(f"  User ID: {user['id']}")
+    rich.print(f"  Full Name: {user.get('full_name', '(not set)')}")
+
+

codeberg_cli/routes/auth/whoami.py

@@ -0,0 +1,14 @@
+import rich
+
+from codeberg_cli.helpers import require_client
+from xclif import command
+
+
+@command("whoami")
+def _() -> None:
+    """Print the current authenticated user's username."""
+    client = require_client()
+    user = client.get("/user")
+    print(user["login"])
+
+

codeberg_cli/routes/issue/__init__.py

@@ -0,0 +1 @@
+# Namespace package for issue subcommands

codeberg_cli/routes/issue/close.py

@@ -0,0 +1,28 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Arg, Option, command
+
+
+@command("close")
+def _(
+    id: Annotated[int, Arg(description="Issue number")],
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Close an issue."""
+    client = require_client()
+
+    if not repo:
+        inferred = infer_repo()
+        if not inferred:
+            rich.print("[bold red]Error:[/bold red] No repo specified and not in a git directory")
+            return 1
+        repo = inferred
+
+    client.patch(f"/repos/{repo}/issues/{id}", data={"state": "closed"})
+    rich.print(f"[bold green]Closed[/bold green] #{id} in {repo}")
+
+

codeberg_cli/routes/issue/create.py

@@ -0,0 +1,55 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Option, command
+
+
+@command("create")
+def _(
+    title: Annotated[str, Option(description="Issue title", name="title")] = "",
+    body: Annotated[str, Option(description="Issue body", name="body")] = "",
+    labels: Annotated[str, Option(description="Comma-separated label names", name="labels")] = "",
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Create an issue."""
+    client = require_client()
+
+    if not repo:
+        inferred = infer_repo()
+        if not inferred:
+            rich.print("[bold red]Error:[/bold red] No repo specified and not in a git directory")
+            return 1
+        repo = inferred
+
+    if not title:
+        title = input("Title: ").strip()
+        if not title:
+            rich.print("[bold red]Error:[/bold red] Title is required")
+            return 1
+
+    if not body:
+        rich.print("[dim]Enter body (Ctrl+D to finish, or leave empty):[/dim]")
+        try:
+            lines = []
+            while True:
+                line = input()
+                lines.append(line)
+        except (EOFError, KeyboardInterrupt):
+            pass
+        body = "\n".join(lines).strip()
+
+    data = {"title": title}
+    if body:
+        data["body"] = body
+    if labels:
+        data["labels"] = [l.strip() for l in labels.split(",")]
+
+    result = client.post(f"/repos/{repo}/issues", data=data)
+
+    rich.print(f"[bold green]Created issue[/bold green] #{result['number']}: {result['title']}")
+    rich.print(f"[dim]https://codeberg.org/{repo}/issues/{result['number']}[/dim]")
+
+

codeberg_cli/routes/issue/list.py

@@ -0,0 +1,49 @@
+from typing import Annotated
+
+import rich
+from rich.table import Table
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Option, command
+
+
+@command("list", "ls")
+def _(
+    state: Annotated[str, Option(description="Filter by state: open, closed", name="state")] = "open",
+    label: Annotated[str, Option(description="Filter by label", name="label")] = "",
+    limit: Annotated[int, Option(description="Maximum issues to show", name="limit")] = 30,
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """List issues."""
+    client = require_client()
+
+    if not repo:
+        inferred = infer_repo()
+        if not inferred:
+            rich.print("[bold red]Error:[/bold red] No repo specified and not in a git directory")
+            return 1
+        repo = inferred
+
+    params = {"state": state, "limit": limit, "page": 1, "type": "issues"}
+    if label:
+        params["labels"] = label
+
+    issues = client.get(f"/repos/{repo}/issues", params=params)
+
+    if not issues:
+        rich.print(f"[dim]No {state} issues in {repo}.[/dim]")
+        return
+
+    table = Table("#", "Title", "Author", "Labels")
+    for issue in issues:
+        labels_str = ", ".join(l["name"] for l in (issue.get("labels") or []))
+        table.add_row(
+            str(issue["number"]),
+            issue["title"],
+            issue["user"]["login"],
+            labels_str,
+        )
+    rich.print(table)
+
+

codeberg_cli/routes/issue/reopen.py

@@ -0,0 +1,28 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Arg, Option, command
+
+
+@command("reopen")
+def _(
+    id: Annotated[int, Arg(description="Issue number")],
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Reopen a closed issue."""
+    client = require_client()
+
+    if not repo:
+        inferred = infer_repo()
+        if not inferred:
+            rich.print("[bold red]Error:[/bold red] No repo specified and not in a git directory")
+            return 1
+        repo = inferred
+
+    client.patch(f"/repos/{repo}/issues/{id}", data={"state": "open"})
+    rich.print(f"[bold green]Reopened[/bold green] #{id} in {repo}")
+
+

codeberg_cli/routes/issue/view.py

@@ -0,0 +1,46 @@
+import webbrowser
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Arg, Option, command
+
+
+@command("view")
+def _(
+    id: Annotated[int, Arg(description="Issue number")],
+    web: Annotated[bool, Option(description="Open in browser", name="web")] = False,
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """View an issue."""
+    client = require_client()
+
+    if not repo:
+        inferred = infer_repo()
+        if not inferred:
+            rich.print("[bold red]Error:[/bold red] No repo specified and not in a git directory")
+            return 1
+        repo = inferred
+
+    if web:
+        webbrowser.open(f"https://codeberg.org/{repo}/issues/{id}")
+        return
+
+    issue = client.get(f"/repos/{repo}/issues/{id}")
+    comments = client.get(f"/repos/{repo}/issues/{id}/comments")
+
+    state_color = "green" if issue["state"] == "open" else "red"
+    rich.print(f"[bold]#{issue['number']}[/bold] [bold]{issue['title']}[/bold]")
+    rich.print(f"[{state_color}]{issue['state']}[/{state_color}] [dim]by {issue['user']['login']}[/dim]")
+    if issue.get("body"):
+        rich.print()
+        rich.print(issue["body"])
+    if comments:
+        rich.print()
+        rich.print(f"[bold]{len(comments)} comments[/bold]")
+        for comment in comments:
+            rich.print(f"  [dim]{comment['user']['login']}:[/dim] {comment.get('body', '')[:100]}")
+
+

codeberg_cli/routes/label/__init__.py

@@ -0,0 +1 @@
+# Namespace package for label subcommands

codeberg_cli/routes/label/create.py

@@ -0,0 +1,35 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Arg, Option, command
+
+
+@command("create")
+def _(
+    name: Annotated[str, Arg(description="Label name")],
+    color: Annotated[str, Option(description="Label color (hex, e.g. ff0000)")] = "",
+    description: Annotated[str, Option(description="Label description", name="description")] = "",
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Create a label."""
+    client = require_client()
+
+    if not repo:
+        inferred = infer_repo()
+        if not inferred:
+            rich.print("[bold red]Error:[/bold red] No repo specified and not in a git directory")
+            return 1
+        repo = inferred
+
+    data: dict = {"name": name}
+    if color:
+        data["color"] = color.lstrip("#")
+    if description:
+        data["description"] = description
+
+    label = client.post(f"/repos/{repo}/labels", data=data)
+
+    rich.print(f"[bold green]Created label[/bold green] {label['name']} (#{label['color']})")

codeberg_cli/routes/label/delete.py

@@ -0,0 +1,26 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Arg, Option, command
+
+
+@command("delete")
+def _(
+    label_id: Annotated[int, Arg(description="Label ID")],
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Delete a label."""
+    client = require_client()
+
+    if not repo:
+        inferred = infer_repo()
+        if not inferred:
+            rich.print("[bold red]Error:[/bold red] No repo specified and not in a git directory")
+            return 1
+        repo = inferred
+
+    client.delete(f"/repos/{repo}/labels/{label_id}")
+    rich.print(f"[bold green]Deleted label[/bold green] #{label_id}")

codeberg_cli/routes/label/list.py

@@ -0,0 +1,41 @@
+from typing import Annotated
+
+import rich
+from rich.table import Table
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Option, command
+
+
+@command("list", "ls")
+def _(
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+    limit: Annotated[int, Option(description="Maximum labels to show", name="limit")] = 30,
+) -> None:
+    """List labels for a repository."""
+    client = require_client()
+
+    if not repo:
+        inferred = infer_repo()
+        if not inferred:
+            rich.print("[bold red]Error:[/bold red] No repo specified and not in a git directory")
+            return 1
+        repo = inferred
+
+    labels = client.get(f"/repos/{repo}/labels", params={"limit": limit})
+
+    if not labels:
+        rich.print(f"[dim]No labels in {repo}.[/dim]")
+        return
+
+    table = Table("#", "Name", "Color", "Description")
+    for label in labels:
+        color = label.get("color", "ffffff")
+        table.add_row(
+            str(label["id"]),
+            f"[bold #{color} on #{color}]  [/bold #{color} on #{color}] {label['name']}",
+            f"#{color}",
+            label.get("description", "") or "",
+        )
+    rich.print(table)

codeberg_cli/routes/milestone/__init__.py

@@ -0,0 +1 @@
+# Namespace package for milestone subcommands

codeberg_cli/routes/milestone/create.py

@@ -0,0 +1,35 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Arg, Option, command
+
+
+@command("create")
+def _(
+    title: Annotated[str, Arg(description="Milestone title")],
+    description: Annotated[str, Option(description="Milestone description")] = "",
+    due_on: Annotated[str, Option(description="Due date (YYYY-MM-DD)")] = "",
+    repo: Annotated[str, Option(description="Repository (owner/repo)")] = "",
+) -> None:
+    """Create a milestone."""
+    client = require_client()
+
+    if not repo:
+        inferred = infer_repo()
+        if not inferred:
+            rich.print("[bold red]Error:[/bold red] No repo specified and not in a git directory")
+            return 1
+        repo = inferred
+
+    data: dict = {"title": title}
+    if description:
+        data["description"] = description
+    if due_on:
+        data["due_on"] = due_on
+
+    ms = client.post(f"/repos/{repo}/milestones", data=data)
+
+    rich.print(f"[bold green]Created milestone[/bold green] #{ms['id']}: {ms['title']}")