pygenkit 0.2.0__py3-none-any.whl

pygenkit/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "0.2.0"

pygenkit/ai/__init__.py

@@ -0,0 +1,11 @@
+from pygenkit.ai.provider import LLMProvider, OpenAIProvider, create_provider
+from pygenkit.ai.review import ReviewResult, get_pr_diff, review_diff
+
+__all__ = [
+    "LLMProvider",
+    "OpenAIProvider",
+    "create_provider",
+    "ReviewResult",
+    "review_diff",
+    "get_pr_diff",
+]

pygenkit/ai/prompts.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+SYSTEM_PROMPT = (
+    "You are an expert Python code reviewer. "
+    "Analyze the provided diff and give concise, actionable feedback.\n\n"
+    "Focus on:\n"
+    "1. **Correctness** - bugs, logic errors, edge cases\n"
+    "2. **Security** - injection, hardcoded secrets, permission issues\n"
+    "3. **Performance** - unnecessary work, poor data structures\n"
+    "4. **Maintainability** - naming, complexity, duplication, error handling\n"
+    "5. **Style** - consistency with modern Python (3.12+) patterns\n\n"
+    "Output format (markdown):\n"
+    "## Summary\n"
+    "Brief 1-sentence overall assessment.\n\n"
+    "## Issues\n"
+    "| Severity | File | Line | Description |\n"
+    "|----------|------|------|-------------|\n"
+    "| high | path/file.py | 42 | Description of the issue and suggestion |\n\n"
+    "Severity: high, medium, low, or info.\n\n"
+    "## Positive\n"
+    "What was done well, if anything."
+)
+
+
+def build_user_prompt(diff: str, filename_hint: str = "") -> str:
+    hint = f" (focusing on {filename_hint})" if filename_hint else ""
+    return f"Review this Python diff{hint}:\n\n```diff\n{diff}\n```"

