prgen-cli 0.2.1__py3-none-any.whl

prgen/__main__.py

@@ -0,0 +1,4 @@
+from prgen.cli import main
+
+if __name__ == "__main__":
+    main()

prgen/about.py

@@ -0,0 +1,16 @@
+"""Project attribution (shown in CLI and Rich output)."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+AUTHOR = "Jean Paul Fernandez"
+REPO_URL = "https://github.com/jpxoi/prgen"
+
+# PyPI distribution name (import package remains `prgen`).
+_DISTRIBUTION_NAME = "prgen-cli"
+
+
+def package_version() -> str:
+    try:
+        return version(_DISTRIBUTION_NAME)
+    except PackageNotFoundError:
+        return "0.0.0"

prgen/api_errors.py

@@ -0,0 +1,81 @@
+"""User-facing messages for LLM provider failures."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+Backend = Literal["openai", "gemini"]
+
+
+def _trim(msg: str, max_len: int = 220) -> str:
+    one = " ".join(msg.split())
+    if len(one) <= max_len:
+        return one
+    return one[: max_len - 1] + "…"
+
+
+def format_provider_error(exc: BaseException, *, backend: Backend) -> str:
+    """Map SDK exceptions to a short stderr-safe line (no traceback)."""
+    if backend == "openai":
+        return _openai_user_message(exc)
+    return _gemini_user_message(exc)
+
+
+def _openai_user_message(exc: BaseException) -> str:
+    try:
+        import openai
+    except ImportError:
+        return f"OpenAI: {_trim(str(exc))}"
+
+    if isinstance(exc, openai.AuthenticationError):
+        return "OpenAI: invalid or revoked API key — check OPENAI_API_KEY."
+    if isinstance(exc, openai.PermissionDeniedError):
+        return "OpenAI: permission denied — account or model may not be allowed."
+    if isinstance(exc, openai.RateLimitError):
+        return "OpenAI: rate limited — wait and retry, or check your plan."
+    if isinstance(exc, (openai.APIConnectionError, openai.APITimeoutError)):
+        return "OpenAI: network error — check your connection and try again."
+    if isinstance(exc, openai.NotFoundError):
+        return "OpenAI: model not found — check --model / --tier."
+    if isinstance(exc, openai.BadRequestError):
+        return f"OpenAI: bad request — {_trim(exc.message)}"
+    if isinstance(exc, openai.APIStatusError):
+        sc = exc.status_code
+        if sc == 401:
+            return "OpenAI: unauthorized — check your API key."
+        if sc == 403:
+            return "OpenAI: forbidden — model or org may not allow this request."
+        if sc == 404:
+            return "OpenAI: not found — model or endpoint unavailable."
+        if sc == 429:
+            return "OpenAI: too many requests — retry after a short wait."
+        if sc >= 500:
+            return "OpenAI: server error — try again later."
+        return f"OpenAI: HTTP {sc} — {_trim(exc.message)}"
+    if isinstance(exc, openai.APIError):
+        return f"OpenAI: {_trim(exc.message)}"
+    return f"OpenAI: {_trim(str(exc))}"
+
+
+def _gemini_user_message(exc: BaseException) -> str:
+    try:
+        from google.genai import errors as genai_errors
+    except ImportError:
+        return f"Gemini: {_trim(str(exc))}"
+
+    if isinstance(exc, genai_errors.ClientError):
+        code = getattr(exc, "code", None)
+        if code in (401, 403):
+            return "Gemini: API key invalid or access denied — check GOOGLE_API_KEY."
+        if code == 404:
+            return "Gemini: model or resource not found — check --model / --tier."
+        if code == 429:
+            return "Gemini: rate limited — wait and retry."
+        if code is not None and 400 <= int(code) < 500:
+            return f"Gemini: request failed (HTTP {code}). {_trim(str(exc))}"
+    if isinstance(exc, genai_errors.ServerError):
+        return "Gemini: server error — try again later."
+    if isinstance(exc, genai_errors.APIError):
+        code = getattr(exc, "code", "?")
+        return f"Gemini: API error (HTTP {code}) — {_trim(str(exc))}"
+    return f"Gemini: {_trim(str(exc))}"

