@pennyfarthing/core 11.1.1 → 11.2.0

package/pennyfarthing-dist/scripts/git/create-feature-branches.sh

@@ -1,267 +1,6 @@
-#!/usr/bin/env zsh
-# Create or checkout feature branches in Pennyfarthing repos
-# Idempotent, worktree-aware, branches from develop
-
+#!/usr/bin/env bash
+# DEPRECATED: Use `pf git branches` instead.
+# This shim forwards to the Python CLI.
 set -e
-
-# Load environment
-if [ -f .env ]; then
-    set -a; source .env; set +a
-elif [ -f ../.env ]; then
-    set -a; source ../.env; set +a
-fi
-
-show_help() {
-    cat << EOF
-Create Feature Branches - Idempotent branch creation/checkout
-
-Usage: ./create-feature-branches.sh <branch-name> [repos]
-
-Arguments:
-  branch-name    Branch name (e.g., feat/11-2-file-preview)
-  repos          Which repos to branch (default: all)
-                 Options: api, ui, all
-
-Repo Options:
-  api     - Pennyfarthing-api only
-  ui      - Pennyfarthing-ui only
-  all     - both repos (default)
-
-Examples:
-  # All repos (default)
-  ./create-feature-branches.sh feat/cross-repo-feature
-
-  # Pennyfarthing UI only
-  ./create-feature-branches.sh feat/11-2-ui-component ui
-
-  # Pennyfarthing API only
-  ./create-feature-branches.sh fix/validation-bug api
-
-Behavior:
-  - Idempotent: Checks out existing branches or creates new ones
-  - Worktree-aware: Detects main checkout vs worktree
-  - Always branches from develop
-  - Fetches latest develop before branching
-
-EOF
-}
-
-if [ -z "$1" ] || [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
-    show_help
-    exit 0
-fi
-
-BRANCH_NAME="$1"
-REPOS="${2:-all}"
-
-# Validate repos parameter
-if [[ ! "$REPOS" =~ ^(api|ui|all)$ ]]; then
-    echo "❌ Error: repos must be one of: api, ui, all"
-    echo "   Got: $REPOS"
-    echo ""
-    echo "Options:"
-    echo "  api     - Pennyfarthing-api only"
-    echo "  ui      - Pennyfarthing-ui only"
-    echo "  all     - both repos (default)"
-    exit 1
-fi
-
-# Detect if we're in a worktree
-CURRENT_DIR=$(pwd)
-if [[ "$CURRENT_DIR" == *"/worktrees/"* ]]; then
-    # Extract worktree name from path
-    WORKTREE_NAME=$(echo "$CURRENT_DIR" | sed -E 's|.*/worktrees/([^/]+).*|\1|')
-    REPO_BASE="$PROJECT_ROOT/worktrees/$WORKTREE_NAME"
-    echo "📂 Detected worktree: $WORKTREE_NAME"
-else
-    REPO_BASE="$PROJECT_ROOT"
-    echo "📂 Using main checkout"
-fi
-
-# Array to track processed repos for verification
-declare -a PROCESSED_REPOS
-
-# Function to create or checkout branch in a repo
-create_or_checkout_branch() {
-    local repo_path=$1
-    local repo_name=$2
-
-    if [ ! -d "$repo_path" ]; then
-        echo "⚠️  Skipping $repo_name: directory not found at $repo_path"
-        return
-    fi
-
-    cd "$repo_path"
-
-    echo ""
-    echo "🔧 Processing $repo_name..."
-
-    # Fetch latest from remote
-    echo "   Fetching from origin..."
-    git fetch origin --quiet
-
-    # Check if branch exists locally
-    if git show-ref --verify --quiet "refs/heads/$BRANCH_NAME"; then
-        echo "   ✅ Branch exists locally, checking out: $BRANCH_NAME"
-        git checkout "$BRANCH_NAME"
-    # Check if branch exists on remote
-    elif git show-ref --verify --quiet "refs/remotes/origin/$BRANCH_NAME"; then
-        echo "   ✅ Branch exists on remote, checking out and tracking: $BRANCH_NAME"
-        git checkout -b "$BRANCH_NAME" "origin/$BRANCH_NAME"
-    else
-        # Branch doesn't exist, create from develop
-        echo "   🌿 Creating new branch from develop: $BRANCH_NAME"
-
-        # Make sure we have latest develop
-        git fetch origin develop:develop --quiet 2>/dev/null || true
-
-        # Checkout develop first
-        if git show-ref --verify --quiet "refs/heads/develop"; then
-            git checkout develop --quiet
-            git pull origin develop --quiet
-        else
-            echo "   ⚠️  Local develop doesn't exist, fetching from remote"
-            git fetch origin develop:develop --quiet
-            git checkout develop --quiet
-        fi
-
-        # Create new branch
-        git checkout -b "$BRANCH_NAME"
-        echo "   ✅ Created: $BRANCH_NAME"
-    fi
-
-    # Show current status
-    CURRENT_BRANCH=$(git branch --show-current)
-    echo "   📍 Now on: $CURRENT_BRANCH"
-
-    # Track this repo for verification
-    PROCESSED_REPOS+=("$repo_path:$repo_name")
-}
-
-echo "🌿 Creating/checking out feature branches..."
-echo "   Branch: $BRANCH_NAME"
-echo "   Repos: $REPOS"
-
-# Process repos based on selection
-# When processing multiple repos, run in parallel for faster network I/O
-case "$REPOS" in
-    api)
-        create_or_checkout_branch "$REPO_BASE/Pennyfarthing-api" "Pennyfarthing-api"
-        ;;
-    ui)
-        create_or_checkout_branch "$REPO_BASE/Pennyfarthing-ui" "Pennyfarthing-ui"
-        ;;
-    all)
-        # Parallel execution for both repos
-        tmpdir=$(mktemp -d)
-        trap "rm -rf '$tmpdir'" EXIT
-        HAD_ERRORS=false
-
-        # Run both in parallel, capturing output
-        # Write to separate files to avoid race condition on shared file
-        (
-            create_or_checkout_branch "$REPO_BASE/Pennyfarthing-api" "Pennyfarthing-api"
-            echo "$REPO_BASE/Pennyfarthing-api:Pennyfarthing-api" > "$tmpdir/api.processed"
-        ) > "$tmpdir/api.out" 2>&1 &
-        pid_api=$!
-
-        (
-            create_or_checkout_branch "$REPO_BASE/Pennyfarthing-ui" "Pennyfarthing-ui"
-            echo "$REPO_BASE/Pennyfarthing-ui:Pennyfarthing-ui" > "$tmpdir/ui.processed"
-        ) > "$tmpdir/ui.out" 2>&1 &
-        pid_ui=$!
-
-        # Wait for both and capture exit codes
-        wait $pid_api; rc_api=$?
-        wait $pid_ui; rc_ui=$?
-
-        # Show output in order
-        [ -f "$tmpdir/api.out" ] && cat "$tmpdir/api.out"
-        [ -f "$tmpdir/ui.out" ] && cat "$tmpdir/ui.out"
-
-        # Rebuild PROCESSED_REPOS from separate files (avoids race condition)
-        [ -f "$tmpdir/api.processed" ] && PROCESSED_REPOS+=("$(cat "$tmpdir/api.processed")")
-        [ -f "$tmpdir/ui.processed" ] && PROCESSED_REPOS+=("$(cat "$tmpdir/ui.processed")")
-
-        # Check for failures
-        if [ $rc_api -ne 0 ] || [ $rc_ui -ne 0 ]; then
-            echo "⚠️  Some repos had errors"
-            HAD_ERRORS=true
-        fi
-        ;;
-esac
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "🔍 Verification Summary"
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-
-# Verify each processed repo
-for repo_info in "${PROCESSED_REPOS[@]}"; do
-    repo_path="${repo_info%%:*}"
-    repo_name="${repo_info##*:}"
-
-    if [ -d "$repo_path" ]; then
-        cd "$repo_path"
-
-        echo ""
-        echo "📦 $repo_name"
-        echo "   Path: $repo_path"
-
-        # Current branch
-        CURRENT_BRANCH=$(git branch --show-current)
-        echo "   Branch: $CURRENT_BRANCH"
-
-        # Check if branch matches expected
-        if [ "$CURRENT_BRANCH" = "$BRANCH_NAME" ]; then
-            echo "   ✅ Branch matches: $BRANCH_NAME"
-        else
-            echo "   ⚠️  Branch mismatch! Expected: $BRANCH_NAME, Got: $CURRENT_BRANCH"
-        fi
-
-        # Latest commit
-        COMMIT_INFO=$(git log -1 --format="%h - %s" 2>/dev/null)
-        echo "   Commit: $COMMIT_INFO"
-
-        # Check remote tracking
-        UPSTREAM=$(git rev-parse --abbrev-ref --symbolic-full-name @{u} 2>/dev/null || echo "none")
-        if [ "$UPSTREAM" != "none" ]; then
-            echo "   Remote: $UPSTREAM"
-
-            # Check if up to date with remote
-            git fetch origin "$CURRENT_BRANCH" --quiet 2>/dev/null || true
-            LOCAL=$(git rev-parse @ 2>/dev/null)
-            REMOTE=$(git rev-parse @{u} 2>/dev/null || echo "none")
-
-            if [ "$LOCAL" = "$REMOTE" ]; then
-                echo "   Status: ✅ Up to date with remote"
-            elif [ "$REMOTE" = "none" ]; then
-                echo "   Status: ⚠️  No remote branch yet (push needed)"
-            else
-                BEHIND=$(git rev-list --count HEAD..@{u} 2>/dev/null || echo "0")
-                AHEAD=$(git rev-list --count @{u}..HEAD 2>/dev/null || echo "0")
-                if [ "$AHEAD" -gt 0 ] && [ "$BEHIND" -gt 0 ]; then
-                    echo "   Status: ⚠️  Diverged ($AHEAD ahead, $BEHIND behind)"
-                elif [ "$AHEAD" -gt 0 ]; then
-                    echo "   Status: ⬆️  $AHEAD commit(s) ahead of remote"
-                elif [ "$BEHIND" -gt 0 ]; then
-                    echo "   Status: ⬇️  $BEHIND commit(s) behind remote"
-                fi
-            fi
-        else
-            echo "   Remote: none (local branch only)"
-            echo "   Status: ⚠️  Not tracking remote (push with -u needed)"
-        fi
-    fi
-done
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-if [ "$HAD_ERRORS" = true ]; then
-    echo "⚠️  Done with errors. Check output above."
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    exit 1
-else
-    echo "✅ Done! All branches verified and ready."
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-fi
+echo "DEPRECATED: create-feature-branches.sh — use 'pf git branches' instead" >&2
+exec pf git branches "$@"

