shiplog-cli 0.1.0__py3-none-any.whl

shiplog/__init__.py

@@ -0,0 +1,3 @@
+"""Shiplog — turn merged GitHub pull requests into customer-facing changelogs."""
+
+__version__ = "0.1.0"

shiplog/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

shiplog/api.py

@@ -0,0 +1,118 @@
+"""Client for the Shiplog generation API (the Cloudflare Worker /api/generate)."""
+
+from __future__ import annotations
+
+import re
+import time
+from dataclasses import dataclass
+
+import requests
+
+VALID_CATEGORIES = ("New", "Improved", "Fixed", "Infrastructure")
+
+# Generation runs on a shared, rate-limited model, so transient 429/502
+# rate-limit responses are expected under concurrency. We retry, honoring the
+# server's suggested wait, rather than dropping the PR from the changelog.
+_MAX_RETRIES = 5
+_MAX_BACKOFF_SECONDS = 30.0
+_RETRY_HINT = re.compile(r"try again in ([\d.]+)\s*(ms|s)", re.IGNORECASE)
+
+
+def _is_rate_limited(status: int, body_text: str) -> bool:
+    return status == 429 or (status == 502 and "rate limit" in body_text.lower())
+
+
+def _retry_after_seconds(resp: requests.Response, attempt: int) -> float:
+    """Wait time before the next retry: Retry-After header, then a parsed
+    'try again in Xs' hint, then exponential backoff."""
+    header = resp.headers.get("Retry-After")
+    if header:
+        try:
+            return min(float(header), _MAX_BACKOFF_SECONDS)
+        except ValueError:
+            pass
+    m = _RETRY_HINT.search(resp.text or "")
+    if m:
+        value = float(m.group(1))
+        if m.group(2).lower() == "ms":
+            value /= 1000.0
+        return min(value + 0.25, _MAX_BACKOFF_SECONDS)  # small cushion
+    return min(2.0 ** attempt, _MAX_BACKOFF_SECONDS)
+
+
+class GenerationError(RuntimeError):
+    pass
+
+
+@dataclass
+class ChangelogEntry:
+    category: str
+    title: str
+    body: str
+
+
+def generate_entry(
+    title: str,
+    body: str,
+    api_base: str,
+    session: requests.Session | None = None,
+    timeout: int = 60,
+    api_key: str | None = None,
+    groq_key: str | None = None,
+    provider: str | None = None,
+) -> ChangelogEntry:
+    """Transform a PR title/body into a customer-facing changelog entry."""
+    if not title.strip():
+        raise GenerationError("PR title is required.")
+
+    sess = session or requests.Session()
+    headers = {}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    resp = None
+    for attempt in range(_MAX_RETRIES + 1):
+        try:
+            payload = {"title": title, "body": body}
+            if groq_key:
+                payload["userKey"] = groq_key
+                if provider:
+                    payload["provider"] = provider
+            resp = sess.post(
+                f"{api_base}/api/generate",
+                json=payload,
+                headers=headers,
+                timeout=timeout,
+            )
+        except requests.RequestException as exc:
+            if attempt < _MAX_RETRIES:
+                time.sleep(min(2.0 ** attempt, _MAX_BACKOFF_SECONDS))
+                continue
+            raise GenerationError(f"Could not reach Shiplog API: {exc}") from exc
+
+        if _is_rate_limited(resp.status_code, resp.text) and attempt < _MAX_RETRIES:
+            time.sleep(_retry_after_seconds(resp, attempt))
+            continue
+        break
+
+    if not resp.ok:
+        detail = ""
+        try:
+            detail = resp.json().get("error", "")
+        except ValueError:
+            detail = resp.text[:200]
+        raise GenerationError(f"API error {resp.status_code}: {detail}")
+
+    try:
+        data = resp.json()
+    except ValueError as exc:
+        raise GenerationError("API returned non-JSON response.") from exc
+
+    category = data.get("category", "New")
+    if category not in VALID_CATEGORIES:
+        category = "New"
+    return ChangelogEntry(
+        category=category,
+        title=data.get("title", "") or title,
+        body=data.get("body", "") or "",
+    )

