codeberg-cli 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

codeberg_cli/__main__.py

@@ -2,7 +2,7 @@ from xclif import Cli
 
 from . import routes
 
-cli = Cli.from_routes(routes)
+cli = Cli.from_routes(routes, config_name="codeberg-cli")
 
 if __name__ == "__main__":
     cli()

codeberg_cli/client.py

@@ -2,11 +2,12 @@ import httpx
 from rich.status import Status
 from xclif.context import get_context
 
-BASE_URL = "https://codeberg.org/api/v1"
+DEFAULT_BASE_URL = "https://codeberg.org"
 
 _VERBS = {
     "GET": "Fetching",
     "POST": "Creating",
+    "PUT": "Updating",
     "PATCH": "Updating",
     "DELETE": "Deleting",
 }
@@ -19,7 +20,7 @@ class ClientError(RuntimeError):
 class Client:
     """HTTP client for the Codeberg API."""
 
-    def __init__(self, token: str | None = None) -> None:
+    def __init__(self, token: str | None = None, base_url: str | None = None) -> None:
         headers = {
             "Accept": "application/json",
             "User-Agent": "codeberg-cli/0.1.0",
@@ -27,7 +28,18 @@ class Client:
         }
         if token:
             headers["Authorization"] = f"Bearer {token}"
-        self._client = httpx.Client(base_url=BASE_URL, headers=headers, timeout=30.0)
+        raw = base_url or DEFAULT_BASE_URL
+        if "://" not in raw:
+            raw = "https://" + raw
+        raw = raw.rstrip("/")
+        if not raw.endswith("/api/v1"):
+            raw += "/api/v1"
+        self._client = httpx.Client(base_url=raw, headers=headers, timeout=30.0)
+
+    @property
+    def base_url(self) -> str:
+        """The API base URL used by this client."""
+        return str(self._client.base_url)
 
     def get(
         self, path: str, params: dict | None = None, action: str | None = None
@@ -44,16 +56,25 @@ class Client:
     ) -> dict | list:
         return self._request("PATCH", path, json=data, action=action)
 
+    def put(
+        self, path: str, data: dict | None = None, action: str | None = None
+    ) -> dict | list:
+        return self._request("PUT", 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()
+        try:
+            ctx = get_context()
+            verbosity = ctx.verbosity
+        except RuntimeError:
+            verbosity = 0
         label = action or (
             f"{method} {path}"
-            if ctx.verbosity >= 2
+            if verbosity >= 2
             else f"{_VERBS.get(method, method)} {path.split('/')[-1]}"
         )
         with Status(f"{label}..."):

codeberg_cli/git.py

@@ -1,16 +1,27 @@
-import re
 import subprocess
 from pathlib import Path
+from urllib.parse import urlparse
 
 
 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}")
+    # HTTPS: https://hostname/owner/repo.git
+    parsed = urlparse(remote_url)
+    if parsed.scheme in ("http", "https"):
+        path = parsed.path
+    elif "@" in remote_url:
+        # SSH: git@hostname:owner/repo.git
+        path = remote_url.split(":", 1)[1]
+    else:
+        raise ValueError(f"Could not parse repo from remote: {remote_url}")
+
+    path = path.rstrip("/")
+    if path.endswith(".git"):
+        path = path[:-4]
+    owner_repo = path.removeprefix("/")
+    if "/" not in owner_repo:
+        raise ValueError(f"Could not parse repo from remote: {remote_url}")
+    return owner_repo
 
 
 def get_default_branch(cwd: Path) -> str:

codeberg_cli/helpers.py

@@ -1,20 +1,120 @@
-from codeberg_cli.client import Client, ClientError
+from __future__ import annotations
+
+import json as _json
+import sys
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+import rich
+
+from codeberg_cli.client import Client, ClientError, DEFAULT_BASE_URL
 from codeberg_cli.config import load_config
 
 
