pygenkit 0.2.0__py3-none-any.whl

pygenkit/cli/commands/release.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from pygenkit.config.loader import ConfigLoader
+from pygenkit.services.release import ReleaseService
+
+
+def release_cmd(
+    config: Path = typer.Option("pygenkit.yaml", "--config", "-c", help="Config file"),  # noqa: B008
+    dry_run: bool = typer.Option(False, "--dry-run", "-n", help="Print actions without executing"),  # noqa: B008
+    bump: str = typer.Option("patch", "--bump", help="Version bump: patch, minor, major"),  # noqa: B008
+) -> None:
+    config_path = Path(config)
+    if not config_path.exists():
+        typer.echo(f"Config file not found: {config_path}")
+        raise typer.Exit(code=1)
+
+    proj_config = ConfigLoader.load(config_path)
+    service = ReleaseService(proj_config)
+
+    if dry_run:
+        service.dry_run(bump)
+    else:
+        result = service.run(bump)
+        typer.echo(f"Tag created: {result['tag']}")
+        typer.echo(f"Version: {result['version']}")
+        if result.get("pushed"):
+            typer.echo("Changes pushed to remote.")
+            msg = "GitHub Actions will handle PyPI publish, GitHub Release, and Launchpad upload."
+            typer.echo(msg)

pygenkit/cli/commands/release_check.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+
+def release_check_cmd(
+    config: Path = typer.Option("pygenkit.toml", "--config", "-c", help="Config file"),  # noqa: B008
+) -> None:
+    """Verify that the project is ready for release."""
+    if not config.exists():
+        typer.echo(f"  Config not found: {config}")
+        typer.echo("  Run: pygenkit init <name>")
+        raise typer.Exit(code=1)
+
+    typer.echo("  [release-check] Readiness check coming in Stage 5.")

pygenkit/cli/commands/review.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from pygenkit.ai.review import get_pr_diff, get_pr_diff_from_file, review_diff
+
+
+def review_cmd(
+    pr: str = typer.Argument("", help="PR number (e.g. 42) or path to diff file"),  # noqa: B008
+    repo: str = typer.Option("", "--repo", help="GitHub repo (owner/repo)"),  # noqa: B008
+    model: str = typer.Option("gpt-4o-mini", "--model", "-m", help="LLM model"),  # noqa: B008
+    dry_run: bool = typer.Option(False, "--dry-run", "-n", help="Show diff without reviewing"),  # noqa: B008
+) -> None:
+    """Review a GitHub PR diff using AI."""
+    diff: str = ""
+
+    if not pr:
+        typer.echo("  Error: PR number or path to diff file required")
+        raise typer.Exit(code=1)
+
+    diff_path = Path(pr)
+    if diff_path.exists():
+        diff = get_pr_diff_from_file(diff_path)
+        source = pr
+    else:
+        try:
+            diff = get_pr_diff(pr, repo or None)
+            source = f"PR #{pr}" + (f" ({repo})" if repo else "")
+        except RuntimeError as exc:
+            typer.echo(f"  Error: {exc}")
+            raise typer.Exit(code=1) from exc
+
+    if not diff.strip():
+        typer.echo("  Empty diff — nothing to review.")
+        return
+
+    if dry_run:
+        typer.echo(f"  Diff from {source}:")
+        typer.echo("")
+        typer.echo(diff[:2000] + ("..." if len(diff) > 2000 else ""))
+        return
+
+    typer.echo(f"  Reviewing {source}...")
+    typer.echo("")
+
+    try:
+        result = review_diff(diff, filename_hint=source, model=model)
+    except ValueError as exc:
+        typer.echo(f"  Error: {exc}")
+        raise typer.Exit(code=1) from exc
+
+    if result.error:
+        typer.echo(f"  Review failed: {result.error}")
+        raise typer.Exit(code=1)
+
+    typer.echo(result.raw)

pygenkit/cli/commands/validate.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import typer
+
+from pygenkit.validators.api import has_errors, validate_project
+
+
+def validate_cmd() -> None:
+    """Check version consistency, workflow quality, and security."""
+    project_dir = "."
+
+    results = validate_project(project_dir)
+
+    if not results:
+        typer.echo("  No issues found.")
+        return
+
+    categories = {"version": "Version", "workflow": "Workflow", "security": "Security"}
+    for cat_key, cat_label in categories.items():
+        cat_issues = [r["message"] for r in results if r["category"] == cat_key]
+        if cat_issues:
+            typer.echo(f"  {cat_label}:")
+            for msg in cat_issues:
+                typer.echo(f"    \u2717 {msg}")
+
+    if has_errors(results):
+        typer.echo("")
+        typer.echo("  Validation failed.")
+        raise typer.Exit(code=1)