shiplog/auth.py

@@ -0,0 +1,45 @@
+"""Local storage for the Shiplog API key."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+_CONFIG_DIR = Path(os.environ.get("SHIPLOG_CONFIG_DIR", "~/.config/shiplog")).expanduser()
+_CONFIG_FILE = _CONFIG_DIR / "config.json"
+
+
+def _read_config() -> dict:
+    if not _CONFIG_FILE.exists():
+        return {}
+    try:
+        return json.loads(_CONFIG_FILE.read_text())
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def _write_config(data: dict) -> None:
+    _CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    _CONFIG_FILE.write_text(json.dumps(data, indent=2) + "\n")
+    os.chmod(_CONFIG_FILE, 0o600)
+
+
+def save_api_key(api_key: str) -> Path:
+    cfg = _read_config()
+    cfg["api_key"] = api_key.strip()
+    _write_config(cfg)
+    return _CONFIG_FILE
+
+
+def get_api_key() -> str | None:
+    env = os.environ.get("SHIPLOG_API_KEY")
+    if env:
+        return env.strip()
+    return _read_config().get("api_key")
+
+
+def clear_api_key() -> None:
+    cfg = _read_config()
+    cfg.pop("api_key", None)
+    _write_config(cfg)

shiplog/cli.py

@@ -0,0 +1,333 @@
+"""Shiplog command-line interface."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timedelta, timezone
+
+import requests
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
+
+from . import __version__, config
+from .api import GenerationError, generate_entry
+from .auth import clear_api_key, get_api_key, save_api_key
+from .github import GitHubError, PullRequest, detect_repo, fetch_merged_prs, parse_repo
+from .render import RenderedItem, to_json, to_markdown
+
+console = Console()
+err_console = Console(stderr=True)
+
+_TAG_STYLE = {
+    "New": "bold green",
+    "Improved": "bold cyan",
+    "Fixed": "bold yellow",
+    "Infrastructure": "bold magenta",
+}
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    if not getattr(args, "func", None):
+        parser.print_help()
+        return 1
+    try:
+        return args.func(args)
+    except (GitHubError, GenerationError) as exc:
+        err_console.print(f"[bold red]Error:[/] {exc}")
+        return 1
+    except KeyboardInterrupt:
+        err_console.print("\n[dim]Aborted.[/]")
+        return 130
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="shiplog",
+        description="Turn merged GitHub pull requests into customer-facing changelogs.",
+    )
+    parser.add_argument("--version", action="version", version=f"shiplog {__version__}")
+    parser.add_argument(
+        "--api-base",
+        help="Override the Shiplog generation API base URL.",
+    )
+    parser.add_argument(
+        "--groq-key",
+        help="Use your own Groq API key (free at console.groq.com). "
+        "Bypasses Shiplog usage limits. Also reads GROQ_API_KEY env var.",
+    )
+    parser.add_argument(
+        "--provider",
+        choices=["groq", "openai", "anthropic"],
+        help="LLM provider to use with your own key (auto-detected from key prefix if omitted).",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    # generate
+    g = sub.add_parser(
+        "generate",
+        help="Fetch merged PRs from a repo and build a changelog.",
+    )
+    g.add_argument(
+        "repo",
+        nargs="?",
+        help="Repository as 'owner/name' or a GitHub URL. "
+        "Defaults to the current git repo's origin remote.",
+    )
+    g.add_argument("--token", help="GitHub token (else GITHUB_TOKEN / gh auth token).")
+    g.add_argument("--base", help="Only PRs merged into this base branch (e.g. main).")
+    since = g.add_mutually_exclusive_group()
+    since.add_argument("--since", help="Only PRs merged since this date (YYYY-MM-DD).")
+    since.add_argument(
+        "--days", type=int, help="Only PRs merged in the last N days."
+    )
+    g.add_argument(
+        "--limit", type=int, default=20, help="Max PRs to include (default 20)."
+    )
+    g.add_argument(
+        "--format",
+        choices=["markdown", "json"],
+        default="markdown",
+        help="Output format (default markdown).",
+    )
+    g.add_argument("--output", "-o", help="Write to a file instead of stdout.")
+    g.add_argument("--title", help="Heading for the changelog (markdown only).")
+    g.add_argument(
+        "--no-group",
+        action="store_true",
+        help="List entries chronologically instead of grouping by category.",
+    )
+    g.add_argument(
+        "--no-links", action="store_true", help="Omit PR number links."
+    )
+    g.add_argument(
+        "--include-bots",
+        action="store_true",
+        help="Include bot PRs (dependabot, renovate, …), skipped by default.",
+    )
+    g.add_argument(
+        "--concurrency",
+        type=int,
+        default=8,
+        help="Parallel generation requests (default 8).",
+    )
+    g.set_defaults(func=_cmd_generate)
+
+    # single
+    s = sub.add_parser(
+        "single",
+        help="Transform a single PR title/body (no GitHub needed).",
+    )
+    s.add_argument("title", help="PR title.")
+    s.add_argument("--body", default="", help="Optional PR description.")
+    s.add_argument(
+        "--format",
+        choices=["pretty", "markdown", "json"],
+        default="pretty",
+        help="Output format (default pretty).",
+    )
+    s.set_defaults(func=_cmd_single)
+
+    # login
+    li = sub.add_parser("login", help="Save your Shiplog API key.")
+    li.add_argument("key", nargs="?", help="API key (or paste when prompted).")
+    li.set_defaults(func=_cmd_login)
+
+    # logout
+    lo = sub.add_parser("logout", help="Remove saved API key.")
+    lo.set_defaults(func=_cmd_logout)
+
+    # whoami
+    w = sub.add_parser("whoami", help="Show the currently saved API key.")
+    w.set_defaults(func=_cmd_whoami)
+
+    return parser
+
+
+def _resolve_groq_key(args: argparse.Namespace) -> str | None:
+    import os
+    return getattr(args, 'groq_key', None) or os.environ.get('GROQ_API_KEY') or None
+
+
+def _resolve_provider(args: argparse.Namespace) -> str | None:
+    return getattr(args, 'provider', None) or None
+
+
+def _cmd_login(args: argparse.Namespace) -> int:
+    key = args.key
+    if not key:
+        key = console.input("[bold]Enter your Shiplog API key:[/] ").strip()
+    if not key:
+        err_console.print("[red]No key provided.[/]")
+        return 1
+    path = save_api_key(key)
+    console.print(f"[green]✓[/] API key saved to [dim]{path}[/]")
+    return 0
+
+
+def _cmd_logout(_args: argparse.Namespace) -> int:
+    clear_api_key()
+    console.print("[green]✓[/] API key removed.")
+    return 0
+
+
+def _cmd_whoami(_args: argparse.Namespace) -> int:
+    key = get_api_key()
+    if not key:
+        console.print("[yellow]Not logged in.[/] Run [bold]shiplog login[/] to save your API key.")
+        return 1
+    masked = key[:12] + "…" + key[-4:]
+    console.print(f"[green]Logged in.[/] Key: [dim]{masked}[/]")
+    return 0
+
+
+def _cmd_single(args: argparse.Namespace) -> int:
+    api_base = config.api_base(args.api_base)
+    api_key = get_api_key()
+    groq_key = _resolve_groq_key(args)
+    provider = _resolve_provider(args)
+    with console.status("[dim]Generating changelog entry…[/]"):
+        entry = generate_entry(args.title, args.body, api_base=api_base, api_key=api_key, groq_key=groq_key, provider=provider)
+
+    item = RenderedItem(entry=entry, pr_number=None, pr_url="", merged_at=None)
+    if args.format == "json":
+        console.print_json(to_json([item]))
+    elif args.format == "markdown":
+        console.print(to_markdown([item], group_by_category=False))
+    else:
+        _print_entry(entry)
+    return 0
+
+
+def _cmd_generate(args: argparse.Namespace) -> int:
+    if args.repo:
+        owner, repo = parse_repo(args.repo)
+    else:
+        detected = detect_repo()
+        if not detected:
+            raise GitHubError(
+                "No repo given and couldn't detect one from git. "
+                "Pass 'owner/name' or run inside a GitHub repo."
+            )
+        owner, repo = detected
+        err_console.print(f"[dim]Using detected repo [bold]{owner}/{repo}[/].[/]")
+
+    token = config.resolve_github_token(args.token)
+    api_base = config.api_base(args.api_base)
+
+    since = _resolve_since(args)
+
+    with console.status(f"[dim]Fetching merged PRs from {owner}/{repo}…[/]"):
+        prs = fetch_merged_prs(
+            owner,
+            repo,
+            token=token,
+            since=since,
+            limit=args.limit,
+            base_branch=args.base,
+            include_bots=args.include_bots,
+        )
+
+    if not prs:
+        err_console.print("[yellow]No merged PRs matched your filters.[/]")
+        return 0
+
+    api_key = get_api_key()
+    groq_key = _resolve_groq_key(args)
+    provider = _resolve_provider(args)
+    items = _generate_all(prs, api_base, concurrency=args.concurrency, api_key=api_key, groq_key=groq_key, provider=provider)
+
+    if args.format == "json":
+        output = to_json(items)
+    else:
+        heading = args.title or f"{repo} — Changelog"
+        output = to_markdown(
+            items,
+            heading=heading,
+            group_by_category=not args.no_group,
+            show_pr_links=not args.no_links,
+        )
+
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as fh:
+            fh.write(output if output.endswith("\n") else output + "\n")
+        console.print(
+            f"[green]✓[/] Wrote {len(items)} entr"
+            f"{'y' if len(items) == 1 else 'ies'} to [bold]{args.output}[/]"
+        )
+    else:
+        # Plain print so piping/redirection stays clean.
+        print(output)
+    return 0
+
+
+def _generate_all(
+    prs: list[PullRequest], api_base: str, concurrency: int = 8, api_key: str | None = None, groq_key: str | None = None, provider: str | None = None
+) -> list[RenderedItem]:
+    session = requests.Session()
+    results: list[RenderedItem | None] = [None] * len(prs)
+    failures = 0
+    workers = max(1, min(concurrency, len(prs)))
+
+    def work(idx: int, pr: PullRequest) -> tuple[int, RenderedItem | str]:
+        try:
+            entry = generate_entry(pr.title, pr.body, api_base=api_base, session=session, api_key=api_key, groq_key=groq_key, provider=provider)
+            return idx, RenderedItem(
+                entry=entry,
+                pr_number=pr.number,
+                pr_url=pr.url,
+                merged_at=pr.merged_at,
+            )
+        except GenerationError as exc:
+            return idx, f"#{pr.number}: {exc}"
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("{task.completed}/{task.total}"),
+        console=err_console,
+        transient=True,
+    ) as progress:
+        task = progress.add_task("Transforming PRs…", total=len(prs))
+        with ThreadPoolExecutor(max_workers=workers) as pool:
+            futures = [pool.submit(work, i, pr) for i, pr in enumerate(prs)]
+            for fut in futures:
+                idx, outcome = fut.result()
+                if isinstance(outcome, RenderedItem):
+                    results[idx] = outcome
+                else:
+                    failures += 1
+                    err_console.print(f"[yellow]skip {outcome}[/]")
+                progress.advance(task)
+
+    if failures:
+        err_console.print(f"[yellow]{failures} PR(s) could not be transformed.[/]")
+    # Drop failures, keep original (newest-first) order.
+    return [item for item in results if item is not None]
+
+
+def _resolve_since(args: argparse.Namespace) -> datetime | None:
+    if args.days is not None:
+        return datetime.now(timezone.utc) - timedelta(days=args.days)
+    if args.since:
+        try:
+            return datetime.strptime(args.since, "%Y-%m-%d").replace(tzinfo=timezone.utc)
+        except ValueError:
+            raise GitHubError(f"Invalid --since date {args.since!r}. Use YYYY-MM-DD.")
+    return None
+
+
+def _print_entry(entry) -> None:
+    style = _TAG_STYLE.get(entry.category, "bold white")
+    header = f"[{style}]{entry.category}[/]"
+    body = f"[bold]{entry.title}[/]\n\n{entry.body}"
+    console.print(Panel(body, title=header, border_style=style, expand=False))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

