@pennyfarthing/core 11.1.1 → 11.2.0

package/pennyfarthing_scripts/git/hooks_installer.py

@@ -0,0 +1,152 @@
+"""
+Git hooks installer — Python replacement for install-git-hooks.sh (145 lines).
+
+Creates .d/ dispatcher directories, symlinks pennyfarthing hooks,
+and migrates existing user hooks.
+
+Usage via CLI:
+    pf git install-hooks
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from pennyfarthing_scripts.common.config import get_project_root
+
+DISPATCHER_MARKER = "pennyfarthing-dispatcher"
+PF_PREFIX = "10"
+MIGRATED_PREFIX = "50"
+
+# Hook source file → git hook name
+HOOKS = [
+    ("pre-commit.sh", "pre-commit"),
+    ("pre-push.sh", "pre-push"),
+    ("post-merge.sh", "post-merge"),
+]
+
+
+def _generate_dispatcher(template_path: Path, hook_name: str) -> str:
+    """Generate a dispatcher script from the template."""
+    template = template_path.read_text()
+    return template.replace("__HOOK_NAME__", hook_name)
+
+
+def install_git_hooks(project_root: Path | None = None) -> int:
+    """Install git hooks with .d/ dispatcher pattern.
+
+    Creates .d/ directories for each hook, installs dispatcher scripts,
+    and symlinks pennyfarthing hooks into the .d/ directories.
+    Existing non-pennyfarthing hooks are migrated into .d/.
+
+    Args:
+        project_root: Project root. Auto-detected if not provided.
+
+    Returns:
+        0 on success, 1 on error
+    """
+    if project_root is None:
+        project_root = get_project_root()
+
+    pf_dist = project_root / "pennyfarthing-dist"
+    if not pf_dist.is_dir():
+        print("Error: This script requires pennyfarthing-dist/ at the project root")
+        print("       End-user projects should use: pennyfarthing init")
+        return 1
+
+    git_dir = project_root / ".git"
+    if not git_dir.is_dir():
+        print("Error: Not a git repository")
+        return 1
+
+    hooks_source = pf_dist / "scripts" / "hooks"
+    hooks_dest = git_dir / "hooks"
+    hooks_dest.mkdir(exist_ok=True)
+
+    dispatcher_template = hooks_source / "dispatcher-template.sh"
+    if not dispatcher_template.is_file():
+        print(f"Error: dispatcher-template.sh not found at {dispatcher_template}")
+        return 1
+
+    print("Installing git hooks with .d/ dispatcher pattern...")
+    print(f"  Source: pennyfarthing-dist/scripts/hooks/")
+    print(f"  Dest:   .git/hooks/")
+    print()
+
+    for source_file, dest_name in HOOKS:
+        source_path = hooks_source / source_file
+        dest_path = hooks_dest / dest_name
+        d_dir = hooks_dest / f"{dest_name}.d"
+        pf_hook_name = f"{PF_PREFIX}-pennyfarthing-{dest_name}.sh"
+        pf_hook_path = d_dir / pf_hook_name
+
+        if not source_path.is_file():
+            print(f"  SKIP {dest_name} (source not found)")
+            continue
+
+        # Create .d/ directory
+        d_dir.mkdir(exist_ok=True)
+
+        # Handle existing hook at dest path
+        if dest_path.exists():
+            if dest_path.is_file():
+                content = dest_path.read_text()
+                if DISPATCHER_MARKER in content:
+                    print(f"  OK   {dest_name} dispatcher (already installed)")
+                elif dest_path.is_symlink():
+                    # Old-style symlink — replace with dispatcher
+                    dest_path.unlink()
+                    dest_path.write_text(_generate_dispatcher(dispatcher_template, dest_name))
+                    dest_path.chmod(0o755)
+                    print(f"  UPD  {dest_name} -> dispatcher")
+                elif "pennyfarthing" in content:
+                    # Old pennyfarthing single-file hook — replace
+                    dest_path.write_text(_generate_dispatcher(dispatcher_template, dest_name))
+                    dest_path.chmod(0o755)
+                    print(f"  UPD  {dest_name} -> dispatcher (was single-file pf hook)")
+                else:
+                    # Non-pennyfarthing hook — migrate into .d/
+                    migrated_name = f"{MIGRATED_PREFIX}-migrated-{dest_name}.sh"
+                    migrated_path = d_dir / migrated_name
+                    if not migrated_path.exists():
+                        dest_path.rename(migrated_path)
+                        migrated_path.chmod(0o755)
+                        print(f"  MIG  {dest_name} -> {dest_name}.d/{migrated_name}")
+                    dest_path.write_text(_generate_dispatcher(dispatcher_template, dest_name))
+                    dest_path.chmod(0o755)
+                    print(f"  NEW  {dest_name} dispatcher")
+            elif dest_path.is_symlink():
+                dest_path.unlink()
+                dest_path.write_text(_generate_dispatcher(dispatcher_template, dest_name))
+                dest_path.chmod(0o755)
+                print(f"  UPD  {dest_name} -> dispatcher")
+        else:
+            # No existing hook — install fresh dispatcher
+            dest_path.write_text(_generate_dispatcher(dispatcher_template, dest_name))
+            dest_path.chmod(0o755)
+            print(f"  NEW  {dest_name} dispatcher")
+
+        # Symlink pennyfarthing hook into .d/
+        # Relative path from .git/hooks/{hook}.d/ to pennyfarthing-dist/scripts/hooks/
+        relative_path = Path("../../../pennyfarthing-dist/scripts/hooks") / source_file
+
+        if pf_hook_path.is_symlink():
+            current_target = pf_hook_path.readlink()
+            if current_target == relative_path:
+                print(f"  OK   {dest_name}.d/{pf_hook_name} (already linked)")
+            else:
+                pf_hook_path.unlink()
+                pf_hook_path.symlink_to(relative_path)
+                print(f"  UPD  {dest_name}.d/{pf_hook_name} -> {relative_path}")
+        elif pf_hook_path.is_file():
+            pf_hook_path.unlink()
+            pf_hook_path.symlink_to(relative_path)
+            print(f"  UPD  {dest_name}.d/{pf_hook_name} -> {relative_path} (was copy)")
+        else:
+            pf_hook_path.symlink_to(relative_path)
+            print(f"  NEW  {dest_name}.d/{pf_hook_name} -> {relative_path}")
+
+    print()
+    print("Done. Verify with: ls -la .git/hooks/*.d/")
+    return 0

package/pennyfarthing_scripts/git/repos.py

@@ -0,0 +1,196 @@
+"""
+Repos.yaml loader — Python replacement for repo-utils.sh (778 lines).
+
+Reads .pennyfarthing/repos.yaml and provides structured access to repo
+configuration: paths, types, branches, build/test commands, dependencies.
+
+Usage:
+    from pennyfarthing_scripts.git.repos import load_repos_config, get_repo_paths
+
+    config = load_repos_config()
+    for name, repo in config.items():
+        print(f"{name}: {repo.path} ({repo.default_branch})")
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from pennyfarthing_scripts.common.config import get_project_root
+
+
+@dataclass
+class RepoConfig:
+    """Configuration for a single repository."""
+
+    name: str
+    path: str  # Relative to project root (e.g., "." or "pennyfarthing")
+    repo_type: str  # "orchestrator", "framework", "api", "ui", etc.
+    default_branch: str  # "main" for trunk-based, "develop" for gitflow
+    branch_strategy: str  # "trunk-based" or "gitflow"
+    description: str = ""
+    language: str = "unknown"
+    test_command: str = ""
+    build_command: str = ""
+    lint_command: str = ""
+    test_filter_flag: str = ""
+    dependencies: list[str] = field(default_factory=list)
+    owns: list[str] = field(default_factory=list)
+    never_edit: list[str] = field(default_factory=list)
+    ui_layer: str = "none"
+
+    @property
+    def is_gitflow(self) -> bool:
+        return self.branch_strategy == "gitflow"
+
+    @property
+    def upstream_ref(self) -> str:
+        """Remote ref to compare against for unpushed commits."""
+        return f"origin/{self.default_branch}"
+
+
+def _parse_repo_entry(name: str, data: dict[str, Any] | None) -> RepoConfig:
+    """Parse a single repo entry from repos.yaml."""
+    if data is None:
+        data = {}
+    return RepoConfig(
+        name=name,
+        path=data.get("path", name),
+        repo_type=data.get("type", "unknown"),
+        default_branch=data.get("default_branch", "main"),
+        branch_strategy=data.get("branch_strategy", "trunk-based"),
+        description=data.get("description", ""),
+        language=data.get("language", "unknown"),
+        test_command=data.get("test_command", ""),
+        build_command=data.get("build_command", ""),
+        lint_command=data.get("lint_command", ""),
+        test_filter_flag=data.get("test_filter_flag", ""),
+        dependencies=data.get("dependencies", []) or [],
+        owns=data.get("owns", []) or [],
+        never_edit=data.get("never_edit", []) or [],
+        ui_layer=data.get("ui_layer", "none"),
+    )
+
+
+def load_repos_config(project_root: Path | None = None) -> dict[str, RepoConfig]:
+    """Load repos.yaml and return a dict of name -> RepoConfig.
+
+    Args:
+        project_root: Project root directory. Auto-detected if not provided.
+
+    Returns:
+        Ordered dict of repo name -> RepoConfig.
+        Empty dict if repos.yaml not found.
+    """
+    if project_root is None:
+        project_root = get_project_root()
+
+    repos_path = project_root / ".pennyfarthing" / "repos.yaml"
+    if not repos_path.exists():
+        return {}
+
+    with open(repos_path) as f:
+        config = yaml.safe_load(f)
+
+    if not config or "repos" not in config:
+        return {}
+
+    repos: dict[str, RepoConfig] = {}
+    for name, data in config["repos"].items():
+        repos[name] = _parse_repo_entry(name, data)
+
+    return repos
+
+
+def get_repo_paths(project_root: Path | None = None) -> list[tuple[str, Path]]:
+    """Get list of (name, absolute_path) tuples for all configured repos.
+
+    Args:
+        project_root: Project root directory. Auto-detected if not provided.
+
+    Returns:
+        List of (repo_name, absolute_path) tuples.
+    """
+    if project_root is None:
+        project_root = get_project_root()
+
+    repos = load_repos_config(project_root)
+    result = []
+    for name, repo in repos.items():
+        abs_path = (project_root / repo.path).resolve()
+        if abs_path.exists():
+            result.append((name, abs_path))
+    return result
+
+
+def get_default_branch(
+    repo_name: str, project_root: Path | None = None
+) -> str:
+    """Get the default branch for a specific repo.
+
+    Args:
+        repo_name: Name of the repo in repos.yaml.
+        project_root: Project root directory. Auto-detected if not provided.
+
+    Returns:
+        Default branch name (e.g., "main" or "develop").
+        Falls back to "main" if repo not found.
+    """
+    repos = load_repos_config(project_root)
+    if repo_name in repos:
+        return repos[repo_name].default_branch
+    return "main"
+
+
+def get_repo_config(
+    repo_name: str, project_root: Path | None = None
+) -> RepoConfig | None:
+    """Get the full config for a specific repo.
+
+    Args:
+        repo_name: Name of the repo in repos.yaml.
+        project_root: Project root directory. Auto-detected if not provided.
+
+    Returns:
+        RepoConfig or None if not found.
+    """
+    repos = load_repos_config(project_root)
+    return repos.get(repo_name)
+
+
+def get_build_order(project_root: Path | None = None) -> list[str]:
+    """Get repos in build/dependency order.
+
+    Uses explicit build_order from repos.yaml if present,
+    otherwise returns repos in definition order.
+
+    Args:
+        project_root: Project root directory. Auto-detected if not provided.
+
+    Returns:
+        List of repo names in build order.
+    """
+    if project_root is None:
+        project_root = get_project_root()
+
+    repos_path = project_root / ".pennyfarthing" / "repos.yaml"
+    if not repos_path.exists():
+        return []
+
+    with open(repos_path) as f:
+        config = yaml.safe_load(f)
+
+    if not config:
+        return []
+
+    if "build_order" in config:
+        return config["build_order"]
+
+    if "repos" in config:
+        return list(config["repos"].keys())
+
+    return []

