codeberg-cli 0.1.0__py3-none-any.whl

codeberg_cli/routes/milestone/list.py

@@ -0,0 +1,46 @@
+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",
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+    limit: Annotated[int, Option(description="Maximum milestones to show", name="limit")] = 30,
+) -> None:
+    """List milestones."""
+    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
+
+    milestones = client.get(f"/repos/{repo}/milestones", params={"state": state, "limit": limit})
+
+    if not milestones:
+        rich.print(f"[dim]No {state} milestones in {repo}.[/dim]")
+        return
+
+    table = Table("#", "Title", "State", "Open / Closed", "Due Date")
+    for ms in milestones:
+        state_color = "green" if ms["state"] == "open" else "red"
+        due = ms.get("due_on", "") or ""
+        if due:
+            due = due[:10]
+        table.add_row(
+            str(ms["id"]),
+            ms["title"],
+            f"[{state_color}]{ms['state']}[/{state_color}]",
+            f"{ms.get('open_issues', 0)} / {ms.get('closed_issues', 0)}",
+            due,
+        )
+    rich.print(table)

codeberg_cli/routes/pr/__init__.py

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

codeberg_cli/routes/pr/checkout.py

@@ -0,0 +1,42 @@
+import subprocess
+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("checkout", "co")
+def _(
+    id: Annotated[int, Arg(description="PR number")],
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Checkout a pull request locally."""
+    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
+
+    pr = client.get(f"/repos/{repo}/pulls/{id}")
+    branch = pr["head"]["ref"]
+    repo_url = pr["head"]["repo"]["clone_url"]
+
+    rich.print(f"Fetching PR #{id} ({branch})...")
+    subprocess.run(
+        ["git", "fetch", repo_url, branch],
+        check=True,
+    )
+    result = subprocess.run(
+        ["git", "checkout", branch],
+    )
+    if result.returncode != 0:
+        subprocess.run(["git", "checkout", "-b", branch, "FETCH_HEAD"], check=True)
+    rich.print(f"[bold green]Checked out[/bold green] PR #{id} as [bold]{branch}[/bold]")
+
+

codeberg_cli/routes/pr/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="PR number")],
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Close a pull request without merging."""
+    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}/pulls/{id}", data={"state": "closed"})
+    rich.print(f"[bold green]Closed[/bold green] PR #{id} in {repo}")
+
+

codeberg_cli/routes/pr/create.py