pygenkit/cli.py

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

pygenkit/config/__init__.py

@@ -0,0 +1,3 @@
+from pygenkit.models.config import PyGenKitConfig
+
+__all__ = ["PyGenKitConfig"]

pygenkit/generators/__init__.py

@@ -0,0 +1,13 @@
+from pygenkit.generators.deploy import DeployGenerator
+from pygenkit.generators.docker import DockerGenerator
+from pygenkit.generators.github_actions import GitHubActionsGenerator
+from pygenkit.generators.orchestrator import generate_all
+from pygenkit.generators.project import ProjectGenerator
+
+__all__ = [
+    "GitHubActionsGenerator",
+    "DockerGenerator",
+    "DeployGenerator",
+    "ProjectGenerator",
+    "generate_all",
+]

pygenkit/generators/base.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pygenkit.render.engine import RenderEngine
+
+
+class BaseGenerator:
+    def __init__(self, subdir: str) -> None:
+        templates_dir = Path(__file__).resolve().parent.parent / "templates" / subdir
+        self._engine = RenderEngine(templates_dir)
+
+    def render(
+        self,
+        template_name: str,
+        output_dir: str | Path,
+        output_name: str,
+        context: dict[str, Any],
+        force: bool = False,
+    ) -> Path | None:
+        out = Path(output_dir) / output_name
+        if out.exists() and not force:
+            return None
+        return self._engine.render_to_file(template_name, out, context)
+
+    def list_templates(self) -> list[str]:
+        d = Path(self._engine.templates_dir)
+        if not d.is_dir():
+            return []
+        return sorted(f.name for f in d.glob("**/*.j2"))

pygenkit/generators/deploy.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pygenkit.generators.base import BaseGenerator
+from pygenkit.models.config import PyGenKitConfig
+
+
+class DeployGenerator(BaseGenerator):
+    def __init__(self) -> None:
+        super().__init__("deploy")
+
+    def generate(
+        self,
+        config: PyGenKitConfig,
+        output_dir: str | Path,
+        force: bool = False,
+    ) -> list[Path]:
+        generated: list[Path] = []
+        ctx = self._build_context(config)
+
+        targets = {
+            "fly.toml": ("fly.toml.j2", config.deploy.fly),
+            "Procfile": ("Procfile.j2", config.deploy.heroku),
+            "railway.json": ("railway.json.j2", config.deploy.railway),
+        }
+
+        for out_name, (template, enabled) in targets.items():
+            if not enabled:
+                continue
+            out = self.render(template, output_dir, out_name, ctx, force=force)
+            if out is not None:
+                generated.append(out)
+
+        return generated
+
+    def _build_context(self, config: PyGenKitConfig) -> dict[str, Any]:
+        return {
+            "project": {"name": config.project.name},
+            "deploy": {
+                "primary_region": config.deploy.primary_region,
+                "port": config.deploy.port,
+                "memory": config.deploy.memory,
+                "cpu_kind": config.deploy.cpu_kind,
+                "cpus": config.deploy.cpus,
+            },
+        }

pygenkit/generators/docker.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pygenkit.generators.base import BaseGenerator
+from pygenkit.models.config import PyGenKitConfig
+
+
+class DockerGenerator(BaseGenerator):
+    def __init__(self) -> None:
+        super().__init__("docker")
+
+    def generate(
+        self,
+        config: PyGenKitConfig,
+        output_dir: str | Path,
+        force: bool = False,
+    ) -> list[Path]:
+        generated: list[Path] = []
+        ctx = self._build_context(config)
+
+        out = self.render("Dockerfile.j2", output_dir, "Dockerfile", ctx, force=force)
+        if out is not None:
+            generated.append(out)
+
+        out = self.render(
+            "docker-compose.yml.j2", output_dir, "docker-compose.yml", ctx, force=force
+        )
+        if out is not None:
+            generated.append(out)
+
+        return generated
+
+    def _build_context(self, config: PyGenKitConfig) -> dict[str, Any]:
+        return {
+            "project": {"name": config.project.name},
+            "docker": {
+                "base_image": config.docker.base_image,
+                "port": config.docker.port,
+                "volumes": config.docker.volumes,
+            },
+        }

