pc-init 0.1.0__py3-none-any.whl

gpc_init/__init__.py

@@ -0,0 +1 @@
+"""pc-init: Generate .pre-commit-config.yaml from language and framework presets."""

gpc_init/about.py

@@ -0,0 +1,3 @@
+"""Provide the version of this package."""
+
+__version__ = "0.1.0"

gpc_init/cli.py

@@ -0,0 +1,204 @@
+"""pc-init CLI: Generate .pre-commit-config.yaml from language and framework presets."""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from gpc_init import fetcher
+from gpc_init.exceptions import (
+    PresetFetchError,
+    PresetNotFoundError,
+    PresetParseError,
+    UnsupportedFrameworkError,
+    UnsupportedLanguageError,
+)
+from gpc_init.loader import (
+    load_common_preset,
+    load_framework_preset,
+    load_language_preset,
+)
+from gpc_init.merger import merge_presets
+from gpc_init.renderer import render_yaml
+from gpc_init.resolver import (
+    deduplicate_preserving_order,
+    get_primary_languages_info,
+    normalize_framework,
+    normalize_lang,
+    validate_frameworks,
+    validate_langs,
+)
+
+
+def _run(
+    langs: list[str],
+    frameworks: list[str],
+    target: Path,
+    base_dir: Path | None,
+) -> None:
+    """Validate, load, merge, render, and write the preset config."""
+    if base_dir is not None and not (base_dir / "lang").is_dir():
+        typer.echo(f"Error: '{base_dir}' must contain a 'lang' subdirectory.", err=True)
+        raise typer.Exit(code=1)
+
+    try:
+        validate_langs(langs, base_dir=base_dir)
+        validate_frameworks(frameworks, base_dir=base_dir)
+
+        common = load_common_preset(base_dir=base_dir)
+        lang_presets = [
+            load_language_preset(lang_id, base_dir=base_dir) for lang_id in langs
+        ]
+        fw_presets = [
+            load_framework_preset(fw_id, base_dir=base_dir) for fw_id in frameworks
+        ]
+
+        merged = merge_presets(common, lang_presets, fw_presets)
+        content = render_yaml(merged)
+
+        overwritten = target.exists()
+        try:
+            target.write_text(content, encoding="utf-8")
+        except (PermissionError, OSError) as exc:
+            typer.echo(f"Error: cannot write to '{target}': {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+
+        info = get_primary_languages_info(frameworks, fw_presets, langs)
+        if info:
+            typer.echo(info)
+
+        lang_str = ", ".join(langs)
+        fw_str = (", ".join(frameworks)) if frameworks else "none"
+        action = "Overwrote" if overwritten else "Generated"
+        typer.echo(
+            f"{action} {target} with languages: {lang_str} and frameworks: {fw_str}"
+        )
+
+    except UnsupportedLanguageError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    except UnsupportedFrameworkError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    except PresetNotFoundError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    except PresetParseError as exc:
+        typer.echo(f"Error: failed to parse preset YAML: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+
+app = typer.Typer(
+    name="pc-init",
+    help="Generate a .pre-commit-config.yaml for your project.",
+    add_completion=False,
+)
+
+
+def _normalize_langs(raw_langs: list[str]) -> list[str]:
+    """Lowercase, resolve aliases, and deduplicate language values."""
+    return deduplicate_preserving_order([normalize_lang(v) for v in raw_langs])
+
+
+def _normalize_frameworks(raw_frameworks: list[str]) -> list[str]:
+    """Lowercase and deduplicate framework values."""
+    return deduplicate_preserving_order(
+        [normalize_framework(v) for v in raw_frameworks]
+    )
+
+
+@app.command()
+def main(
+    lang: Annotated[
+        list[str],
+        typer.Option(
+            "--lang",
+            help="Language preset to include (repeatable). "
+            "Run without --lang to see supported values from the active catalog.",
+        ),
+    ],
+    framework: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--framework",
+            help="Framework preset to layer on top of language baselines (repeatable). "
+            "Run without --framework to see supported values from the active catalog.",
+        ),
+    ] = None,
+    force: Annotated[
+        bool,
+        typer.Option(
+            "--force",
+            help="Overwrite existing .pre-commit-config.yaml without prompting.",
+        ),
+    ] = False,
+    output: Annotated[
+        str,
+        typer.Option(
+            "--output",
+            help="Output file path. Defaults to .pre-commit-config.yaml.",
+        ),
+    ] = ".pre-commit-config.yaml",
+    presets: Annotated[
+        str | None,
+        typer.Option(
+            "--presets",
+            help=(
+                "Preset catalog to use. Accepts a local directory path or a git "
+                "repository URL (https://, git@, git://, ssh://). The directory / "
+                "repo root must contain lang/ and framework/ subdirectories. "
+                "Defaults to the bundled presets."
+            ),
+        ),
+    ] = None,
+) -> None:
+    """
+    Generate a .pre-commit-config.yaml from language and optional framework presets.
+
+    At least one --lang value is required. --framework values are optional.
+    Use --force to overwrite an existing config file.
+    """
+    raw_frameworks: list[str] = framework or []
+
+    # Normalize and deduplicate
+    langs = _normalize_langs(lang)
+    frameworks = _normalize_frameworks(raw_frameworks)
+
+    # Check existing file before any I/O
+    target = Path(output)
+    if target.exists() and not force:
+        typer.echo(
+            f"Error: '{target}' already exists. Use --force to overwrite.", err=True
+        )
+        raise typer.Exit(code=1)
+
+    # Resolve preset catalog
+    if presets is not None and not fetcher.is_git_url(presets):
+        local_dir = Path(presets)
+        if not local_dir.is_dir():
+            typer.echo(
+                f"Error: presets directory '{local_dir}' does not exist.", err=True
+            )
+            raise typer.Exit(code=1)
+        _run(langs, frameworks, target, local_dir)
+    elif presets is not None:
+        try:
+            with fetcher.fetch_preset_repo(presets) as cloned:
+                _run(langs, frameworks, target, cloned)
+        except PresetFetchError as exc:
+            typer.echo(f"Error: {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+    else:
+        _run(langs, frameworks, target, None)
+
+
+def entry_point() -> None:
+    """Entry point for the pc-init command."""
+    app()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app()

gpc_init/exceptions.py

@@ -0,0 +1,49 @@
+"""Custom exceptions for pc-init."""
+
+
+class PresetNotFoundError(Exception):
+    """Raised when a preset file is not found on the filesystem."""
+
+
+class PresetParseError(Exception):
+    """Raised when a preset file contains invalid YAML or unexpected structure."""
+
+
+class UnsupportedLanguageError(Exception):
+    """Raised when a requested language is not in the language catalog."""
+
+    def __init__(self, lang: str, supported: list[str]) -> None:
+        """Initialize with the unsupported language and supported language list."""
+        self.lang = lang
+        self.supported = supported
+        supported_str = ", ".join(sorted(supported))
+        super().__init__(f"Unsupported language '{lang}'. Supported: {supported_str}")
+
+
+class UnsupportedFrameworkError(Exception):
+    """Raised when a requested framework is not in the framework catalog."""
+
+    def __init__(self, fw: str, supported: list[str]) -> None:
+        """Initialize with the unsupported framework and supported framework list."""
+        self.fw = fw
+        self.supported = supported
+        supported_str = ", ".join(sorted(supported))
+        super().__init__(f"Unsupported framework '{fw}'. Supported: {supported_str}")
+
+
+class TargetFileExistsError(Exception):
+    """Raised when target file already exists and --force was not provided."""
+
+    def __init__(self, path: str) -> None:
+        """Initialize with the path that already exists."""
+        self.path = path
+        super().__init__(f"'{path}' already exists. Use --force to overwrite.")
+
+
+class PresetFetchError(Exception):
+    """Raised when a remote preset repository cannot be fetched."""
+
+    def __init__(self, url: str, detail: str) -> None:
+        """Initialize with the URL that failed and the reason."""
+        self.url = url
+        super().__init__(f"Failed to fetch presets from '{url}': {detail}")

gpc_init/fetcher.py

@@ -0,0 +1,63 @@
+"""Fetch preset catalogs from remote git repositories."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from gpc_init.exceptions import PresetFetchError
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+_GIT_URL_PREFIXES = ("https://", "git@", "git://", "ssh://")
+
+
+def is_git_url(value: str) -> bool:
+    """Return True if value looks like a git repository URL rather than a local path."""
+    if Path(value).exists():
+        return False
+    return value.startswith(_GIT_URL_PREFIXES) or value.endswith(".git")
+
+
+@contextmanager
+def fetch_preset_repo(url: str) -> Generator[Path]:
+    """
+    Shallow-clone a git repository and yield the path to the clone root.
+
+    The temporary directory is removed on exit regardless of success or failure.
+
+    Args:
+        url: Git repository URL (https://, git@, git://, or ssh://).
+
+    Yields:
+        Path to the root of the cloned repository.
+
+    Raises:
+        PresetFetchError: If git is not installed or the clone fails.
+
+    """
+    git = shutil.which("git")
+    if git is None:
+        msg = "git is not installed or not on PATH"
+        raise PresetFetchError(url, msg)
+
+    with tempfile.TemporaryDirectory(prefix="gpc-init-presets-") as tmp:
+        try:
+            subprocess.run(  # noqa: S603
+                [git, "clone", "--depth=1", "--", url, tmp],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+        except subprocess.CalledProcessError as exc:
+            detail = (exc.stderr or exc.stdout or "unknown error").strip()
+            raise PresetFetchError(url, detail) from exc
+        except OSError as exc:
+            msg = f"Failed to execute git: {exc}"
+            raise PresetFetchError(url, msg) from exc
+        yield Path(tmp)

gpc_init/framework/bevy/preset.yaml

@@ -0,0 +1,13 @@
+primary_languages:
+  - ru
+repos:
+  - repo: https://github.com/nickel-lang/nickel-pre-commit
+    rev: v0.1.0
+    hooks:
+      - id: bevy-lint
+        name: bevy-lint
+        description: run bevy-lint to check Bevy ECS usage patterns
+        entry: bevy-lint
+        language: rust
+        types:
+          - rust

gpc_init/framework/django/preset.yaml

@@ -0,0 +1,8 @@
+primary_languages:
+  - py
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: name-tests-test
+        args: ['--django']

gpc_init/framework/react/preset.yaml

@@ -0,0 +1,15 @@
+primary_languages:
+  - js
+repos:
+  - repo: local
+    hooks:
+      - id: eslint-react
+        name: eslint (react)
+        description: lint JavaScript/React files with eslint and react-hooks plugin
+        entry: npx eslint --fix
+        files: \.(jsx?|tsx?)$
+        language: node
+        additional_dependencies:
+          - eslint@9.28.0
+          - eslint-plugin-react@7.37.5
+          - eslint-plugin-react-hooks@5.2.0

gpc_init/lang/common/default.yaml

@@ -0,0 +1,23 @@
+repos:
+  - repo: meta
+    hooks:
+      - id: check-useless-excludes
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: check-added-large-files
+      - id: check-docstring-first
+      - id: check-json
+      - id: check-merge-conflict
+      - id: check-toml
+      - id: check-vcs-permalinks
+      - id: check-xml
+      - id: check-yaml
+      - id: debug-statements
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+      - id: name-tests-test
+      - id: no-commit-to-branch
+      - id: pretty-format-json
+      - id: requirements-txt-fixer
+      - id: trailing-whitespace

gpc_init/lang/go/baseline.yaml

@@ -0,0 +1,5 @@
+repos:
+  - repo: https://github.com/crate-ci/typos
+    rev: v1
+    hooks:
+      - id: typos

gpc_init/lang/js/baseline.yaml

@@ -0,0 +1,14 @@
+repos:
+  - repo: local
+    hooks:
+      - id: prettier
+        name: run prettier
+        description: format files with prettier
+        entry: prettier --write '**/*.js' '**/*.yaml' '**/*.yml'
+        files: \.(js|ya?ml)$
+        language: node
+        additional_dependencies: ['prettier@3.6.2']
+  - repo: https://github.com/crate-ci/typos
+    rev: v1
+    hooks:
+      - id: typos

gpc_init/lang/md/baseline.yaml

@@ -0,0 +1,9 @@
+repos:
+  - repo: https://github.com/rvben/rumdl-pre-commit
+    rev: v0.2.0
+    hooks:
+      - id: rumdl-fmt
+  - repo: https://github.com/crate-ci/typos
+    rev: v1
+    hooks:
+      - id: typos

gpc_init/lang/py/baseline.yaml

@@ -0,0 +1,38 @@
+repos:
+  - repo: https://github.com/MarcoGorelli/absolufy-imports
+    rev: v0.3.1
+    hooks:
+      - id: absolufy-imports
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.12
+    hooks:
+      - id: ruff-check
+      - id: ruff-format
+  - repo: https://github.com/abravalheri/validate-pyproject
+    rev: v0.25
+    hooks:
+      - id: validate-pyproject
+  - repo: https://github.com/kieran-ryan/pyprojectsort
+    rev: v0.4.0
+    hooks:
+      - id: pyprojectsort
+  - repo: https://github.com/adamchainz/blacken-docs
+    rev: 1.20.0
+    hooks:
+      - id: blacken-docs
+  - repo: https://github.com/crate-ci/typos
+    rev: v1
+    hooks:
+      - id: typos
+  - repo: https://github.com/facebook/pyrefly-pre-commit
+    rev: v0.42.0
+    hooks:
+      - id: pyrefly-check
+  - repo: https://github.com/astral-sh/ty-pre-commit
+    rev: v0.0.51
+    hooks:
+      - id: ty
+  - repo: https://github.com/rohaquinlop/complexipy-pre-commit
+    rev: v5.1.0
+    hooks:
+      - id: complexipy

gpc_init/lang/ru/baseline.yaml

@@ -0,0 +1,28 @@
+repos:
+  - repo: https://github.com/doublify/pre-commit-rust
+    rev: v1.0
+    hooks:
+      - id: cargo-check
+        args:
+          - --workspace
+      - id: clippy
+        args:
+          - --
+          - -D
+          - warnings
+      - id: fmt
+        args:
+          - --
+          - --check
+  - repo: https://github.com/nim65s/pre-commit-sort
+    rev: v1.0.0
+    hooks:
+      - id: pre-commit-sort
+  - repo: https://github.com/crate-ci/typos
+    rev: v1
+    hooks:
+      - id: typos
+  - repo: https://github.com/rvben/rumdl-pre-commit
+    rev: v0.2.0
+    hooks:
+      - id: rumdl-fmt

gpc_init/lang/yaml/baseline.yaml

@@ -0,0 +1,6 @@
+repos:
+  - repo: https://github.com/owenlamont/ryl-pre-commit
+    # Match the latest ryl release tag.
+    rev: v0.19.1
+    hooks:
+      - id: ryl

gpc_init/loader.py

@@ -0,0 +1,93 @@
+"""Load language and framework presets from the filesystem."""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from gpc_init.exceptions import PresetNotFoundError, PresetParseError
+
+# Base directory containing lang/ and framework/ preset folders.
+# In development the symlinks gpc_init/lang -> ../lang resolve here; when installed
+# from a wheel the real copies are present at the same location.
+_DEFAULT_PRESETS_BASE = Path(__file__).parent
+
+
+def _resolve_base(base_dir: Path | None) -> Path:
+    return base_dir if base_dir is not None else _DEFAULT_PRESETS_BASE
+
+
+def _load_yaml_file(path: Path) -> dict[str, Any]:
+    """Load and parse a YAML file, raising structured errors on failure."""
+    if not path.exists():
+        msg = f"Preset file not found: {path}"
+        raise PresetNotFoundError(msg)
+    try:
+        with path.open(encoding="utf-8") as fh:
+            data = yaml.safe_load(fh)
+    except yaml.YAMLError as exc:
+        msg = f"Failed to parse preset YAML '{path}': {exc}"
+        raise PresetParseError(msg) from exc
+    if data is None:
+        data = {}
+    if not isinstance(data, dict):
+        msg = (
+            f"Preset file '{path}' must contain a YAML mapping,"
+            f" got {type(data).__name__}"
+        )
+        raise PresetParseError(msg)
+    return data
+
+
+def load_common_preset(base_dir: Path | None = None) -> dict[str, Any]:
+    """
+    Load the common baseline preset (lang/common/default.yaml).
+
+    Returns an empty dict if the file does not exist.
+    """
+    path = _resolve_base(base_dir) / "lang" / "common" / "default.yaml"
+    if not path.exists():
+        return {}
+    return _load_yaml_file(path)
+
+
+def load_language_preset(lang_id: str, base_dir: Path | None = None) -> dict[str, Any]:
+    """
+    Load the baseline preset for a language (lang/<lang_id>/baseline.yaml).
+
+    Args:
+        lang_id: Canonical language identifier (e.g. 'py', 'js', 'go', 'ru').
+        base_dir: Override base directory for presets (used in tests).
+
+    Returns:
+        Parsed preset as a dictionary.
+
+    Raises:
+        PresetNotFoundError: If the preset file does not exist.
+        PresetParseError: If the YAML is invalid or not a mapping.
+
+    """
+    return _load_yaml_file(_resolve_base(base_dir) / "lang" / lang_id / "baseline.yaml")
+
+
+def load_framework_preset(
+    framework_id: str, base_dir: Path | None = None
+) -> dict[str, Any]:
+    """
+    Load the preset for a framework (framework/<framework_id>/preset.yaml).
+
+    Args:
+        framework_id: Canonical framework identifier (e.g. 'react', 'bevy').
+        base_dir: Override base directory for presets (used in tests).
+
+    Returns:
+        Parsed preset as a dictionary.
+
+    Raises:
+        PresetNotFoundError: If the preset file does not exist.
+        PresetParseError: If the YAML is invalid or not a mapping.
+
+    """
+    return _load_yaml_file(
+        _resolve_base(base_dir) / "framework" / framework_id / "preset.yaml"
+    )