shiplog/config.py

@@ -0,0 +1,47 @@
+"""Configuration and credential resolution for the Shiplog CLI."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+
+# Default Shiplog generation API (the deployed Cloudflare Worker).
+# Override with the SHIPLOG_API_BASE environment variable or --api-base.
+DEFAULT_API_BASE = "https://shiplog-api.siddharthmahajan65.workers.dev"
+
+
+def api_base(override: str | None = None) -> str:
+    return (override or os.environ.get("SHIPLOG_API_BASE") or DEFAULT_API_BASE).rstrip("/")
+
+
+def resolve_github_token(override: str | None = None) -> str | None:
+    """Resolve a GitHub token.
+
+    Order: explicit flag -> $GITHUB_TOKEN -> $GH_TOKEN -> `gh auth token`.
+    Returns None if nothing is available (public repos still work unauthenticated,
+    just with tighter rate limits).
+    """
+    if override:
+        return override
+    for var in ("GITHUB_TOKEN", "GH_TOKEN"):
+        val = os.environ.get(var)
+        if val:
+            return val.strip()
+    return _gh_cli_token()
+
+
+def _gh_cli_token() -> str | None:
+    if not shutil.which("gh"):
+        return None
+    try:
+        out = subprocess.run(
+            ["gh", "auth", "token"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (subprocess.SubprocessError, OSError):
+        return None
+    token = out.stdout.strip()
+    return token or None

shiplog/github.py

@@ -0,0 +1,195 @@
+"""Fetch merged pull requests from the GitHub REST API."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+from dataclasses import dataclass
+from datetime import datetime, timezone
+
+import requests
+
+GITHUB_API = "https://api.github.com"
+_PAGE_SIZE = 100
+
+
+class GitHubError(RuntimeError):
+    pass
+
+
+@dataclass
+class PullRequest:
+    number: int
+    title: str
+    body: str
+    merged_at: datetime
+    author: str
+    url: str
+    labels: list[str]
+
+
+def parse_repo(value: str) -> tuple[str, str]:
+    """Accept 'owner/name' or a full GitHub URL and return (owner, name)."""
+    value = value.strip()
+    m = re.search(r"github\.com[/:]([^/]+)/([^/.]+)", value)
+    if m:
+        return m.group(1), m.group(2)
+    parts = value.split("/")
+    if len(parts) == 2 and all(parts):
+        return parts[0], parts[1]
+    raise GitHubError(f"Could not parse repo from {value!r}. Use 'owner/name'.")
+
+
+def detect_repo(cwd: str | None = None) -> tuple[str, str] | None:
+    """Infer 'owner/name' from the current git repo's origin remote.
+
+    Returns None when not in a git repo, git is unavailable, or the remote
+    isn't a GitHub URL.
+    """
+    if not shutil.which("git"):
+        return None
+    try:
+        out = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            cwd=cwd,
+        )
+    except (subprocess.SubprocessError, OSError):
+        return None
+    url = out.stdout.strip()
+    if out.returncode != 0 or not url:
+        return None
+    try:
+        return parse_repo(url)
+    except GitHubError:
+        return None
+
+
+def _headers(token: str | None) -> dict[str, str]:
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "User-Agent": "shiplog-cli",
+    }
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    return headers
+
+
+def is_bot(author: str) -> bool:
+    """Heuristic: GitHub apps end in '[bot]'; also catch common automation accounts."""
+    lowered = author.lower()
+    return lowered.endswith("[bot]") or lowered in {
+        "dependabot",
+        "renovate",
+        "renovate-bot",
+        "github-actions",
+        "snyk-bot",
+        "greenkeeper",
+        "imgbot",
+        "pre-commit-ci",
+    }
+
+
+def fetch_merged_prs(
+    owner: str,
+    repo: str,
+    token: str | None = None,
+    since: datetime | None = None,
+    limit: int | None = None,
+    base_branch: str | None = None,
+    include_bots: bool = False,
+) -> list[PullRequest]:
+    """Return merged PRs newest-first, optionally filtered by merge date / count.
+
+    Lists closed PRs sorted by `updated` descending and keeps the merged ones.
+    Bot-authored PRs (dependabot, renovate, …) are skipped unless include_bots.
+    Stops paging early once we pass the `since` cutoff.
+    """
+    session = requests.Session()
+    session.headers.update(_headers(token))
+
+    results: list[PullRequest] = []
+    page = 1
+    while True:
+        params = {
+            "state": "closed",
+            "sort": "updated",
+            "direction": "desc",
+            "per_page": _PAGE_SIZE,
+            "page": page,
+        }
+        if base_branch:
+            params["base"] = base_branch
+
+        resp = session.get(
+            f"{GITHUB_API}/repos/{owner}/{repo}/pulls",
+            params=params,
+            timeout=30,
+        )
+        if resp.status_code == 404:
+            raise GitHubError(
+                f"Repo {owner}/{repo} not found (or no access). "
+                "Provide a token for private repos."
+            )
+        if resp.status_code == 401:
+            raise GitHubError("GitHub rejected the token (401). Check your credentials.")
+        if resp.status_code == 403 and "rate limit" in resp.text.lower():
+            raise GitHubError(
+                "GitHub rate limit hit. Set a token via --token or GITHUB_TOKEN."
+            )
+        if not resp.ok:
+            raise GitHubError(f"GitHub API error {resp.status_code}: {resp.text[:200]}")
+
+        batch = resp.json()
+        if not batch:
+            break
+
+        reached_cutoff = False
+        for pr in batch:
+            if not pr.get("merged_at"):
+                continue
+            merged_at = _parse_dt(pr["merged_at"])
+            if since and merged_at < since:
+                # Sorted by updated desc, not merged desc, so don't break outright —
+                # but a whole page older than the cutoff means we're done.
+                reached_cutoff = True
+                continue
+            author = (pr.get("user") or {}).get("login", "unknown")
+            if not include_bots and is_bot(author):
+                continue
+            results.append(
+                PullRequest(
+                    number=pr["number"],
+                    title=pr["title"] or "",
+                    body=pr.get("body") or "",
+                    merged_at=merged_at,
+                    author=author,
+                    url=pr.get("html_url", ""),
+                    labels=[l["name"] for l in pr.get("labels", [])],
+                )
+            )
+            if limit and len(results) >= limit:
+                results.sort(key=lambda p: p.merged_at, reverse=True)
+                return results[:limit]
+
+        # Heuristic stop: if the oldest item on this page predates the cutoff,
+        # later pages (older still) can't contain newer merges.
+        if since and reached_cutoff and batch:
+            oldest = _parse_dt(batch[-1]["updated_at"])
+            if oldest < since:
+                break
+
+        if len(batch) < _PAGE_SIZE:
+            break
+        page += 1
+
+    results.sort(key=lambda p: p.merged_at, reverse=True)
+    return results
+
+
+def _parse_dt(value: str) -> datetime:
+    return datetime.strptime(value, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)