package/pennyfarthing-dist/scripts/git/git-status-all.sh

@@ -1,152 +1,6 @@
-#!/usr/bin/env zsh
-# Show git status across all repos
-# Usage: ./scripts/git-status-all.sh [--brief]
-#
-# Shows: branch, status, unpushed commits for all repos
-# Reads repo configuration from .pennyfarthing/repos.yaml
-
+#!/usr/bin/env bash
+# DEPRECATED: Use `pf git status` instead.
+# This shim forwards to the Python CLI.
 set -e
-
-# Source environment (inline to avoid argument passing issues)
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-if [ -f "$SCRIPT_DIR/../.env" ]; then
-    set -a; source "$SCRIPT_DIR/../.env"; set +a
-fi
-
-# Fallback if PROJECT_ROOT not set
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-# Source repo utilities for dynamic repo configuration
-source "$SCRIPT_DIR/../misc/repo-utils.sh"
-
-# Colors
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-RED='\033[0;31m'
-NC='\033[0m'
-
-BRIEF=false
-if [ "${1:-}" = "--brief" ] || [ "${1:-}" = "-b" ]; then
-    BRIEF=true
-fi
-
-cd "$PROJECT_ROOT"
-
-show_repo_status() {
-    local repo_name=$1
-    local repo_dir=$2  # Note: can't use 'path' - it's a zsh special variable
-
-    if [ ! -d "$repo_dir/.git" ] && [ ! -d "$repo_dir" ]; then
-        return
-    fi
-
-    local branch=$(git -C "$repo_dir" branch --show-current 2>/dev/null || echo "detached")
-    local git_status=$(git -C "$repo_dir" status --short 2>/dev/null)
-    local git_status_count=$(echo "$git_status" | grep -c . 2>/dev/null); git_status_count=${git_status_count:-0}
-    local unpushed=$(git -C "$repo_dir" log origin/develop..HEAD --oneline 2>/dev/null | head -5)
-    local unpushed_count=$(git -C "$repo_dir" log origin/develop..HEAD --oneline 2>/dev/null | wc -l | tr -d ' ')
-
-    if $BRIEF; then
-        # One-line format
-        local status_indicator=""
-        [ "$git_status_count" -gt 0 ] && status_indicator="${YELLOW}M${NC}" || status_indicator="${GREEN}✓${NC}"
-        local push_indicator=""
-        [ "$unpushed_count" -gt 0 ] && push_indicator=" ${BLUE}↑${unpushed_count}${NC}"
-        echo -e "$repo_name: $branch $status_indicator$push_indicator"
-    else
-        echo -e "${BLUE}=== $repo_name ===${NC}"
-        echo -e "Branch: ${GREEN}$branch${NC}"
-
-        if [ -n "$git_status" ]; then
-            echo -e "${YELLOW}Changes:${NC}"
-            echo "$git_status" | head -10 | sed 's/^/  /'
-            [ "$git_status_count" -gt 10 ] && echo "  ... and $((git_status_count - 10)) more"
-        else
-            echo -e "${GREEN}Clean${NC}"
-        fi
-
-        if [ "$unpushed_count" -gt 0 ]; then
-            echo -e "${BLUE}Unpushed ($unpushed_count):${NC}"
-            echo "$unpushed" | sed 's/^/  /'
-            [ "$unpushed_count" -gt 5 ] && echo "  ... and $((unpushed_count - 5)) more"
-        fi
-        echo ""
-    fi
-}
-
-if ! $BRIEF; then
-    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-    echo -e "${BLUE}  Git Status - All Repos${NC}"
-    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-    echo ""
-fi
-
-# Check each repo from configuration (parallelized for performance)
-repo_count=$(get_repo_count)
-if [[ "$repo_count" -eq 0 ]]; then
-    # No repos configured, just show current directory
-    show_repo_status "Project" "$PROJECT_ROOT"
-else
-    # Create temp dir for parallel output capture
-    tmpdir=$(mktemp -d)
-    trap "rm -rf '$tmpdir'" EXIT
-
-    # Launch status checks in parallel
-    for repo in $(get_repos); do
-        repo_path=$(get_repo_full_path "$repo")
-        (show_repo_status "$repo" "$repo_path" > "$tmpdir/$repo.out" 2>&1) &
-    done
-    wait
-
-    # Output results in order
-    for repo in $(get_repos); do
-        [ -f "$tmpdir/$repo.out" ] && cat "$tmpdir/$repo.out"
-    done
-fi
-
-if ! $BRIEF; then
-    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-    # Summary
-    total_changes=0
-    total_unpushed=0
-
-    if [[ "$repo_count" -eq 0 ]]; then
-        # No repos configured, just check current directory
-        count=$(git -C "$PROJECT_ROOT" status --short 2>/dev/null | wc -l | tr -d ' ')
-        total_changes=$((total_changes + count))
-        unpushed=$(git -C "$PROJECT_ROOT" log origin/develop..HEAD --oneline 2>/dev/null | wc -l | tr -d ' ')
-        total_unpushed=$((total_unpushed + unpushed))
-    else
-        # Parallelize summary collection
-        summary_tmp=$(mktemp -d)
-        for repo in $(get_repos); do
-            repo_path=$(get_repo_full_path "$repo")
-            (
-                [ -d "$repo_path/.git" ] || [ -d "$repo_path" ] || exit 0
-                count=$(git -C "$repo_path" status --short 2>/dev/null | wc -l | tr -d ' ')
-                unpushed=$(git -C "$repo_path" log origin/develop..HEAD --oneline 2>/dev/null | wc -l | tr -d ' ')
-                echo "$count $unpushed" > "$summary_tmp/$repo.count"
-            ) &
-        done
-        wait
-
-        # Aggregate results
-        for repo in $(get_repos); do
-            if [ -f "$summary_tmp/$repo.count" ]; then
-                read count unpushed < "$summary_tmp/$repo.count"
-                total_changes=$((total_changes + count))
-                total_unpushed=$((total_unpushed + unpushed))
-            fi
-        done
-        rm -rf "$summary_tmp"
-    fi
-
-    if [ "$total_changes" -eq 0 ] && [ "$total_unpushed" -eq 0 ]; then
-        echo -e "${GREEN}✅ All repos clean and pushed${NC}"
-    else
-        [ "$total_changes" -gt 0 ] && echo -e "${YELLOW}$total_changes uncommitted change(s)${NC}"
-        [ "$total_unpushed" -gt 0 ] && echo -e "${BLUE}$total_unpushed unpushed commit(s)${NC}"
-    fi
-fi
+echo "DEPRECATED: git-status-all.sh — use 'pf git status' instead" >&2
+exec pf git status "$@"