pygenkit/ai/provider.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import json
+import os
+import urllib.request
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class LLMProvider(ABC):
+    @abstractmethod
+    def complete(self, system: str, user: str, **kwargs: Any) -> str:
+        ...
+
+
+class OpenAIProvider(LLMProvider):
+    def __init__(self, api_key: str | None = None, model: str = "gpt-4o-mini") -> None:
+        self.api_key = api_key or os.environ.get("OPENAI_API_KEY", "")
+        if not self.api_key:
+            msg = "OPENAI_API_KEY is not set"
+            raise ValueError(msg)
+        self.model = model
+        self._base_url = "https://api.openai.com/v1/chat/completions"
+
+    def complete(self, system: str, user: str, **kwargs: Any) -> str:
+        body = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            **kwargs,
+        }
+        req = urllib.request.Request(
+            self._base_url,
+            data=json.dumps(body).encode(),
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            result: dict[str, Any] = json.loads(resp.read().decode())
+
+        choices = result.get("choices", [])
+        if not choices:
+            msg = f"OpenAI API returned no choices: {result}"
+            raise RuntimeError(msg)
+        return str(choices[0]["message"]["content"])
+
+
+def create_provider(provider_name: str = "openai", **kwargs: Any) -> LLMProvider:
+    if provider_name == "openai":
+        return OpenAIProvider(**kwargs)
+    msg = f"Unknown provider: {provider_name}"
+    raise ValueError(msg)

pygenkit/ai/review.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from pygenkit.ai.prompts import SYSTEM_PROMPT, build_user_prompt
+from pygenkit.ai.provider import LLMProvider, create_provider
+
+
+@dataclass
+class ReviewResult:
+    raw: str
+    summary: str = ""
+    issues: list[dict[str, str]] = field(default_factory=list)
+    positives: list[str] = field(default_factory=list)
+    error: str = ""
+
+
+def get_pr_diff(pr_number: str, repo: str | None = None) -> str:
+    cmd = ["gh", "pr", "diff", pr_number]
+    if repo:
+        cmd.extend(["--repo", repo])
+    try:
+        r = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if r.returncode != 0:
+            msg = f"gh command failed: {r.stderr.strip()}"
+            raise RuntimeError(msg)
+        return r.stdout
+    except FileNotFoundError:
+        msg = "GitHub CLI (gh) is not installed"
+        raise RuntimeError(msg)  # noqa: B904
+
+
+def get_pr_diff_from_file(path: str | Path) -> str:
+    return Path(path).read_text(encoding="utf-8")
+
+
+def review_diff(
+    diff: str,
+    provider: LLMProvider | None = None,
+    filename_hint: str = "",
+    **llm_kwargs: Any,
+) -> ReviewResult:
+    if provider is None:
+        provider = create_provider()
+
+    try:
+        user = build_user_prompt(diff, filename_hint)
+        raw = provider.complete(SYSTEM_PROMPT, user, **llm_kwargs)
+        return ReviewResult(raw=raw)
+    except Exception as exc:
+        return ReviewResult(raw="", error=str(exc))

pygenkit/cli/__init__.py

@@ -0,0 +1,3 @@
+from pygenkit.cli.app import cli
+
+__all__ = ["cli"]

pygenkit/cli/app.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import typer
+
+from pygenkit import __version__
+from pygenkit.cli.commands import (
+    doctor_cmd,
+    generate_cmd,
+    health_cmd,
+    init_cmd,
+    inspect_cmd,
+    new_cmd,
+    release_check_cmd,
+    review_cmd,
+    validate_cmd,
+)
+
+cli = typer.Typer(
+    name="pygenkit",
+    help="Analyze Python projects and generate CI/CD pipelines for PyPI and Debian/Launchpad",
+    no_args_is_help=True,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"PyGenKit v{__version__}")
+        raise typer.Exit()
+
+
+@cli.callback()
+def _main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show version and exit",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    pass
+
+
+cli.command(name="init")(init_cmd)
+cli.command(name="new")(new_cmd)
+cli.command(name="inspect")(inspect_cmd)
+cli.command(name="validate")(validate_cmd)
+cli.command(name="generate")(generate_cmd)
+cli.command(name="release-check")(release_check_cmd)
+cli.command(name="health")(health_cmd)
+cli.command(name="review")(review_cmd)
+cli.command(name="doctor")(doctor_cmd)

pygenkit/cli/commands/__init__.py

@@ -0,0 +1,21 @@
+from pygenkit.cli.commands.doctor import doctor_cmd
+from pygenkit.cli.commands.generate import generate_cmd
+from pygenkit.cli.commands.health import health_cmd
+from pygenkit.cli.commands.init import init_cmd
+from pygenkit.cli.commands.inspect import inspect_cmd
+from pygenkit.cli.commands.new import new_cmd
+from pygenkit.cli.commands.release_check import release_check_cmd
+from pygenkit.cli.commands.review import review_cmd
+from pygenkit.cli.commands.validate import validate_cmd
+
+__all__ = [
+    "init_cmd",
+    "inspect_cmd",
+    "new_cmd",
+    "validate_cmd",
+    "generate_cmd",
+    "release_check_cmd",
+    "doctor_cmd",
+    "health_cmd",
+    "review_cmd",
+]

pygenkit/cli/commands/build.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+
+
+def build_cmd(
+    clean: bool = typer.Option(True, "--clean", help="Clean before build"),
+) -> None:
+    project_dir = Path.cwd()
+    pyproject = project_dir / "pyproject.toml"
+    if not pyproject.exists():
+        typer.echo("No pyproject.toml found. Are you in a Python project?")
+        raise typer.Exit(code=1)
+
+    if clean:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "build"],
+            capture_output=True,
+            timeout=60,
+        )
+
+    result = subprocess.run(
+        [sys.executable, "-m", "build", "--sdist", "--wheel", str(project_dir)],
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+
+    if result.returncode != 0:
+        typer.echo(f"Build failed:\n{result.stderr}")
+        raise typer.Exit(code=1)
+
+    dist_dir = project_dir / "dist"
+    if dist_dir.exists():
+        for f in sorted(dist_dir.iterdir()):
+            typer.echo(f"  {f.name}")
+    typer.echo("Build complete.")

pygenkit/cli/commands/doctor.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from collections.abc import Callable
+from typing import Any
+
+import typer
+
+from pygenkit import __version__
+
+
+class DoctorCheck:
+    def __init__(self, name: str, check_fn: Callable[[], Any], hint: str = "") -> None:
+        self.name = name
+        self.check_fn = check_fn
+        self.hint = hint
+
+    def run(self) -> dict[str, Any]:
+        try:
+            result = self.check_fn()
+            return {"name": self.name, "ok": True, "detail": str(result), "hint": ""}
+        except Exception as exc:
+            return {"name": self.name, "ok": False, "detail": str(exc), "hint": self.hint}
+
+
+def _check_python() -> str:
+    return sys.version.split()[0]
+
+
+def _check_git() -> str:
+    r = subprocess.run(["git", "--version"], capture_output=True, text=True, timeout=10)
+    return r.stdout.strip()
+
+
+def _check_gh() -> str:
+    if not shutil.which("gh"):
+        raise RuntimeError("not found")
+    r = subprocess.run(["gh", "--version"], capture_output=True, text=True, timeout=10)
+    return r.stdout.split("\n")[0] if r.stdout else "found"
+
+
+def _check_gpg() -> str:
+    if not shutil.which("gpg"):
+        raise RuntimeError("not found (apt install gnupg)")
+    return "found"
+
+
+def _check_dput() -> str:
+    if not shutil.which("dput"):
+        raise RuntimeError("not found (apt install dput)")
+    return "found"
+
+
+def _check_debhelper() -> str:
+    if not shutil.which("dh"):
+        raise RuntimeError("not found (apt install debhelper)")
+    return "found"
+
+
+def _check_twine() -> str:
+    r = subprocess.run(
+        [sys.executable, "-m", "twine", "--version"],
+        capture_output=True, text=True, timeout=10,
+    )
+    if r.returncode != 0:
+        raise RuntimeError("not installed (pip install twine)")
+    return r.stdout.strip()
+
+
+def _check_build_module() -> str:
+    r = subprocess.run(
+        [sys.executable, "-m", "build", "--version"],
+        capture_output=True, text=True, timeout=10,
+    )
+    if r.returncode != 0:
+        raise RuntimeError("not installed (pip install build)")
+    return r.stdout.strip()
+
+
+def doctor_cmd() -> None:
+    """Check system for required tools."""
+    checks = [
+        DoctorCheck("Python", _check_python, "Install Python 3.12+ from python.org"),
+        DoctorCheck("Git", _check_git, "apt install git"),
+        DoctorCheck("GitHub CLI", _check_gh, "Install from https://cli.github.com"),
+        DoctorCheck("GPG", _check_gpg, "apt install gnupg"),
+        DoctorCheck("dput", _check_dput, "apt install dput"),
+        DoctorCheck("debhelper", _check_debhelper, "apt install debhelper"),
+        DoctorCheck(
+            "twine", _check_twine, "pip install twine"
+        ),
+        DoctorCheck(
+            "build", _check_build_module, "pip install build"
+        ),
+    ]
+
+    typer.echo(f"PyGenKit v{__version__} — Doctor")
+    typer.echo("")
+
+    all_ok = True
+    for check in checks:
+        result = check.run()
+        if result["ok"]:
+            typer.echo(f"  \u2713 {result['name']}: {result['detail']}")
+        else:
+            all_ok = False
+            detail = f" ({result['detail']})" if result["detail"] else ""
+            typer.echo(f"  \u2717 {result['name']}: not found{detail}")
+            if result["hint"]:
+                typer.echo(f"    \u2192 {result['hint']}")
+
+    typer.echo("")
+    if all_ok:
+        typer.echo("All checks passed!")
+    else:
+        typer.echo("Some checks failed. Fix the issues above and re-run.")
+        raise typer.Exit(code=1)

pygenkit/cli/commands/generate.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from pygenkit.generators.orchestrator import generate_all
+from pygenkit.models.config import PyGenKitConfig
+
+
+def generate_cmd(
+
+    config: Path = typer.Option("pygenkit.toml", "--config", "-c", help="Config file"),  # noqa: B008
+    dry_run: bool = typer.Option(False, "--dry-run", "-n", help="Show changes without writing"),  # noqa: B008
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing files"),  # noqa: B008
+) -> None:
+    """Generate CI/CD pipelines, Dockerfiles, and deploy configs."""
+    if not config.exists():
+        typer.echo(f"  Config not found: {config}")
+        typer.echo("  Run: pygenkit init <name>")
+        raise typer.Exit(code=1)
+
+    cfg = PyGenKitConfig.load(config)
+    results = generate_all(cfg, force=force)
+
+    if dry_run:
+        _report_dry(results)
+        return
+
+    total = sum(len(v) for v in results.values())
+    if total == 0:
+        typer.echo("  Nothing to generate (enable docker/deploy in config, or files already exist).")  # noqa: E501
+        typer.echo("  Use --force to overwrite existing files.")
+        return
+
+    typer.echo(f"  Generated {total} file(s):")
+    cwd = Path.cwd().resolve()
+    for category, paths in results.items():
+        for p in paths:
+            rel = p.resolve().relative_to(cwd)
+            typer.echo(f"    \u2713 {category}: {rel}")
+
+    typer.echo("")
+    typer.echo("  Done.")
+
+
+def _report_dry(results: dict[str, list[Path]]) -> None:
+    total = sum(len(v) for v in results.values())
+    typer.echo(f"  Would generate {total} file(s):")
+    for category, paths in results.items():
+        for p in paths:
+            typer.echo(f"    {category}: {p}")

pygenkit/cli/commands/health.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import typer
+
+from pygenkit.health.api import calculate_health
+
+
+def _bar(pct: int, width: int = 20) -> str:
+    filled = int(pct / 100 * width)
+    empty = width - filled
+    return "[" + "#" * filled + "-" * empty + "]"
+
+
+def health_cmd() -> None:
+    """Assess project health across 7 categories."""
+    report = calculate_health(".")
+
+    score = report.score
+    bar = _bar(score)
+    grade = _grade(score)
+
+    typer.echo(f"  Health Score: {bar} {score}/100 ({grade})")
+    typer.echo("")
+
+    cat_keys = (
+        "versioning", "testing", "documentation",
+        "cicd", "security", "packaging", "structure",
+    )
+    for cat_key in cat_keys:
+        cat = report.categories.get(cat_key)
+        if not cat:
+            continue
+        pct = int(cat.score * 100)
+        cb = _bar(pct, 10)
+        label = cat.name.ljust(14)
+        typer.echo(f"  {label} {cb} {pct}%  ({cat.passed}/{cat.total})")
+
+    if report.issues:
+        typer.echo("")
+        typer.echo("  Issues:")
+        for issue in report.issues[:10]:
+            typer.echo(f"    \u2717 {issue}")
+        if len(report.issues) > 10:
+            typer.echo(f"    ... and {len(report.issues) - 10} more")
+
+    typer.echo("")
+    if score >= 80:
+        typer.echo("  Great shape!")
+    elif score >= 50:
+        typer.echo("  Room for improvement.")
+    else:
+        typer.echo("  Needs significant work.")
+
+
+def _grade(score: int) -> str:
+    if score >= 90:
+        return "A"
+    if score >= 80:
+        return "B"
+    if score >= 65:
+        return "C"
+    if score >= 50:
+        return "D"
+    return "F"

pygenkit/cli/commands/init.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from pygenkit.models.config import PyGenKitConfig
+
+
+def init_cmd(
+    name: str = typer.Argument(..., help="Project name"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config"),  # noqa: B008
+) -> None:
+    """Create pygenkit.toml in the current directory."""
+    config_path = Path("pygenkit.toml").resolve()
+    if config_path.exists() and not force:
+        typer.echo("  pygenkit.toml already exists. Use --force to overwrite.")
+        raise typer.Exit(code=1)
+
+    content = PyGenKitConfig.generate_default(name)
+    config_path.write_text(content, encoding="utf-8")
+    typer.echo(f"  Created {config_path}")
+    typer.echo("  Edit it with your project info, then run: pygenkit inspect")

pygenkit/cli/commands/inspect.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from pygenkit.inspector.api import inspect_project
+
+
+def _fmt(val: object) -> str:
+    if val is None:
+        return "—"
+    return str(val)
+
+
+def inspect_cmd() -> None:
+    """Analyze project structure, versions, and metadata."""
+    project_dir = Path.cwd()
+
+    typer.echo(f"  Inspecting {project_dir}")
+    typer.echo("")
+
+    result = inspect_project(project_dir)
+
+    typer.echo(f"  Project:       {_fmt(result.name)}")
+    typer.echo(f"  Version:       {_fmt(result.version)}")
+    typer.echo(f"  Module:        {_fmt(result.module)}")
+    backend = result.build_backend
+    typer.echo(f"  Build backend: {_fmt(backend.name if backend else None)}")
+    typer.echo(f"  Python req:    {_fmt(result.python_requires)}")
+    typer.echo(f"  License:       {_fmt(result.license_type)}")
+    typer.echo(f"  Tests:         {'yes' if result.has_tests else 'no'}")
+    typer.echo(f"  Debian:        {'yes' if result.has_debian.present else 'no'}")
+    typer.echo(f"  GitHub:        {_fmt(result.github_remote)}")
+    typer.echo("")
+
+    if result.versions.issues:
+        typer.echo("  Version issues:")
+        for issue in result.versions.issues:
+            typer.echo(f"    \u2717 {issue}")
+
+    if result.warnings:
+        typer.echo("  Warnings:")
+        for w in result.warnings:
+            typer.echo(f"    ! {w}")
+
+    if result.errors:
+        typer.echo("  Errors:")
+        for e in result.errors:
+            typer.echo(f"    \u2717 {e}")
+        raise typer.Exit(code=1)
+
+    typer.echo("")
+    if result.versions.consistent:
+        typer.echo("  Versions: consistent")
+    else:
+        typer.echo("  Versions: inconsistent")
+        raise typer.Exit(code=1)

pygenkit/cli/commands/new.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from pygenkit.generators.project import ProjectGenerator
+
+
+def new_cmd(
+    name: str = typer.Argument(..., help="Project name"),
+    output: Path | None = typer.Option(None, "--output", "-o", help="Output directory"),  # noqa: B008
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing directory"),  # noqa: B008
+) -> None:
+    """Scaffold a new Python project with CI/CD, tests, and tooling ready."""
+    gen = ProjectGenerator()
+    output_dir = output or Path.cwd()
+    try:
+        root = gen.generate(
+            name=name,
+            output_dir=output_dir,
+            force=force,
+        )
+    except FileExistsError as exc:
+        typer.echo(f"  Error: {exc}")
+        raise typer.Exit(code=1) from exc
+
+    typer.echo(f"  Created {root}")
+    typer.echo("")
+    typer.echo("  Next steps:")
+    typer.echo(f"    cd {name}")
+    typer.echo("    git add . && git commit -m 'Initial commit'")
+    typer.echo("    git remote add origin <repo-url>")
+    typer.echo("    git push -u origin main")
+    typer.echo("")
+    typer.echo("  Edit pygenkit.toml with your info, then run:")
+    typer.echo("    pygenkit generate")

pygenkit/cli/commands/publish.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+
+
+def publish_cmd(
+    repository: str = typer.Option("pypi", "--repository", "-r", help="PyPI repository"),  # noqa: B008
+    dist_dir: Path = typer.Option("dist", "--dist", help="Dist directory"),  # noqa: B008
+) -> None:
+    dist_path = Path(dist_dir)
+    if not dist_path.is_dir() or not list(dist_path.glob("*.whl")):
+        typer.echo("No distribution files found. Run 'pygenkit build' first.")
+        raise typer.Exit(code=1)
+
+    result = subprocess.run(
+        [sys.executable, "-m", "twine", "upload", "--repository", repository, f"{dist_path}/*"],
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+
+    if result.returncode != 0:
+        typer.echo(f"Publish failed:\n{result.stderr}")
+        raise typer.Exit(code=1)
+
+    typer.echo("Published to PyPI successfully.")