-def get_authenticated_client() -> Client | None:
+def is_json_mode() -> bool:
+    """Check whether ``--json`` was passed on the CLI."""
+    return "--json" in sys.argv[1:]
+
+
+def output(
+    data: Any,
+    *,
+    json: bool | None = None,
+    default: str | None = None,
+) -> None:
+    """Print *data* as JSON or fall back to *default* text.
+
+    When ``json=True`` (or global ``--json`` was passed), data is printed as
+    prettified JSON.  When ``json=False`` the *default* string (if given) is
+    printed.  When *default* is ``None`` and JSON mode is off, this is a no-op
+    — the caller is expected to handle rich printing themselves.
+    """
+    if json is None:
+        json = is_json_mode()
+    if json:
+        _json.dump(
+            data,
+            sys.stdout,
+            indent=2,
+            default=str,
+        )
+        sys.stdout.write("\n")
+    elif default is not None:
+        rich.print(default)
+
+
+def print_table(
+    columns: list[str],
+    rows: Iterable[Iterable[str]],
+    *,
+    json: bool | None = None,
+    json_data: Any = None,
+    title: str | None = None,
+) -> None:
+    """Print a table, or JSON when ``--json`` is active.
+
+    When JSON mode is on, *json_data* is printed as JSON (or *rows* converted
+    to a list if no explicit json_data is given).  When not in JSON mode, a
+    rich ``Table`` is printed.
+    """
+    if json is None:
+        json = is_json_mode()
+    if json:
+        _json.dump(
+            json_data if json_data is not None else list(rows),
+            sys.stdout,
+            indent=2,
+            default=str,
+        )
+        sys.stdout.write("\n")
+        return
+
+    from rich.table import Table
+
+    table = Table(*columns, title=title)
+    for row in rows:
+        table.add_row(*row)
+    rich.print(table)
+
+
+def get_base_url() -> str:
+    """Get the web base URL from cascading CLI context or default."""
+    from xclif.context import get_context
+
+    try:
+        ctx = get_context()
+        raw = ctx.get("base_url", DEFAULT_BASE_URL)
+    except RuntimeError:
+        raw = DEFAULT_BASE_URL
+
+    # Normalize: ensure scheme, strip API path suffix for backward compat
+    if "://" not in raw:
+        raw = "https://" + raw
+    raw = raw.rstrip("/")
+    if raw.endswith("/api/v1"):
+        raw = raw[:-7]
+    return raw
+
+
+def get_web_base_url() -> str:
+    """Derive the web UI base URL from the API base URL."""
+    return get_base_url()
+
+
+def get_authenticated_client(base_url: str | None = None) -> 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)
+    return Client(token=token, base_url=base_url or get_base_url())
 
 
-def require_client() -> Client:
+def require_client(base_url: str | None = None) -> Client:
     """Return an authenticated Client or print error and exit."""
-    client = get_authenticated_client()
+    client = get_authenticated_client(base_url=base_url)
     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

@@ -1,6 +1,13 @@
-from xclif import command
+from codeberg_cli.client import DEFAULT_BASE_URL
+from xclif import Cascade, WithConfig, command
 
 
 @command("cb")
-def _() -> None:
-    """A Codeberg CLI."""
+def _(
+    base_url: Cascade[WithConfig[str]] = DEFAULT_BASE_URL,
+    json: bool = False,
+) -> None:
+    """Interact with Codeberg or any Forgejo instance — manage repos, issues, PRs, releases, actions, and more.
+
+    Use --json on any command for machine-readable output.
+    """

codeberg_cli/routes/actions/__init__.py

@@ -0,0 +1,6 @@
+from xclif import command
+
+
+@command("actions")
+def _() -> None:
+    """Manage Forgejo Actions — view runs, list workflows, and dispatch workflows."""

codeberg_cli/routes/actions/dispatch.py

