pc-init 0.1.0__py3-none-any.whl

gpc_init/merger.py

@@ -0,0 +1,148 @@
+"""Merge language and framework presets into a single configuration dict."""
+
+from typing import Any
+
+
+def _repo_key(repo_entry: dict[str, Any]) -> tuple[str, str]:
+    """Return a (repo, rev) identity key for a repo entry."""
+    return (str(repo_entry.get("repo", "")), str(repo_entry.get("rev", "")))
+
+
+def _merge_hook(lower: dict[str, Any], higher: dict[str, Any]) -> dict[str, Any]:
+    """
+    Merge two hook dicts: higher-precedence fields replace lower-precedence fields.
+
+    The hook id and position come from the lower layer; all other fields from
+    the higher layer override the lower layer.
+    """
+    return {**lower, **higher}
+
+
+def _merge_hooks_list(
+    lower: list[dict[str, Any]], higher: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
+    """
+    Merge two hook lists by hook id.
+
+    - Preserves first-seen order from the lower-precedence layer.
+    - Appends new hook ids from the higher-precedence layer.
+    - When the same hook id appears in both, higher-precedence fields
+      replace lower fields.
+    """
+    result: list[dict[str, Any]] = []
+    lower_by_id: dict[str, int] = {}
+    for i, hook in enumerate(lower):
+        hook_id = str(hook.get("id", ""))
+        lower_by_id[hook_id] = i
+        result.append(dict(hook))
+
+    for hook in higher:
+        hook_id = str(hook.get("id", ""))
+        if hook_id in lower_by_id:
+            idx = lower_by_id[hook_id]
+            result[idx] = _merge_hook(result[idx], hook)
+        else:
+            result.append(dict(hook))
+
+    return result
+
+
+def _merge_repos(
+    lower: list[dict[str, Any]], higher: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
+    """
+    Merge two repos lists by (repo, rev) key.
+
+    - Preserves first-seen order from the lower-precedence layer.
+    - Appends new (repo, rev) pairs from the higher-precedence layer.
+    - When the same (repo, rev) pair appears in both, hooks are merged by hook id.
+    """
+    result: list[dict[str, Any]] = []
+    lower_by_key: dict[tuple[str, str], int] = {}
+    for i, repo in enumerate(lower):
+        key = _repo_key(repo)
+        lower_by_key[key] = i
+        result.append(dict(repo))
+
+    for repo in higher:
+        key = _repo_key(repo)
+        if key in lower_by_key:
+            idx = lower_by_key[key]
+            merged_repo = dict(result[idx])
+            lower_hooks = list(result[idx].get("hooks", []))
+            higher_hooks = list(repo.get("hooks", []))
+            merged_repo["hooks"] = _merge_hooks_list(lower_hooks, higher_hooks)
+            result[idx] = merged_repo
+        else:
+            result.append(dict(repo))
+
+    return result
+
+
+def _deep_merge_top_level(
+    lower: dict[str, Any], higher: dict[str, Any]
+) -> dict[str, Any]:
+    """
+    Deep-merge two top-level dicts (excluding 'repos').
+
+    Higher-precedence values override lower-precedence values on key conflicts.
+    Nested dicts are recursively merged; other types are replaced by higher value.
+    """
+    merged: dict[str, Any] = dict(lower)
+    for key, value in higher.items():
+        if key == "repos":
+            continue
+        if key in merged and isinstance(merged[key], dict) and isinstance(value, dict):
+            merged[key] = _deep_merge_top_level(merged[key], value)
+        else:
+            merged[key] = value
+    return merged
+
+
+def merge_presets(
+    common: dict[str, Any],
+    langs: list[dict[str, Any]],
+    frameworks: list[dict[str, Any]],
+) -> dict[str, Any]:
+    """
+    Merge preset dicts in deterministic order.
+
+    Merge order (lowest to highest precedence):
+    1. Common preset
+    2. Language presets in CLI input order
+    3. Framework presets in CLI input order
+
+    For top-level 'repos' key: entries are merged by (repo, rev) key.
+    For other top-level keys: higher-precedence values override lower.
+    Framework metadata keys (e.g. 'primary_languages') are excluded from output.
+
+    Args:
+        common: Common baseline preset dict.
+        langs: Ordered list of language preset dicts.
+        frameworks: Ordered list of framework preset dicts.
+
+    Returns:
+        Merged configuration dict ready for YAML rendering.
+
+    """
+    layers: list[dict[str, Any]] = [common, *langs, *frameworks]
+    result: dict[str, Any] = {}
+    merged_repos: list[dict[str, Any]] = []
+
+    for layer in layers:
+        if not layer:
+            continue
+        # Merge repos
+        layer_repos: list[dict[str, Any]] = list(layer.get("repos", []))
+        if layer_repos:
+            merged_repos = _merge_repos(merged_repos, layer_repos)
+        # Merge other top-level keys (skip repos and framework metadata)
+        non_repo = {
+            k: v for k, v in layer.items() if k not in ("repos", "primary_languages")
+        }
+        result = _deep_merge_top_level(result, non_repo)
+
+    if merged_repos:
+        result["repos"] = merged_repos
+
+    return result

gpc_init/profiles.py

@@ -0,0 +1,63 @@
+"""Data classes for pc-init profiles and generation entities."""
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class HookConfig:
+    """Individual pre-commit hook item."""
+
+    id: str
+    args: tuple[str, ...] = field(default_factory=tuple)
+    additional_dependencies: tuple[str, ...] = field(default_factory=tuple)
+    stages: tuple[str, ...] = field(default_factory=tuple)
+    extra_fields: dict[str, object] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        """Validate hook fields."""
+        if not self.id:
+            msg = "HookConfig.id must be non-empty"
+            raise ValueError(msg)
+
+
+@dataclass(frozen=True)
+class RepoConfig:
+    """A pre-commit repository entry."""
+
+    repo: str
+    hooks: tuple[HookConfig, ...] = field(default_factory=tuple)
+    rev: str = ""
+
+    def __post_init__(self) -> None:
+        """Validate repo fields."""
+        if not self.repo:
+            msg = "RepoConfig.repo must be non-empty"
+            raise ValueError(msg)
+        if not self.hooks:
+            msg = "RepoConfig.hooks must contain at least one hook"
+            raise ValueError(msg)
+
+
+@dataclass(frozen=True)
+class GenerationRequest:
+    """User request parsed from CLI."""
+
+    langs: tuple[str, ...] = field(default_factory=tuple)
+    frameworks: tuple[str, ...] = field(default_factory=tuple)
+    force: bool = False
+    target_path: str = ".pre-commit-config.yaml"
+
+    def __post_init__(self) -> None:
+        """Validate generation request fields."""
+        if not self.langs:
+            msg = "GenerationRequest.langs must be non-empty"
+            raise ValueError(msg)
+
+
+@dataclass(frozen=True)
+class GenerationResult:
+    """Deterministic rendering and write outcome."""
+
+    content: str
+    path: str
+    overwritten: bool = False

gpc_init/renderer.py

@@ -0,0 +1,28 @@
+"""Render merged configuration dict to YAML string."""
+
+from typing import Any
+
+import yaml
+
+
+def render_yaml(merged_dict: dict[str, Any]) -> str:
+    """
+    Render a merged configuration dict to a deterministic YAML string.
+
+    Uses yaml.dump with stable key ordering and block style for readability.
+    The output is compatible with pre-commit's expected .pre-commit-config.yaml format.
+
+    Args:
+        merged_dict: Merged configuration dictionary to render.
+
+    Returns:
+        UTF-8 YAML string suitable for writing to .pre-commit-config.yaml.
+
+    """
+    return yaml.dump(
+        merged_dict,
+        default_flow_style=False,
+        sort_keys=True,
+        allow_unicode=True,
+        width=4096,
+    )

gpc_init/resolver.py

@@ -0,0 +1,155 @@
+"""Resolve and validate generation requests against the preset catalog."""
+
+from pathlib import Path
+from typing import Any
+
+from gpc_init.exceptions import UnsupportedFrameworkError, UnsupportedLanguageError
+
+# Language name aliases -> canonical id
+_LANG_ALIASES: dict[str, str] = {
+    "python": "py",
+    "javascript": "js",
+    "rust": "ru",
+    "golang": "go",
+}
+
+# Default base directory for preset discovery.
+# 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 _discover_languages(base_dir: Path) -> list[str]:
+    """Scan lang/<lang>/baseline.yaml and return sorted list of language ids."""
+    lang_dir = base_dir / "lang"
+    if not lang_dir.is_dir():
+        return []
+    return sorted(
+        d.name
+        for d in lang_dir.iterdir()
+        if d.is_dir() and d.name != "common" and (d / "baseline.yaml").exists()
+    )
+
+
+def _discover_frameworks(base_dir: Path) -> list[str]:
+    """Scan framework/<fw>/preset.yaml and return sorted list of framework ids."""
+    fw_dir = base_dir / "framework"
+    if not fw_dir.is_dir():
+        return []
+    return sorted(
+        d.name for d in fw_dir.iterdir() if d.is_dir() and (d / "preset.yaml").exists()
+    )
+
+
+def normalize_lang(lang: str) -> str:
+    """Normalize a language value: lowercase and resolve aliases to canonical id."""
+    normalized = lang.strip().lower()
+    return _LANG_ALIASES.get(normalized, normalized)
+
+
+def normalize_framework(fw: str) -> str:
+    """Normalize a framework value: lowercase and strip whitespace."""
+    return fw.strip().lower()
+
+
+def deduplicate_preserving_order(values: list[str]) -> list[str]:
+    """Remove duplicate values from a list, preserving first-occurrence order."""
+    seen: set[str] = set()
+    result: list[str] = []
+    for v in values:
+        if v not in seen:
+            seen.add(v)
+            result.append(v)
+    return result
+
+
+def get_supported_languages(base_dir: Path | None = None) -> list[str]:
+    """
+    Return sorted list of supported language ids discovered from the filesystem.
+
+    Args:
+        base_dir: Override base directory for preset discovery (used in tests).
+
+    """
+    return _discover_languages(_resolve_base(base_dir))
+
+
+def get_supported_frameworks(base_dir: Path | None = None) -> list[str]:
+    """
+    Return sorted list of supported framework ids discovered from the filesystem.
+
+    Args:
+        base_dir: Override base directory for preset discovery (used in tests).
+
+    """
+    return _discover_frameworks(_resolve_base(base_dir))
+
+
+def validate_langs(langs: list[str], base_dir: Path | None = None) -> None:
+    """
+    Validate that all requested language ids are supported.
+
+    Args:
+        langs: Normalized language ids to validate.
+        base_dir: Override base directory for preset discovery (used in tests).
+
+    Raises:
+        UnsupportedLanguageError: If any language is not in the catalog.
+
+    """
+    supported = get_supported_languages(base_dir)
+    for lang in langs:
+        if lang not in supported:
+            raise UnsupportedLanguageError(lang, supported)
+
+
+def validate_frameworks(frameworks: list[str], base_dir: Path | None = None) -> None:
+    """
+    Validate that all requested framework ids are supported.
+
+    Args:
+        frameworks: Normalized framework ids to validate.
+        base_dir: Override base directory for preset discovery (used in tests).
+
+    Raises:
+        UnsupportedFrameworkError: If any framework is not in the catalog.
+
+    """
+    supported = get_supported_frameworks(base_dir)
+    for fw in frameworks:
+        if fw not in supported:
+            raise UnsupportedFrameworkError(fw, supported)
+
+
+def get_primary_languages_info(
+    frameworks: list[str],
+    framework_presets: list[dict[str, Any]],
+    selected_langs: list[str],
+) -> str | None:
+    """
+    Return a message if selected langs don't match a framework's primary_languages.
+
+    This is purely informational and non-blocking.
+
+    Args:
+        frameworks: Normalized framework ids.
+        framework_presets: Loaded framework preset dicts.
+        selected_langs: Normalized selected language ids.
+
+    Returns:
+        Informational message string, or None if no mismatch.
+
+    """
+    messages: list[str] = []
+    for fw_id, fw_preset in zip(frameworks, framework_presets, strict=True):
+        primary = fw_preset.get("primary_languages", [])
+        if primary and not any(lang in primary for lang in selected_langs):
+            primary_str = ", ".join(primary)
+            messages.append(
+                f"Note: framework '{fw_id}' is typically used with: {primary_str}"
+            )
+    return "\n".join(messages) if messages else None