package/pennyfarthing_scripts/git/status_all.py

@@ -65,12 +65,15 @@ async def _run_git_command(args: list[str], cwd: Path) -> tuple[str, str, int]:
     )
 
 
-async def get_repo_status(name: str, path: Path) -> RepoStatus:
+async def get_repo_status(
+    name: str, path: Path, upstream_ref: str = "origin/develop"
+) -> RepoStatus:
     """Get git status for a single repository.
 
     Args:
         name: Display name for the repo
         path: Path to the repository
+        upstream_ref: Remote ref to compare for unpushed commits (default: origin/develop)
 
     Returns:
         RepoStatus with current branch, changes, and unpushed commits
@@ -124,9 +127,9 @@ async def get_repo_status(name: str, path: Path) -> RepoStatus:
         status_out, _, _ = await _run_git_command(["status", "--short"], path)
         changes = [line for line in status_out.split("\n") if line.strip()]
 
-        # Get unpushed commits (comparing to origin/develop)
+        # Get unpushed commits (comparing to upstream ref)
         unpushed_out, _, unpushed_rc = await _run_git_command(
-            ["log", "origin/develop..HEAD", "--oneline"], path
+            ["log", f"{upstream_ref}..HEAD", "--oneline"], path
         )
         if unpushed_rc == 0 and unpushed_out:
             unpushed_commits = [
@@ -154,11 +157,13 @@ async def get_repo_status(name: str, path: Path) -> RepoStatus:
         )
 
 
-async def get_all_repo_status(repos: Sequence[tuple[str, Path]]) -> list[RepoStatus]:
+async def get_all_repo_status(
+    repos: Sequence[tuple[str, Path, str] | tuple[str, Path]],
+) -> list[RepoStatus]:
     """Get git status for all repos in parallel using asyncio.gather.
 
     Args:
-        repos: Sequence of (name, path) tuples for each repo
+        repos: Sequence of (name, path) or (name, path, upstream_ref) tuples
 
     Returns:
         List of RepoStatus objects in same order as input
@@ -166,7 +171,14 @@ async def get_all_repo_status(repos: Sequence[tuple[str, Path]]) -> list[RepoSta
     if not repos:
         return []
 
-    tasks = [get_repo_status(name, path) for name, path in repos]
+    tasks = []
+    for entry in repos:
+        if len(entry) == 3:
+            name, path, upstream_ref = entry  # type: ignore[misc]
+            tasks.append(get_repo_status(name, path, upstream_ref))
+        else:
+            name, path = entry  # type: ignore[misc]
+            tasks.append(get_repo_status(name, path))
     results = await asyncio.gather(*tasks, return_exceptions=False)
     return list(results)
 
@@ -279,13 +291,17 @@ async def main(brief: bool = False) -> int:
     Returns:
         0 if all repos clean, 1 if any have changes/unpushed
     """
-    from pennyfarthing_scripts.common.config import get_project_root
+    from pennyfarthing_scripts.git.repos import load_repos_config, get_repo_paths
+
+    repos_with_upstream: list[tuple[str, Path, str]] = []
+    repo_paths = get_repo_paths()
+    config = load_repos_config()
 
-    # For now, just check the current project
-    project_root = get_project_root()
-    repos = [("pennyfarthing", project_root)]
+    for name, path in repo_paths:
+        upstream = config[name].upstream_ref if name in config else "origin/develop"
+        repos_with_upstream.append((name, path, upstream))
 
-    statuses = await get_all_repo_status(repos)
+    statuses = await get_all_repo_status(repos_with_upstream)
 
     if brief:
         print(format_status_brief(statuses))