@@ -0,0 +1,31 @@
+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("dispatch")
+def _(
+    workflow: Annotated[str, Arg(description="Workflow filename (e.g. ci.yml)")],
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+    ref: Annotated[str, Option(description="Branch or tag to dispatch on", name="ref")] = "main",
+) -> None:
+    """Dispatch a workflow (trigger a workflow_dispatch event)."""
+    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.post(
+        f"/repos/{repo}/actions/workflows/{workflow}/dispatches",
+        data={"ref": ref},
+        action="Dispatching workflow",
+    )
+    rich.print(f"[green]Dispatched {workflow} on {ref} in {repo}.[/green]")

codeberg_cli/routes/actions/run.py

@@ -0,0 +1,40 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import is_json_mode, output, require_client
+from xclif import Arg, Option, command
+
+
+@command("run")
+def _(
+    run_id: Annotated[int, Arg(description="Run ID")],
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """View details of a specific action run."""
+    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
+
+    run = client.get(f"/repos/{repo}/actions/runs/{run_id}")
+
+    if is_json_mode():
+        output(run)
+        return
+
+    rich.print(f"[bold]Run #{run['id']}:[/bold] {run['display_title']}")
+    rich.print(f"  Status:      {run.get('status', '?')}")
+    rich.print(f"  Conclusion:  {run.get('conclusion', 'N/A')}")
+    rich.print(f"  Event:       {run.get('event', '?')}")
+    rich.print(f"  Branch:      {run.get('head_branch', '?')}")
+    rich.print(f"  Commit:      {run.get('head_sha', '?')[:12]}")
+    rich.print(f"  Created:     {run.get('created_at', '?')}")
+    rich.print(f"  Updated:     {run.get('updated_at', '?')}")
+    if run.get("url"):
+        rich.print(f"  URL:         {run['url']}")

codeberg_cli/routes/actions/runs.py

@@ -0,0 +1,52 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import print_table, require_client
+from xclif import Option, command
+
+
+@command("runs")
+def _(
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+    limit: Annotated[int, Option(description="Maximum runs to show", name="limit")] = 20,
+) -> None:
+    """List action runs 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
+
+    runs = client.get(f"/repos/{repo}/actions/runs", params={"limit": limit, "page": 1})
+
+    if not runs:
+        rich.print(f"[dim]No action runs in {repo}.[/dim]")
+        return
+
+    rows = []
+    json_rows = []
+    for run in runs:
+        status = run.get("status", "?")
+        conclusion = run.get("conclusion", "")
+        label = f"{status}" if not conclusion else f"{conclusion}"
+        rows.append((str(run["id"]), run["display_title"][:72], label, run["event"]))
+        json_rows.append({
+            "id": run["id"],
+            "title": run["display_title"],
+            "status": status,
+            "conclusion": conclusion,
+            "event": run["event"],
+            "created_at": run.get("created_at", ""),
+            "head_branch": run.get("head_branch", ""),
+        })
+
+    print_table(
+        ["ID", "Title", "Status", "Event"],
+        rows,
+        json_data=json_rows,
+    )

codeberg_cli/routes/actions/workflows.py

@@ -0,0 +1,46 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import print_table, require_client
+from xclif import Option, command
+
+
+@command("workflows")
+def _(
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """List workflows 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
+
+    workflows = client.get(f"/repos/{repo}/actions/workflows")
+
+    if not workflows:
+        rich.print(f"[dim]No workflows in {repo}.[/dim]")
+        return
+
+    rows = []
+    json_rows = []
+    for wf in workflows:
+        state = wf.get("state", "?")
+        rows.append((str(wf["id"]), wf["name"], wf.get("filename", ""), state))
+        json_rows.append({
+            "id": wf["id"],
+            "name": wf["name"],
+            "filename": wf.get("filename", ""),
+            "state": state,
+        })
+
+    print_table(
+        ["ID", "Name", "Filename", "State"],
+        rows,
+        json_data=json_rows,
+    )

codeberg_cli/routes/auth/__init__.py

@@ -1 +1,6 @@
-# Namespace package for auth subcommands
+from xclif import command
+
+
+@command("auth")
+def _() -> None:
+    """Manage authentication — login, logout, check status, and whoami."""

codeberg_cli/routes/auth/login.py

@@ -19,5 +19,3 @@ def _(
     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/status.py

@@ -17,5 +17,3 @@ def _() -> None:
     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

@@ -10,5 +10,3 @@ def _() -> None:
     client = require_client()
     user = client.get("/user")
     print(user["login"])
-
-

codeberg_cli/routes/issue/__init__.py

@@ -1 +1,6 @@
-# Namespace package for issue subcommands
+from xclif import command
+
+
+@command("issue")
+def _() -> None:
+    """Manage issues — create, view, close, and more."""

codeberg_cli/routes/issue/comment.py

@@ -0,0 +1,41 @@
+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("comment")
+def _(
+    id: Annotated[int, Arg(description="Issue number")],
+    message: Annotated[str, Option(description="Comment text", name="message")] = "",
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Comment on 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 message:
+        rich.print("[dim]Enter comment (Ctrl+D to finish):[/dim]")
+        try:
+            lines = []
+            while True:
+                line = input()
+                lines.append(line)
+        except (EOFError, KeyboardInterrupt):
+            pass
+        message = "\n".join(lines).strip()
+        if not message:
+            rich.print("[bold red]Error:[/bold red] Comment cannot be empty")
+            return 1
+
+    client.post(f"/repos/{repo}/issues/{id}/comments", data={"body": message})
+    rich.print(f"[bold green]Commented[/bold green] on issue #{id} in {repo}")

codeberg_cli/routes/issue/create.py

@@ -3,7 +3,7 @@ from typing import Annotated
 import rich
 
 from codeberg_cli.git import infer_repo
-from codeberg_cli.helpers import require_client
+from codeberg_cli.helpers import get_web_base_url, require_client
 from xclif import Option, command
 
 
@@ -50,6 +50,6 @@ def _(
     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]")
+    rich.print(f"[dim]{get_web_base_url()}/{repo}/issues/{result['number']}[/dim]")
 
 

codeberg_cli/routes/issue/delete.py

@@ -0,0 +1,31 @@
+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 _(
+    id: Annotated[int, Arg(description="Issue number")],
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Delete 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
+
+    confirm = input(f"Are you sure you want to delete issue #{id} in {repo}? [y/N] ").strip().lower()
+    if confirm != "y":
+        rich.print("[dim]Cancelled.[/dim]")
+        return
+
+    client.delete(f"/repos/{repo}/issues/{id}")
+    rich.print(f"[bold green]Deleted[/bold green] issue #{id} in {repo}")

codeberg_cli/routes/issue/edit.py

@@ -0,0 +1,38 @@
+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("edit")
+def _(
+    id: Annotated[int, Arg(description="Issue number")],
+    title: Annotated[str, Option(description="New title", name="title")] = "",
+    body: Annotated[str, Option(description="New body", name="body")] = "",
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Edit an issue's title or body."""
+    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 = {}
+    if title:
+        data["title"] = title
+    if body:
+        data["body"] = body
+
+    if not data:
+        rich.print("[bold yellow]Nothing to update.[/bold yellow] Pass --title and/or --body.")
+        return 1
+
+    client.patch(f"/repos/{repo}/issues/{id}", data=data)
+    rich.print(f"[bold green]Updated[/bold green] issue #{id} in {repo}")

codeberg_cli/routes/issue/labels/__init__.py

@@ -0,0 +1,6 @@
+from xclif import command
+
+
+@command("labels")
+def _() -> None:
+    """Manage issue labels — list, add, and remove."""

codeberg_cli/routes/issue/labels/add.py

@@ -0,0 +1,27 @@
+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("add")
+def _(
+    id: Annotated[int, Arg(description="Issue number")],
+    label: Annotated[str, Arg(description="Label name")],
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Add a label to 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.post(f"/repos/{repo}/issues/{id}/labels", data={"labels": [label]})
+    rich.print(f"[bold green]Added label[/bold green] \"{label}\" to issue #{id} in {repo}")