pygenkit/generators/github_actions.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pygenkit.generators.base import BaseGenerator
+from pygenkit.models.config import PyGenKitConfig
+
+
+class GitHubActionsGenerator(BaseGenerator):
+    def __init__(self) -> None:
+        super().__init__("github/workflows")
+
+    def generate(
+        self,
+        config: PyGenKitConfig,
+        output_dir: str | Path,
+        force: bool = False,
+    ) -> list[Path]:
+        generated: list[Path] = []
+        ctx = self._build_context(config)
+        wf_dir = Path(output_dir) / ".github" / "workflows"
+        wf_dir.mkdir(parents=True, exist_ok=True)
+
+        workflows = {
+            "ci.yml": ("ci.yml.j2", config.github.ci),
+            "release.yml": ("release.yml.j2", config.github.release),
+            "publish-pypi.yml": ("publish-pypi.yml.j2", config.github.publish_pypi),
+            "publish-launchpad.yml": (
+                "publish-launchpad.yml.j2",
+                config.github.publish_launchpad,
+            ),
+        }
+
+        for out_name, (template, enabled) in workflows.items():
+            if not enabled:
+                continue
+            out = self.render(template, wf_dir, out_name, ctx, force=force)
+            if out is not None:
+                generated.append(out)
+
+        return generated
+
+    def _build_context(self, config: PyGenKitConfig) -> dict[str, Any]:
+        return {
+            "project": {
+                "name": config.project.name,
+                "extras": config.project.extras,
+            },
+            "ci": {
+                "python_versions": config.ci.python_versions,
+                "runner": config.ci.runner,
+                "lint": config.ci.lint,
+                "type_check": config.ci.type_check,
+            },
+            "release": {
+                "branch": config.release.branch,
+                "tag_prefix": config.release.tag_prefix,
+            },
+            "pypi": {
+                "environment": config.pypi.environment,
+                "trusted_publishing": config.pypi.trusted_publishing,
+            },
+            "debian": {
+                "owner": config.debian.owner,
+                "ppa": config.debian.ppa,
+            },
+        }

pygenkit/generators/orchestrator.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pygenkit.generators.deploy import DeployGenerator
+from pygenkit.generators.docker import DockerGenerator
+from pygenkit.generators.github_actions import GitHubActionsGenerator
+from pygenkit.models.config import PyGenKitConfig
+
+
+def generate_all(
+    config: PyGenKitConfig,
+    output_dir: str | Path = ".",
+    force: bool = False,
+) -> dict[str, list[Path]]:
+    results: dict[str, list[Path]] = {}
+
+    gh = GitHubActionsGenerator()
+    results["github"] = gh.generate(config, output_dir, force=force)
+
+    if config.docker.enabled:
+        dkr = DockerGenerator()
+        results["docker"] = dkr.generate(config, output_dir, force=force)
+    else:
+        results["docker"] = []
+
+    if config.deploy.enabled:
+        dep = DeployGenerator()
+        results["deploy"] = dep.generate(config, output_dir, force=force)
+    else:
+        results["deploy"] = []
+
+    return results