prgen/cli.py

@@ -0,0 +1,518 @@
+from __future__ import annotations
+
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Annotated, cast
+
+import typer
+from click.core import ParameterSource
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.text import Text
+
+from prgen.about import AUTHOR, REPO_URL, package_version
+from prgen.api_errors import Backend, format_provider_error
+from prgen.config import (
+    PersistedConfigKey,
+    load_prgen_env,
+    public_config_rows,
+    read_cli_defaults_from_config,
+    read_persisted_config,
+    set_user_key,
+    unset_user_key,
+    user_config_path,
+)
+from prgen.defaults import ModelTier, ProviderChoice, model_for_tier
+from prgen.git_utils import (
+    GitNotFoundError,
+    GitRefError,
+    ensure_git_available,
+    get_commits,
+    get_diff,
+    git_repo_root,
+    verify_base_ref,
+)
+from prgen.prompting import build_prompt, load_prompt_template
+from prgen.ui import loading, print_pr_summary
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"prgen {package_version()}")
+        typer.echo(f"Author: {AUTHOR}")
+        typer.echo(REPO_URL)
+        raise typer.Exit(0)
+
+
+def _api_key_setup_hint() -> str:
+    return (
+        "Run: prgen config\n"
+        "Keys live in ~/.config/prgen/config.json (prgen config set …, or edit that file)."
+    )
+
+
+def extract_tag(text: str, tag: str) -> str | None:
+    match = re.search(rf"<{tag}>\s*(.*?)\s*</{tag}>", text, re.DOTALL | re.IGNORECASE)
+    return match.group(1).strip() if match else None
+
+
+def _print_config_table(console: Console) -> None:
+    rows = public_config_rows()
+    path = user_config_path()
+    console.print(f"[dim]{path}[/dim]\n")
+    table = Table(box=box.SIMPLE, show_header=True, padding=(0, 1))
+    table.add_column("Key", style="bold")
+    table.add_column("Value")
+    for key, val, is_secret in rows:
+        if is_secret:
+            value_cell = (
+                Text("set", style="green bold") if val == "set" else Text("unset", style="yellow")
+            )
+        elif val == "unset":
+            value_cell = Text("unset", style="dim")
+        else:
+            value_cell = Text(val, style="cyan")
+        table.add_row(key, value_cell)
+    console.print(table)
+
+
+def run_interactive_config() -> int:
+    """Interactive wizard for ~/.config/prgen/config.json (all persisted keys)."""
+    if not sys.stdin.isatty():
+        print(
+            "prgen: `config` needs an interactive terminal (stdin is not a TTY).",
+            file=sys.stderr,
+        )
+        return 1
+
+    console = Console(stderr=True)
+    try:
+        data = read_persisted_config()
+    except ValueError as exc:
+        print(f"prgen: {exc}", file=sys.stderr)
+        return 1
+
+    console.print(
+        Panel.fit(
+            "[bold]Interactive config[/bold]\n"
+            f"[dim]prgen v{package_version()} · {AUTHOR}[/dim]\n\n"
+            "[dim]• API keys: hidden; empty = leave unchanged.\n"
+            "• Any field: type [bold]-[/bold] to remove the saved value.\n"
+            "• Defaults: Enter accepts the suggested default.\n"
+            "• Omit saving implicit defaults (auto / default) unless you change them.[/dim]",
+            title="prgen",
+            border_style="dim",
+        )
+    )
+    console.print()
+
+    updates: dict[str, str] = {}
+    unsets: list[str] = []
+
+    console.print("[bold]API keys[/bold]\n")
+    for key, label in (
+        ("OPENAI_API_KEY", "OpenAI"),
+        ("GOOGLE_API_KEY", "Google AI / Gemini"),
+    ):
+        hint = " [dim](saved)[/dim]" if (data.get(key) or "").strip() else ""
+        try:
+            line = Prompt.ask(
+                f"{label}{hint}",
+                password=True,
+            )
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[yellow]Aborted.[/yellow]")
+            return 1
+        line = (line or "").strip()
+        if line == "-":
+            if (data.get(key) or "").strip():
+                unsets.append(key)
+        elif line:
+            updates[key] = line
+
+    console.print("\n[bold]CLI defaults[/bold]\n")
+
+    cur_base = (data.get("base") or "").strip()
+    try:
+        raw_base = Prompt.ask(
+            "Merge base ref (git)",
+            default=cur_base,
+        ).strip()
+    except (EOFError, KeyboardInterrupt):
+        console.print("\n[yellow]Aborted.[/yellow]")
+        return 1
+    if raw_base == "-":
+        if cur_base:
+            unsets.append("base")
+    elif raw_base != cur_base:
+        if raw_base:
+            updates["base"] = raw_base
+
+    cur_p = (data.get("provider") or "").strip()
+    if cur_p not in ("auto", "openai", "gemini"):
+        cur_p = ""
+    prompt_p = cur_p if cur_p else "auto"
+    while True:
+        try:
+            raw_p = Prompt.ask(
+                "Provider [auto|openai|gemini]",
+                default=prompt_p,
+            ).strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[yellow]Aborted.[/yellow]")
+            return 1
+        if raw_p == "-":
+            if cur_p:
+                unsets.append("provider")
+            break
+        if raw_p in ("auto", "openai", "gemini"):
+            if raw_p == cur_p:
+                pass
+            elif not cur_p and raw_p == "auto":
+                pass
+            else:
+                updates["provider"] = raw_p
+            break
+        console.print("[red]Invalid: use auto, openai, gemini, or -[/red]")
+
+    cur_t = (data.get("tier") or "").strip()
+    if cur_t not in ("default", "pro"):
+        cur_t = ""
+    prompt_t = cur_t if cur_t else "default"
+    while True:
+        try:
+            raw_t = Prompt.ask(
+                "Model tier [default|pro]",
+                default=prompt_t,
+            ).strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[yellow]Aborted.[/yellow]")
+            return 1
+        if raw_t == "-":
+            if cur_t:
+                unsets.append("tier")
+            break
+        if raw_t in ("default", "pro"):
+            if raw_t == cur_t:
+                pass
+            elif not cur_t and raw_t == "default":
+                pass
+            else:
+                updates["tier"] = raw_t
+            break
+        console.print("[red]Invalid: use default, pro, or -[/red]")
+
+    if not unsets and not updates:
+        console.print("\n[dim]No changes.[/dim]")
+        return 0
+
+    try:
+        for key in dict.fromkeys(unsets):
+            unset_user_key(key)
+        for key, value in updates.items():
+            set_user_key(key, value)
+    except ValueError as exc:
+        print(f"prgen: {exc}", file=sys.stderr)
+        return 1
+
+    console.print("\n[green]Saved.[/green]\n")
+    _print_config_table(console)
+    return 0
+
+
+def resolve_credentials(provider: ProviderChoice) -> tuple[str, str]:
+    """Return (backend, api_key). Raises ValueError if misconfigured."""
+    openai_key = os.getenv("OPENAI_API_KEY")
+    google_key = os.getenv("GOOGLE_API_KEY")
+
+    if provider == "openai":
+        if not openai_key:
+            raise ValueError(
+                "Missing OPENAI_API_KEY (--provider openai).\n\n" + _api_key_setup_hint()
+            )
+        return "openai", openai_key
+    if provider == "gemini":
+        if not google_key:
+            raise ValueError(
+                "Missing GOOGLE_API_KEY (--provider gemini).\n\n" + _api_key_setup_hint()
+            )
+        return "gemini", google_key
+
+    if google_key:
+        return "gemini", google_key
+    if openai_key:
+        return "openai", openai_key
+    raise ValueError("No API keys configured.\n\n" + _api_key_setup_hint())
+
+
+def run_summarize(
+    *,
+    repo: Path | None,
+    base: str,
+    provider: ProviderChoice,
+    tier: ModelTier,
+    model: str | None,
+    context: str,
+) -> int:
+    try:
+        ensure_git_available()
+    except GitNotFoundError as exc:
+        print(f"prgen: {exc}", file=sys.stderr)
+        return 1
+
+    git_cwd: Path | None = None
+    if repo is not None:
+        try:
+            git_cwd = git_repo_root(repo)
+        except ValueError as exc:
+            print(str(exc), file=sys.stderr)
+            return 1
+    try:
+        load_prgen_env()
+    except ValueError as exc:
+        print(f"prgen: {exc}", file=sys.stderr)
+        return 1
+
+    try:
+        backend, api_key = resolve_credentials(provider)
+    except ValueError as exc:
+        print(f"prgen: {exc}", file=sys.stderr)
+        return 1
+
+    if model is not None:
+        model_id = model
+    else:
+        model_id = model_for_tier(
+            "openai" if backend == "openai" else "gemini",
+            tier,
+        )
+
+    try:
+        try:
+            verify_base_ref(base, cwd=git_cwd)
+        except GitRefError as exc:
+            print(f"prgen: {exc}", file=sys.stderr)
+            return 1
+
+        diff = get_diff(base, cwd=git_cwd)
+        commits = get_commits(base, cwd=git_cwd)
+
+        if not diff and not commits:
+            print(
+                f"No commits or file changes vs {base}. Adjust --base or make changes.",
+                file=sys.stderr,
+            )
+            return 1
+
+        template = load_prompt_template()
+        prompt = build_prompt(
+            template=template,
+            diff=diff,
+            commits=commits,
+            additional_context=context,
+        )
+
+        try:
+            with loading(model=model_id):
+                if backend == "openai":
+                    from prgen.providers.openai_provider import OpenAIProvider
+
+                    output = OpenAIProvider(api_key=api_key, model=model_id).generate(prompt)
+                else:
+                    from prgen.providers.gemini_provider import GeminiProvider
+
+                    output = GeminiProvider(api_key=api_key, model=model_id).generate(prompt)
+        except ImportError as exc:
+            print(f"prgen: {exc}", file=sys.stderr)
+            return 1
+        except Exception as exc:
+            print(
+                f"prgen: {format_provider_error(exc, backend=cast(Backend, backend))}",
+                file=sys.stderr,
+            )
+            return 1
+
+        summary = extract_tag(output, "summary")
+        body = extract_tag(output, "body")
+
+        has_parts = bool(summary and body)
+        print_pr_summary(
+            summary if has_parts else None,
+            body if has_parts else None,
+            output,
+        )
+
+        return 0
+
+    except Exception as exc:
+        print(f"prgen: {exc}", file=sys.stderr)
+        return 1
+
+
+_CREDIT_EPILOG = f"[dim]{AUTHOR} · {REPO_URL}[/dim]"
+
+app = typer.Typer(
+    name="prgen",
+    help=(
+        "PR title and body from git diff and commits vs --base. "
+        "Optional defaults for --base, --provider, and --tier: ~/.config/prgen/config.json."
+    ),
+    invoke_without_command=True,
+    no_args_is_help=False,
+    epilog=_CREDIT_EPILOG,
+)
+
+config_app = typer.Typer(
+    name="config",
+    help="Configure ~/.config/prgen/config.json (interactive when no subcommand).",
+    invoke_without_command=True,
+    no_args_is_help=False,
+    epilog=_CREDIT_EPILOG,
+)
+app.add_typer(config_app, name="config")
+
+
+@app.callback()
+def _root(
+    ctx: typer.Context,
+    _version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            callback=_version_callback,
+            is_eager=True,
+            help="Print version.",
+        ),
+    ] = False,
+    repo: Annotated[
+        Path | None,
+        typer.Option(
+            "-C",
+            "--repo",
+            metavar="PATH",
+            help="Git working directory (git -C).",
+        ),
+    ] = None,
+    base: Annotated[
+        str,
+        typer.Option(
+            "--base",
+            help="Merge base ref for diff and log vs HEAD.",
+        ),
+    ] = "origin/main",
+    provider: Annotated[
+        ProviderChoice,
+        typer.Option(
+            "--provider",
+            help="auto picks Gemini when both API keys exist in config.",
+        ),
+    ] = "auto",
+    tier: Annotated[
+        ModelTier,
+        typer.Option(
+            "--tier",
+            help="Cheaper/faster vs stronger models.",
+        ),
+    ] = "default",
+    model: Annotated[
+        str | None,
+        typer.Option(
+            "--model",
+            metavar="ID",
+            help="Overrides --tier preset.",
+        ),
+    ] = None,
+    context: Annotated[
+        str,
+        typer.Option(
+            "--context",
+            metavar="TEXT",
+            help="Extra text merged into the prompt.",
+        ),
+    ] = "none",
+) -> None:
+    if ctx.invoked_subcommand is not None:
+        return
+    cfg_base, cfg_provider, cfg_tier = read_cli_defaults_from_config()
+    if ctx.get_parameter_source("base") == ParameterSource.DEFAULT and cfg_base is not None:
+        base = cfg_base
+    if ctx.get_parameter_source("provider") == ParameterSource.DEFAULT and cfg_provider is not None:
+        provider = cfg_provider
+    if ctx.get_parameter_source("tier") == ParameterSource.DEFAULT and cfg_tier is not None:
+        tier = cfg_tier
+    raise typer.Exit(
+        run_summarize(
+            repo=repo,
+            base=base,
+            provider=provider,
+            tier=tier,
+            model=model,
+            context=context,
+        )
+    )
+
+
+@config_app.callback()
+def _config_entry(ctx: typer.Context) -> None:
+    if ctx.invoked_subcommand is not None:
+        return
+    raise typer.Exit(run_interactive_config())
+
+
+@config_app.command("set", help="Set KEY to VALUE in config JSON.")
+def _config_set(
+    key: Annotated[PersistedConfigKey, typer.Argument(help="Field name.")],
+    value: Annotated[str, typer.Argument(help="Value; use - for stdin")],
+) -> None:
+    try:
+        val = value
+        if val == "-":
+            val = sys.stdin.read()
+        val = val.strip("\n\r")
+        path = set_user_key(key, val)
+        print(f"Wrote {key} to {path}", file=sys.stderr)
+    except ValueError as exc:
+        print(f"prgen: {exc}", file=sys.stderr)
+        raise typer.Exit(1) from exc
+
+
+@config_app.command("unset", help="Remove KEY from config JSON.")
+def _config_unset(
+    key: Annotated[PersistedConfigKey, typer.Argument(help="Field name.")],
+) -> None:
+    try:
+        path = unset_user_key(key)
+        print(f"Removed {key} from {path}", file=sys.stderr)
+    except ValueError as exc:
+        print(f"prgen: {exc}", file=sys.stderr)
+        raise typer.Exit(1) from exc
+
+
+@config_app.command(
+    "show",
+    help="Print config.json (non-secret values; API keys as set or unset only).",
+)
+def _config_show() -> None:
+    try:
+        _print_config_table(Console())
+    except ValueError as exc:
+        print(f"prgen: {exc}", file=sys.stderr)
+        raise typer.Exit(1) from exc
+
+
+@config_app.command("path", help="Print config file path.")
+def _config_path() -> None:
+    typer.echo(user_config_path())
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()