package/pennyfarthing-dist/scripts/git/install-git-hooks.sh

@@ -1,144 +1,6 @@
-#!/bin/bash
-# install-git-hooks.sh - Install Pennyfarthing git hooks for framework development
-#
-# Usage: ./pennyfarthing-dist/scripts/install-git-hooks.sh
-#
-# For the pennyfarthing framework repo and orchestrator repos that inline it.
-# End-user projects use `pennyfarthing init` which copies hooks from node_modules.
-# This script creates .d/ directories with symlinks so hook changes in
-# pennyfarthing-dist/ take effect immediately.
-
-set -euo pipefail
-
-# Self-locate and set up PROJECT_ROOT
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-source "$SCRIPT_DIR/../lib/find-root.sh"
-HOOKS_SOURCE="$PROJECT_ROOT/pennyfarthing-dist/scripts/hooks"
-HOOKS_DEST="$PROJECT_ROOT/.git/hooks"
-
-DISPATCHER_MARKER="pennyfarthing-dispatcher"
-PF_PREFIX="10"
-MIGRATED_PREFIX="50"
-
-# Check we're in a repo with pennyfarthing-dist (framework or orchestrator)
-if [[ ! -d "$PROJECT_ROOT/pennyfarthing-dist" ]]; then
-    echo "Error: This script requires pennyfarthing-dist/ at the project root"
-    echo "       (framework repo or orchestrator with inlined pennyfarthing/)"
-    echo "       End-user projects should use: pennyfarthing init"
-    exit 1
-fi
-
-# Check .git exists
-if [[ ! -d "$PROJECT_ROOT/.git" ]]; then
-    echo "Error: Not a git repository"
-    exit 1
-fi
-
-echo "Installing git hooks with .d/ dispatcher pattern..."
-echo "  Source: pennyfarthing-dist/scripts/hooks/"
-echo "  Dest:   .git/hooks/"
-echo ""
-
-# Shared dispatcher template — single source of truth
-DISPATCHER_TEMPLATE="$PROJECT_ROOT/pennyfarthing-dist/scripts/hooks/dispatcher-template.sh"
-
-if [[ ! -f "$DISPATCHER_TEMPLATE" ]]; then
-    echo "Error: dispatcher-template.sh not found at $DISPATCHER_TEMPLATE"
-    exit 1
-fi
-
-# Generate a dispatcher script for a given hook name
-generate_dispatcher() {
-    local hook_name="$1"
-    sed "s/__HOOK_NAME__/${hook_name}/g" "$DISPATCHER_TEMPLATE"
-}
-
-# Define hooks to install
-HOOKS=(
-    "pre-commit.sh:pre-commit"
-    "pre-push.sh:pre-push"
-    "post-merge.sh:post-merge"
-)
-
-for hook_pair in "${HOOKS[@]}"; do
-    source_file="${hook_pair%%:*}"
-    dest_name="${hook_pair##*:}"
-
-    source_path="$HOOKS_SOURCE/$source_file"
-    dest_path="$HOOKS_DEST/$dest_name"
-    d_dir="$HOOKS_DEST/${dest_name}.d"
-    pf_hook_name="${PF_PREFIX}-pennyfarthing-${dest_name}.sh"
-    pf_hook_path="${d_dir}/${pf_hook_name}"
-
-    if [[ ! -f "$source_path" ]]; then
-        echo "  SKIP $dest_name (source not found)"
-        continue
-    fi
-
-    # Create .d/ directory
-    mkdir -p "$d_dir"
-
-    # Handle existing hook at the dest path
-    if [[ -e "$dest_path" ]]; then
-        if [[ -f "$dest_path" ]] && grep -q "$DISPATCHER_MARKER" "$dest_path" 2>/dev/null; then
-            echo "  OK   $dest_name dispatcher (already installed)"
-        elif [[ -L "$dest_path" ]]; then
-            # Old-style symlink — migrate to .d/ pattern
-            rm "$dest_path"
-            generate_dispatcher "$dest_name" > "$dest_path"
-            chmod 755 "$dest_path"
-            echo "  UPD  $dest_name → dispatcher"
-        elif [[ -f "$dest_path" ]]; then
-            existing_content="$(cat "$dest_path")"
-            if echo "$existing_content" | grep -q "pennyfarthing"; then
-                # Old pennyfarthing single-file hook — replace with dispatcher
-                generate_dispatcher "$dest_name" > "$dest_path"
-                chmod 755 "$dest_path"
-                echo "  UPD  $dest_name → dispatcher (was single-file pf hook)"
-            else
-                # Non-pennyfarthing hook — migrate into .d/
-                migrated_name="${MIGRATED_PREFIX}-migrated-${dest_name}.sh"
-                migrated_path="${d_dir}/${migrated_name}"
-                if [[ ! -f "$migrated_path" ]]; then
-                    mv "$dest_path" "$migrated_path"
-                    chmod 755 "$migrated_path"
-                    echo "  MIG  $dest_name → ${dest_name}.d/${migrated_name}"
-                fi
-                generate_dispatcher "$dest_name" > "$dest_path"
-                chmod 755 "$dest_path"
-                echo "  NEW  $dest_name dispatcher"
-            fi
-        fi
-    else
-        # No existing hook — install fresh dispatcher
-        generate_dispatcher "$dest_name" > "$dest_path"
-        chmod 755 "$dest_path"
-        echo "  NEW  $dest_name dispatcher"
-    fi
-
-    # Symlink pennyfarthing hook into .d/ (framework dev — symlink for live edits)
-    # From .git/hooks/{hook}.d/ we need ../../.../pennyfarthing-dist/scripts/hooks/
-    relative_path="../../../pennyfarthing-dist/scripts/hooks/$source_file"
-
-    if [[ -L "$pf_hook_path" ]]; then
-        current_target=$(readlink "$pf_hook_path")
-        if [[ "$current_target" == "$relative_path" ]]; then
-            echo "  OK   ${dest_name}.d/${pf_hook_name} (already linked)"
-        else
-            rm "$pf_hook_path"
-            ln -sf "$relative_path" "$pf_hook_path"
-            echo "  UPD  ${dest_name}.d/${pf_hook_name} → $relative_path"
-        fi
-    elif [[ -f "$pf_hook_path" ]]; then
-        # Regular file — replace with symlink for dev
-        rm "$pf_hook_path"
-        ln -sf "$relative_path" "$pf_hook_path"
-        echo "  UPD  ${dest_name}.d/${pf_hook_name} → $relative_path (was copy)"
-    else
-        ln -sf "$relative_path" "$pf_hook_path"
-        echo "  NEW  ${dest_name}.d/${pf_hook_name} → $relative_path"
-    fi
-done
-
-echo ""
-echo "Done. Verify with: ls -la .git/hooks/*.d/"
+#!/usr/bin/env bash
+# DEPRECATED: Use `pf git install-hooks` instead.
+# This shim forwards to the Python CLI.
+set -e
+echo "DEPRECATED: install-git-hooks.sh — use 'pf git install-hooks' instead" >&2
+exec pf git install-hooks "$@"