@@ -0,0 +1,68 @@
+import subprocess
+from pathlib import Path
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.git import get_default_branch, infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Option, command
+
+
+@command("create")
+def _(
+    title: Annotated[str, Option(description="PR title", name="title")] = "",
+    body: Annotated[str, Option(description="PR body", name="body")] = "",
+    base: Annotated[str, Option(description="Base branch", name="base")] = "",
+    head: Annotated[str, Option(description="Head branch (default: current branch)", name="head")] = "",
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Create a pull request."""
+    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 base:
+        base = get_default_branch(Path.cwd())
+
+    if not head:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True, text=True,
+        )
+        head = result.stdout.strip()
+
+    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,
+        "body": body,
+        "base": base,
+        "head": head,
+    }
+
+    result = client.post(f"/repos/{repo}/pulls", data=data)
+    rich.print(f"[bold green]Created PR[/bold green] #{result['number']}: {result['title']}")
+    rich.print(f"[dim]https://codeberg.org/{repo}/pulls/{result['number']}[/dim]")
+
+

codeberg_cli/routes/pr/list.py

@@ -0,0 +1,43 @@
+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",
+    limit: Annotated[int, Option(description="Maximum PRs to show", name="limit")] = 30,
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """List pull requests."""
+    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
+
+    pulls = client.get(f"/repos/{repo}/pulls", params={"state": state, "limit": limit, "page": 1})
+
+    if not pulls:
+        rich.print(f"[dim]No {state} PRs in {repo}.[/dim]")
+        return
+
+    table = Table("#", "Title", "Author", "Base \u2192 Head")
+    for pr in pulls:
+        table.add_row(
+            str(pr["number"]),
+            pr["title"],
+            pr["user"]["login"],
+            f"{pr['base']['ref']} \u2192 {pr['head']['ref']}",
+        )
+    rich.print(table)
+
+

codeberg_cli/routes/pr/merge.py

@@ -0,0 +1,32 @@
+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("merge")
+def _(
+    id: Annotated[int, Arg(description="PR number")],
+    style: Annotated[str, Option(description="Merge style: merge, rebase, squash", name="style")] = "merge",
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Merge a pull request."""
+    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 = {
+        "Do": style,
+    }
+    client.post(f"/repos/{repo}/pulls/{id}/merge", data=data)
+    rich.print(f"[bold green]Merged[/bold green] #{id} in {repo}")
+
+

codeberg_cli/routes/pr/view.py

@@ -0,0 +1,42 @@
+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="PR number")],
+    web: Annotated[bool, Option(description="Open in browser", name="web")] = False,
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """View a pull request."""
+    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}/pulls/{id}")
+        return
+
+    pr = client.get(f"/repos/{repo}/pulls/{id}")
+
+    state_color = "green" if pr["state"] == "open" else "red"
+    merged = "[bold magenta]MERGED[/bold magenta] " if pr.get("merged") else ""
+    rich.print(f"[bold]#{pr['number']}[/bold] [bold]{pr['title']}[/bold]")
+    rich.print(f"{merged}[{state_color}]{pr['state']}[/{state_color}] [dim]by {pr['user']['login']}[/dim]")
+    rich.print(f"  [dim]{pr['base']['ref']}[/dim] \u2190 [dim]{pr['head']['ref']}[/dim]")
+    if pr.get("body"):
+        rich.print()
+        rich.print(pr["body"])
+
+

codeberg_cli/routes/release/__init__.py

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

codeberg_cli/routes/release/create.py