shiplog/render.py

@@ -0,0 +1,91 @@
+"""Render generated changelog entries to Markdown or JSON."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import datetime
+
+from .api import VALID_CATEGORIES, ChangelogEntry
+
+_EMOJI = {
+    "New": "✨",
+    "Improved": "⚡",
+    "Fixed": "🐛",
+    "Infrastructure": "🛠️",
+}
+
+# Display order for grouped output.
+_ORDER = ("New", "Improved", "Fixed", "Infrastructure")
+
+
+@dataclass
+class RenderedItem:
+    """A generated entry paired with its source PR metadata."""
+
+    entry: ChangelogEntry
+    pr_number: int | None
+    pr_url: str
+    merged_at: datetime | None
+
+
+def to_markdown(
+    items: list[RenderedItem],
+    heading: str | None = None,
+    group_by_category: bool = True,
+    show_pr_links: bool = True,
+) -> str:
+    lines: list[str] = []
+    if heading:
+        lines.append(f"# {heading}")
+        lines.append("")
+
+    if group_by_category:
+        buckets: dict[str, list[RenderedItem]] = {c: [] for c in _ORDER}
+        for it in items:
+            buckets.setdefault(it.entry.category, []).append(it)
+        for category in _ORDER:
+            bucket = buckets.get(category) or []
+            if not bucket:
+                continue
+            lines.append(f"## {_EMOJI.get(category, '')} {category}".strip())
+            lines.append("")
+            for it in bucket:
+                lines.extend(_item_lines(it, show_pr_links))
+            lines.append("")
+    else:
+        for it in items:
+            lines.extend(_item_lines(it, show_pr_links, with_category=True))
+
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _item_lines(it: RenderedItem, show_pr_links: bool, with_category: bool = False) -> list[str]:
+    prefix = f"**[{it.entry.category}]** " if with_category else ""
+    suffix = ""
+    if show_pr_links and it.pr_number:
+        if it.pr_url:
+            suffix = f" ([#{it.pr_number}]({it.pr_url}))"
+        else:
+            suffix = f" (#{it.pr_number})"
+    return [
+        f"### {prefix}{it.entry.title}{suffix}",
+        "",
+        it.entry.body,
+        "",
+    ]
+
+
+def to_json(items: list[RenderedItem]) -> str:
+    payload = [
+        {
+            "category": it.entry.category,
+            "title": it.entry.title,
+            "body": it.entry.body,
+            "pr_number": it.pr_number,
+            "pr_url": it.pr_url,
+            "merged_at": it.merged_at.isoformat() if it.merged_at else None,
+        }
+        for it in items
+    ]
+    return json.dumps(payload, indent=2)

shiplog_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: shiplog-cli
+Version: 0.1.0
+Summary: Turn merged GitHub pull requests into clean, customer-facing changelogs.
+Author-email: Siddharth Mahajan <siddharthmahajan65@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://shiplogbeta.arksoft.xyz
+Project-URL: Repository, https://github.com/20sid02/shiplog
+Project-URL: Issues, https://github.com/20sid02/shiplog/issues
+Keywords: changelog,github,ai,release-notes,cli,pull-request
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+Requires-Dist: rich>=13.0
+
+# Shiplog CLI
+
+Turn merged GitHub pull requests into clean, customer-facing changelogs.
+
+Shiplog reads merged PRs from a repository, runs each one through the Shiplog AI
+transform, and emits a publish-ready changelog grouped by category
+(New / Improved / Fixed / Infrastructure).
+
+## Install
+
+```bash
+pip install shiplog
+```
+
+Requires Python 3.9+.
+
+## Quick start
+
+```bash
+# 1. Save your API key (get one at https://shiplogbeta.arksoft.xyz)
+shiplog login
+
+# 2. Generate a changelog — auto-detects the repo from git origin
+cd your-project
+shiplog generate
+
+# 3. Or name any repo explicitly
+shiplog generate owner/repo --days 30 -o CHANGELOG.md
+```
+
+## Authentication
+
+### Shiplog API key
+
+The CLI sends your API key with every generation request. Save it once:
+
+```bash
+shiplog login sk_live_abc123...
+```
+
+Or set `SHIPLOG_API_KEY` in your environment. Without a key, the CLI works in
+demo mode (limited to 5 generations per day).
+
+Other auth commands:
+
+```bash
+shiplog whoami    # show current key
+shiplog logout    # remove saved key
+```
+
+### GitHub token
+
+For the `generate` command, Shiplog needs read access to the repo's pull
+requests. It resolves a GitHub token in this order:
+
+1. `--token` flag
+2. `$GITHUB_TOKEN` / `$GH_TOKEN`
+3. `gh auth token` (if the GitHub CLI is installed and logged in)
+
+Public repos work without a token but are subject to tighter rate limits.
+
+## Usage
+
+### Generate a changelog from a repo
+
+The repo argument is optional — inside a git repo, Shiplog uses the `origin`
+remote automatically:
+
+```bash
+# Run inside your repo — no arguments needed
+shiplog generate
+
+# Or name any repo explicitly
+shiplog generate owner/repo
+
+# Everything merged in the last 30 days, written to a file
+shiplog generate --days 30 -o CHANGELOG.md
+
+# Since a specific date, only PRs merged into main, as JSON
+shiplog generate owner/repo --since 2026-06-01 --base main --format json
+```
+
+Bot-authored PRs (dependabot, renovate, …) are skipped by default so the
+changelog stays customer-facing. Generation runs in parallel and automatically
+retries on rate limits, so large repos finish fast without dropping entries.
+
+Options:
+
+| Flag | Description |
+|------|-------------|
+| `--token` | GitHub token (overrides env / gh CLI) |
+| `--base` | Only PRs merged into this base branch |
+| `--since YYYY-MM-DD` | Only PRs merged since this date |
+| `--days N` | Only PRs merged in the last N days |
+| `--limit N` | Max PRs to include (default 20) |
+| `--format markdown\|json` | Output format (default markdown) |
+| `--output, -o` | Write to a file instead of stdout |
+| `--title` | Custom heading for the changelog |
+| `--no-group` | List chronologically instead of by category |
+| `--no-links` | Omit PR number links |
+| `--include-bots` | Include bot PRs (off by default) |
+| `--concurrency N` | Parallel generation requests (default 8) |
+
+### Transform a single PR (no GitHub needed)
+
+Handy for testing or one-off entries — mirrors the website demo.
+
+```bash
+shiplog single "fix: pagination offset bug in list endpoint" \
+  --body "Closes #412. Switched to cursor-based pagination."
+```
+
+Add `--format markdown` or `--format json` for machine-readable output.
+
+## Configuration
+
+| Env var | Purpose |
+|---------|---------|
+| `SHIPLOG_API_KEY` | Shiplog API key (alternative to `shiplog login`) |
+| `SHIPLOG_API_BASE` | Override the generation API URL |
+| `SHIPLOG_CONFIG_DIR` | Override config directory (default `~/.config/shiplog`) |
+| `GITHUB_TOKEN` / `GH_TOKEN` | GitHub auth |
+
+## How it works
+
+```
+GitHub PRs ──▶ Shiplog API (/api/generate) ──▶ {category, title, body} ──▶ Markdown / JSON
+```
+
+The generation API is a Cloudflare Worker. Authenticated users get metered
+access based on their plan. Anonymous users get a small demo allowance.

shiplog_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+shiplog/__init__.py,sha256=KQMSQCYT4oVUAcqbJXXkrhY-M7__2Qm-hJkM6y1eIc0,107
+shiplog/__main__.py,sha256=4JMK66Wj4uLZTKbF-sT3LAxOsr6buig77PmOkJCRRxw,83
+shiplog/api.py,sha256=29fjwuOJi8vCeFR70Xy5eHX8lUZACpd-LZB7pmT2aMU,3636
+shiplog/auth.py,sha256=nq-iGQVa3cl_D1HRZoJ4M44XAz6K34oulJGb5BoV0ms,1076
+shiplog/cli.py,sha256=K8b-yoi2zVIgmlz9Yq68TZm1HTNpy1PK4XbTaRIMxwE,11258
+shiplog/config.py,sha256=_GRXOfDd9O1FAXpQGxx3TfwiFSDS5CSmBe6l5DXiZRo,1382
+shiplog/github.py,sha256=sQeJKYIaTT00pLflHSpmta6u_WxnhOFeFL9Zsjb3Je4,5886
+shiplog/render.py,sha256=fT8mSPf1tkQHjVopKR3p7-Mm9WBXGkv9IJJz3KpaVFs,2491
+shiplog_cli-0.1.0.dist-info/METADATA,sha256=W5lQyffpIY6d6fYElD-09QAYjpI154Zl3LJzynVloes,4965
+shiplog_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+shiplog_cli-0.1.0.dist-info/entry_points.txt,sha256=rr4GtabeWAnsGQ4UfeSHQYNw4YboxUrdIsPUOsg6JL8,45
+shiplog_cli-0.1.0.dist-info/top_level.txt,sha256=AurA5LdlpUwimgmFfncWdWB-YvecmJCHhPRmCmHzJHo,8
+shiplog_cli-0.1.0.dist-info/RECORD,,

shiplog_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

shiplog_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+shiplog = shiplog.cli:main

shiplog_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+shiplog