pygenkit/generators/project.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import contextlib
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from pygenkit.generators.base import BaseGenerator
+from pygenkit.models.config import PyGenKitConfig
+from pygenkit.utils.filters import TemplateFilters
+
+
+class ProjectGenerator(BaseGenerator):
+    def __init__(self) -> None:
+        super().__init__("project")
+
+    def generate(
+        self,
+        name: str,
+        output_dir: str | Path = ".",
+        force: bool = False,
+        author_name: str = "",
+        author_email: str = "",
+        github_owner: str = "",
+        description: str = "",
+        version: str = "0.1.0",
+    ) -> Path:
+        root = Path(output_dir).resolve() / name
+        if root.exists() and not force:
+            msg = f"{root} already exists. Use --force to overwrite."
+            raise FileExistsError(msg)
+
+        module_name = TemplateFilters.snake_case(name)
+        author_name = author_name or _git_config("user.name") or "Your Name"
+        author_email = author_email or _git_config("user.email") or "your@email.com"
+        github_owner = github_owner or _git_config("github.user") or "your-username"
+        description = description or f"{name} — generated by PyGenKit"
+        year = datetime.now().year
+
+        ctx: dict[str, Any] = {
+            "project": {
+                "name": name,
+                "version": version,
+                "description": description,
+            },
+            "module_name": module_name,
+            "author": {
+                "name": author_name,
+                "email": author_email,
+            },
+            "github": {
+                "owner": github_owner,
+            },
+            "year": year,
+        }
+
+        files: list[tuple[str, str]] = [
+            ("src/__init__.py", f"src/{module_name}/__init__.py"),
+            ("src/cli.py", f"src/{module_name}/cli.py"),
+            ("tests/__init__.py", "tests/__init__.py"),
+            ("tests/test_cli.py", "tests/test_cli.py"),
+            ("pyproject.toml", "pyproject.toml"),
+            ("README.md", "README.md"),
+            ("LICENSE", "LICENSE"),
+            (".gitignore", ".gitignore"),
+            (".editorconfig", ".editorconfig"),
+            (".pre-commit-config.yaml", ".pre-commit-config.yaml"),
+        ]
+
+        for template_rel, output_rel in files:
+            out = root / output_rel
+            out.parent.mkdir(parents=True, exist_ok=True)
+            self.render(template_rel + ".j2", root, output_rel, ctx, force=True)
+
+        _generate_pygenkit_toml(root, name, github_owner)
+
+        _run_commands(root)
+
+        return root
+
+
+def _git_config(key: str) -> str:
+    try:
+        r = subprocess.run(
+            ["git", "config", "--global", key],
+            capture_output=True, text=True, timeout=5,
+        )
+        return r.stdout.strip() if r.returncode == 0 else ""
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return ""
+
+
+def _generate_pygenkit_toml(root: Path, name: str, github_owner: str) -> None:
+    content = PyGenKitConfig.generate_default(name)
+    toml_path = root / "pygenkit.toml"
+    toml_path.write_text(content, encoding="utf-8")
+
+    if github_owner and github_owner != "your-username":
+        raw = toml_path.read_text(encoding="utf-8")
+        raw = raw.replace('owner = ""', f'owner = "{github_owner}"')
+        toml_path.write_text(raw, encoding="utf-8")
+
+
+def _run_commands(root: Path) -> None:
+    with contextlib.suppress(subprocess.SubprocessError, FileNotFoundError):
+        subprocess.run(
+            ["git", "init"],
+            cwd=str(root), capture_output=True, timeout=10,
+        )

pygenkit/health/__init__.py

@@ -0,0 +1,3 @@
+from pygenkit.health.api import calculate_health
+
+__all__ = ["calculate_health"]

pygenkit/health/api.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pygenkit.health.checks import (
+    check_cicd,
+    check_documentation,
+    check_packaging,
+    check_security,
+    check_structure,
+    check_testing,
+    check_versioning,
+)
+from pygenkit.inspector.pyproject import read_pyproject
+from pygenkit.models.health import HealthReport
+
+
+def calculate_health(root: str | Path = ".") -> HealthReport:
+    root_path = Path(root).resolve()
+    pyproject_data = _safe_read_pyproject(root_path)
+
+    checks = [
+        check_versioning(root_path, pyproject_data),
+        check_testing(root_path),
+        check_documentation(root_path),
+        check_cicd(root_path),
+        check_security(root_path),
+        check_packaging(root_path, pyproject_data),
+        check_structure(root_path),
+    ]
+
+    categories = {c.name.lower(): c for c in checks}
+    weighted_sum = sum(c.score * c.weight for c in checks)
+    total_weight = sum(c.weight for c in checks)
+    final_score = int(round(weighted_sum / total_weight * 100)) if total_weight > 0 else 0
+
+    all_issues: list[str] = []
+    all_suggestions: list[str] = []
+    for c in checks:
+        all_issues.extend(c.issues)
+        for detail in c.details:
+            all_suggestions.append(f"{c.name}: {detail}")
+
+    return HealthReport(
+        score=final_score,
+        categories=categories,
+        issues=all_issues,
+        suggestions=all_suggestions,
+    )
+
+
+def _safe_read_pyproject(root: Path) -> dict[str, Any] | None:
+    try:
+        return read_pyproject(root)
+    except (FileNotFoundError, Exception):
+        return None