@@ -0,0 +1,40 @@
+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 _(
+    tag: Annotated[str, Arg(description="Git tag for the release")],
+    title: Annotated[str, Option(description="Release title", name="title")] = "",
+    notes: Annotated[str, Option(description="Release notes", name="notes")] = "",
+    prerelease: Annotated[bool, Option(description="Mark as prerelease", name="prerelease")] = False,
+    draft: Annotated[bool, Option(description="Create as draft", name="draft")] = False,
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Create a release."""
+    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 = {
+        "tag_name": tag,
+        "name": title or tag,
+        "body": notes,
+        "prerelease": prerelease,
+        "draft": draft,
+    }
+
+    result = client.post(f"/repos/{repo}/releases", data=data)
+    rich.print(f"[bold green]Created release[/bold green] {result.get('name', tag)}")
+    rich.print(f"[dim]https://codeberg.org/{repo}/releases/tag/{tag}[/dim]")
+

codeberg_cli/routes/release/list.py

@@ -0,0 +1,42 @@
+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 _(
+    limit: Annotated[int, Option(description="Maximum releases to show", name="limit")] = 30,
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """List releases."""
+    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
+
+    releases = client.get(f"/repos/{repo}/releases", params={"limit": limit, "page": 1})
+
+    if not releases:
+        rich.print(f"[dim]No releases in {repo}.[/dim]")
+        return
+
+    table = Table("Tag", "Title", "Type", "Assets")
+    for r in releases:
+        release_type = "[yellow]draft[/yellow]" if r.get("draft") else "[cyan]prerelease[/cyan]" if r.get("prerelease") else "[green]release[/green]"
+        table.add_row(
+            r["tag_name"],
+            r.get("name", ""),
+            release_type,
+            str(len(r.get("assets", []))),
+        )
+    rich.print(table)
+

codeberg_cli/routes/release/upload.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+from typing import Annotated
+
+import httpx
+import rich
+
+from codeberg_cli.git import infer_repo
+from codeberg_cli.helpers import require_client
+from xclif import Arg, Option, command
+
+
+@command("upload")
+def _(
+    id: Annotated[int, Arg(description="Release ID")],
+    file: Annotated[str, Arg(description="File to upload")],
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """Upload a release asset."""
+    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
+
+    file_path = Path(file)
+    if not file_path.exists():
+        rich.print(f"[bold red]Error:[/bold red] File not found: {file}")
+        return 1
+
+    with open(file_path, "rb") as f:
+        content = f.read()
+
+    # Direct multipart upload (bypasses Client for multipart support)
+    token = client._client.headers.get("Authorization", "").replace("Bearer ", "")
+    headers = {"Authorization": f"Bearer {token}"}
+
+    response = httpx.post(
+        f"https://codeberg.org/api/v1/repos/{repo}/releases/{id}/assets",
+        headers=headers,
+        files={"attachment": (file_path.name, content)},
+    )
+    if response.is_success:
+        rich.print(f"[bold green]Uploaded[/bold green] {file_path.name} to release #{id}")
+    else:
+        msg = response.json().get("message", "unknown error") if response.text else "unknown error"
+        rich.print(f"[bold red]Error:[/bold red] {response.status_code} {msg}")
+        return 1
+

codeberg_cli/routes/release/view.py

@@ -0,0 +1,50 @@
+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="Release ID")],
+    web: Annotated[bool, Option(description="Open in browser", name="web")] = False,
+    repo: Annotated[str, Option(description="Repository (owner/repo)", name="repo")] = "",
+) -> None:
+    """View a release."""
+    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
+
+    release = client.get(f"/repos/{repo}/releases/{id}")
+
+    if web:
+        webbrowser.open(release.get("html_url", f"https://codeberg.org/{repo}/releases/tag/{release['tag_name']}"))
+        return
+
+    rich.print(f"[bold]{release.get('name', release['tag_name'])}[/bold]")
+    rich.print(f"  [dim]Tag:[/dim] {release['tag_name']}")
+    rich.print(f"  [dim]Draft:[/dim] {release.get('draft', False)}")
+    rich.print(f"  [dim]Prerelease:[/dim] {release.get('prerelease', False)}")
+
+    if release.get("body"):
+        rich.print()
+        rich.print(release["body"])
+
+    assets = release.get("assets", [])
+    if assets:
+        rich.print()
+        rich.print(f"[bold]{len(assets)} asset(s)[/bold]")
+        for asset in assets:
+            size = asset.get("size", 0)
+            size_str = f"{size / 1024:.1f} KB" if size < 1024 * 1024 else f"{size / 1024 / 1024:.1f} MB"
+            rich.print(f"  [dim]-[/dim] {asset['name']} ({size_str})")
+

codeberg_cli/routes/repo/__init__.py

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

codeberg_cli/routes/repo/clone.py

@@ -0,0 +1,21 @@
+import subprocess
+from typing import Annotated
+
+import rich
+
+from xclif import Arg, command
+
+
+@command("clone")
+def _(
+    repo: Annotated[str, Arg(description="Repository in owner/repo format")],
+) -> None:
+    """Clone a Codeberg repository."""
+    url = f"https://codeberg.org/{repo}.git"
+    rich.print(f"Cloning [cyan]{repo}[/cyan]...")
+    result = subprocess.run(["git", "clone", url])
+    if result.returncode != 0:
+        rich.print(f"[bold red]Error:[/bold red] git clone failed")
+        return 1
+
+

codeberg_cli/routes/repo/create.py

@@ -0,0 +1,77 @@
+from pathlib import Path
+from typing import Annotated
+
+import rich
+from rich.prompt import Confirm, Prompt
+
+from codeberg_cli.git import get_repo_remote
+from codeberg_cli.helpers import require_client
+from xclif import Option, command
+
+
+@command("create")
+def _(
+    name: Annotated[str, Option(description="Repository name")] = "",
+    org: Annotated[str, Option(description="Organization to create repo under")] = "",
+    description: Annotated[str, Option(description="Repository description")] = "",
+    private: Annotated[bool, Option(description="Make repository private")] = False,
+    remote: Annotated[bool, Option(description="Add git remote and push")] = False,
+) -> None:
+    """Create a repository."""
+    client = require_client()
+
+    if not name:
+        name = Prompt.ask("Repository name", default=Path.cwd().name)
+        if not description:
+            description = Prompt.ask("Description", default="")
+        private = not Confirm.ask("Public repository?", default=True)
+        is_git = Path.cwd().joinpath(".git").exists()
+        if is_git and not get_repo_remote(Path.cwd()):
+            remote = Confirm.ask("Add remote and push to Codeberg?", default=True)
+
+    data = {
+        "name": name,
+        "description": description,
+        "private": private,
+        "auto_init": True,
+    }
+
+    if org:
+        result = client.post(f"/orgs/{org}/repos", data=data, action=f"Creating repository in {org}")
+        owner = org
+        repo_url = f"https://codeberg.org/{org}/{name}"
+    else:
+        result = client.post("/user/repos", data=data, action="Creating repository")
+        owner = result["owner"]["login"]
+        repo_url = f"https://codeberg.org/{owner}/{name}"
+
+    rich.print(f"[bold green]Created repository[/bold green] {repo_url}")
+
+    if remote:
+        import subprocess
+
+        cwd = Path.cwd()
+        if not (cwd / ".git").exists():
+            rich.print("[yellow]Not a git repository, skipping remote setup[/yellow]")
+            return
+
+        existing = get_repo_remote(cwd)
+        if existing:
+            rich.print(f"[yellow]Remote 'origin' already exists ({existing}), skipping[/yellow]")
+            return
+
+        try:
+            subprocess.run(
+                ["git", "remote", "add", "origin", f"https://codeberg.org/{owner}/{name}.git"],
+                capture_output=True, text=True, check=True, cwd=cwd,
+            )
+            rich.print("[dim]Added remote 'origin'[/dim]")
+            subprocess.run(
+                ["git", "push", "-u", "origin", "HEAD"],
+                capture_output=True, text=True, cwd=cwd,
+            )
+            rich.print("[dim]Pushed current branch[/dim]")
+        except subprocess.CalledProcessError as e:
+            rich.print(f"[red]Failed to set up remote: {e.stderr.strip()}[/red]")
+
+

codeberg_cli/routes/repo/delete.py

@@ -0,0 +1,27 @@
+from typing import Annotated
+
+import rich
+
+from codeberg_cli.helpers import require_client
+from xclif import Arg, Option, command
+
+
+@command("delete", "rm")
+def _(
+    repo: Annotated[str, Arg(description="Repository to delete")],
+    yes: Annotated[bool, Option(description="Skip confirmation")] = False,
+) -> None:
+    """Delete a repository."""
+    client = require_client()
+
+    if not yes:
+        rich.print(f"[bold red]Warning:[/bold red] This will permanently delete [bold]{repo}[/bold]")
+        confirm = input("Type the repo name to confirm: ").strip()
+        if confirm != repo:
+            rich.print("[dim]Aborted.[/dim]")
+            return
+
+    client.delete(f"/repos/{repo}")
+    rich.print(f"[bold green]Deleted[/bold green] {repo}")
+
+

codeberg_cli/routes/repo/fork.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 Option, Arg, command
+
+
+@command("fork")
+def _(
+    repo: Annotated[str, Option(description="Repository to fork")] = "",
+) -> None:
+    """Fork 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
+
+    result = client.post(f"/repos/{repo}/forks", action=f"Forking {repo}")
+    fork_name = result.get("full_name", f"{result['owner']['login']}/{result['name']}")
+    rich.print(f"[bold green]Forked[/bold green] {repo} -> [bold]{fork_name}[/bold]")
+
+