Worktree Manager

#!/usr/bin/env bash
# Cleanup alpha-forge worktree and optionally delete merged branch
# ADR: /docs/adr/2025-12-14-alpha-forge-worktree-management.md
#
# Usage: cleanup-worktree.sh <worktree-path> [--delete-branch]
# Example: cleanup-worktree.sh ~/eon/alpha-forge.worktree-2025-12-14-feature-name
# Example: cleanup-worktree.sh ~/eon/alpha-forge.worktree-2025-12-14-feature-name --delete-branch

set -euo pipefail

WORKTREE_PATH="${1:-}"
DELETE_BRANCH="${2:-}"

# Dynamic worktree detection (ADR: 2025-12-29-ralph-constraint-scanning.md)
# Uses git rev-parse --git-common-dir instead of hardcoded path
detect_alpha_forge_root() {
    local git_common_dir
    git_common_dir=$(git rev-parse --git-common-dir 2>/dev/null || echo "")

    if [[ -z "$git_common_dir" ]]; then
        echo ""
        return
    fi

    if [[ "$git_common_dir" == ".git" ]]; then
        # Main worktree - we're in the repo root
        pwd
    else
        # Linked worktree - git-common-dir points to main's .git
        dirname "$git_common_dir"
    fi
}

AF_ROOT="${AF_ROOT:-$(detect_alpha_forge_root)}"

# Fallback to legacy path if detection fails
if [[ -z "$AF_ROOT" ]]; then
    AF_ROOT="$HOME/eon/alpha-forge"
fi

# Validate input
if [[ -z "$WORKTREE_PATH" ]]; then
    echo "Usage: cleanup-worktree.sh <worktree-path> [--delete-branch]" >&2
    echo "Example: cleanup-worktree.sh ~/eon/alpha-forge.worktree-2025-12-14-feature-name" >&2
    exit 1
fi

# Expand path
WORKTREE_PATH=$(eval echo "$WORKTREE_PATH")

# Validate alpha-forge repo exists
if [[ ! -d "$AF_ROOT/.git" ]]; then
    echo "Error: alpha-forge repo not found at $AF_ROOT" >&2
    echo "" >&2
    echo "Fix options:" >&2
    echo "  1. Run from within an alpha-forge worktree (auto-detection)" >&2
    echo "  2. Set AF_ROOT: export AF_ROOT=~/path/to/alpha-forge" >&2
    exit 1
fi

cd "$AF_ROOT"

# Validate worktree exists
if ! git worktree list | grep -q "^${WORKTREE_PATH} "; then
    echo "Error: '$WORKTREE_PATH' is not a valid worktree" >&2
    echo "" >&2
    echo "Current worktrees:" >&2
    git worktree list >&2
    exit 1
fi

# Get branch name for this worktree
BRANCH=$(git worktree list | grep "^${WORKTREE_PATH} " | sed 's/.*\[\(.*\)\].*/\1/' || true)

if [[ -z "$BRANCH" ]]; then
    echo "Warning: Could not determine branch for worktree" >&2
    BRANCH="(unknown)"
fi

# Extract slug for tab name
SLUG=$(basename "$WORKTREE_PATH" | sed 's/alpha-forge\.worktree-[0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}-//')
ACRONYM=$(echo "$SLUG" | tr '-' '\n' | cut -c1 | tr -d '\n' | tr '[:upper:]' '[:lower:]')

echo "Removing worktree..."
echo "  Path:   $WORKTREE_PATH"
echo "  Branch: $BRANCH"
echo "  Tab:    AF-${ACRONYM}"
echo ""

# Remove worktree
git worktree remove "$WORKTREE_PATH"

echo "✓ Worktree removed"

# Optionally delete branch
if [[ "$DELETE_BRANCH" == "--delete-branch" && "$BRANCH" != "(unknown)" ]]; then
    echo ""
    echo "Deleting branch '$BRANCH'..."

    # Check if branch is merged (safe delete with -d)
    if git branch -d "$BRANCH" 2>/dev/null; then
        echo "✓ Branch deleted (was merged)"
    else
        echo "Warning: Branch not fully merged. Use 'git branch -D $BRANCH' to force delete." >&2
    fi
fi

# Prune any orphaned worktree entries
git worktree prune 2>/dev/null || true

echo ""
echo "Done. Restart iTerm2 to update tab layout."

#!/usr/bin/env bash
# Create alpha-forge worktree with ADR-style naming
# ADR: /docs/adr/2025-12-14-alpha-forge-worktree-management.md
#
# Modes:
#   new    - Create new branch + worktree (atomic)
#   remote - Track remote branch in worktree
#   local  - Use existing local branch
#
# Usage:
#   New:    create-worktree.sh --mode new --slug <slug> --type <type> --base <base>
#   Remote: create-worktree.sh --mode remote --branch <remote-branch>
#   Local:  create-worktree.sh --mode local --branch <branch>
#
# Examples:
#   create-worktree.sh --mode new --slug sharpe-statistical-validation --type feat --base main
#   create-worktree.sh --mode remote --branch origin/feat/2025-12-10-existing
#   create-worktree.sh --mode local --branch feat/2025-12-15-my-feature

set -euo pipefail

# Dynamic worktree detection (ADR: 2025-12-29-ralph-constraint-scanning.md)
# Uses git rev-parse --git-common-dir instead of hardcoded path
detect_alpha_forge_root() {
    local git_common_dir
    git_common_dir=$(git rev-parse --git-common-dir 2>/dev/null || echo "")

    if [[ -z "$git_common_dir" ]]; then
        echo ""
        return
    fi

    if [[ "$git_common_dir" == ".git" ]]; then
        # Main worktree - we're in the repo root
        pwd
    else
        # Linked worktree - git-common-dir points to main's .git
        dirname "$git_common_dir"
    fi
}

# Defaults
MODE=""
SLUG=""
TYPE=""
BASE=""
BRANCH=""
AF_ROOT="${AF_ROOT:-$(detect_alpha_forge_root)}"
WORKTREE_BASE="${WORKTREE_BASE:-$HOME/eon}"

# Fallback to legacy path if detection fails
if [[ -z "$AF_ROOT" ]]; then
    AF_ROOT="$HOME/eon/alpha-forge"
fi

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --mode)
            MODE="$2"
            shift 2
            ;;
        --slug)
            SLUG="$2"
            shift 2
            ;;
        --type)
            TYPE="$2"
            shift 2
            ;;
        --base)
            BASE="$2"
            shift 2
            ;;
        --branch)
            BRANCH="$2"
            shift 2
            ;;
        *)
            # Legacy support: first positional arg is branch (local mode)
            if [[ -z "$BRANCH" ]]; then
                BRANCH="$1"
                MODE="${MODE:-local}"
            fi
            shift
            ;;
    esac
done

# Validate mode
if [[ -z "$MODE" ]]; then
    echo "Error: --mode required (new|remote|local)" >&2
    echo "" >&2
    echo "Usage:" >&2
    echo "  New:    create-worktree.sh --mode new --slug <slug> --type <type> --base <base>" >&2
    echo "  Remote: create-worktree.sh --mode remote --branch <remote-branch>" >&2
    echo "  Local:  create-worktree.sh --mode local --branch <branch>" >&2
    exit 1
fi

# Validate alpha-forge repo exists
if [[ ! -d "$AF_ROOT/.git" ]]; then
    echo "Error: alpha-forge repo not found at $AF_ROOT" >&2
    echo "" >&2
    echo "Fix options:" >&2
    echo "  1. Run from within an alpha-forge worktree (auto-detection)" >&2
    echo "  2. Set AF_ROOT: export AF_ROOT=~/path/to/alpha-forge" >&2
    exit 1
fi

cd "$AF_ROOT"

# Mode-specific validation and execution
case "$MODE" in
    new)
        # Mode 1: New branch from description (atomic creation)
        if [[ -z "$SLUG" || -z "$TYPE" || -z "$BASE" ]]; then
            echo "Error: --mode new requires --slug, --type, and --base" >&2
            exit 1
        fi

        DATE=$(date +%Y-%m-%d)
        BRANCH="${TYPE}/${DATE}-${SLUG}"
        WORKTREE_NAME="alpha-forge.worktree-${DATE}-${SLUG}"
        WORKTREE_PATH="${WORKTREE_BASE}/${WORKTREE_NAME}"

        # Check if branch already exists
        if git show-ref --verify --quiet "refs/heads/$BRANCH" 2>/dev/null; then
            echo "Error: Branch '$BRANCH' already exists" >&2
            echo "Use --mode local to create worktree for existing branch" >&2
            exit 1
        fi

        # Check if worktree path already exists
        if [[ -d "$WORKTREE_PATH" ]]; then
            echo "Error: Worktree already exists at $WORKTREE_PATH" >&2
            exit 1
        fi

        # Validate base branch exists on remote
        if ! git show-ref --verify --quiet "refs/remotes/origin/$BASE" 2>/dev/null; then
            echo "Error: Base branch 'origin/$BASE' not found" >&2
            echo "" >&2
            echo "Available remote branches:" >&2
            git branch -r --format='  %(refname:short)' | head -20 >&2
            exit 1
        fi

        # Atomic branch + worktree creation
        echo "Creating new branch and worktree..."
        echo "  Branch: $BRANCH"
        echo "  Base:   origin/$BASE"
        echo "  Path:   $WORKTREE_PATH"

        git worktree add -b "$BRANCH" "$WORKTREE_PATH" "origin/$BASE"
        ;;

    remote)
        # Mode 2: Track remote branch
        if [[ -z "$BRANCH" ]]; then
            echo "Error: --mode remote requires --branch <remote-branch>" >&2
            exit 1
        fi

        # Strip origin/ prefix if present for local branch name
        REMOTE_BRANCH="$BRANCH"
        LOCAL_BRANCH="${BRANCH#origin/}"

        # Extract date and slug from branch name
        if [[ "$LOCAL_BRANCH" =~ ^(feat|fix|refactor|chore)/([0-9]{4}-[0-9]{2}-[0-9]{2})-(.+)$ ]]; then
            DATE="${BASH_REMATCH[2]}"
            SLUG="${BASH_REMATCH[3]}"
        elif [[ "$LOCAL_BRANCH" =~ ^(feat|fix|refactor|chore)/(.+)$ ]]; then
            DATE=$(date +%Y-%m-%d)
            SLUG="${BASH_REMATCH[2]}"
        else
            DATE=$(date +%Y-%m-%d)
            SLUG="${LOCAL_BRANCH##*/}"
        fi

        WORKTREE_NAME="alpha-forge.worktree-${DATE}-${SLUG}"
        WORKTREE_PATH="${WORKTREE_BASE}/${WORKTREE_NAME}"

        # Validate remote branch exists
        if ! git show-ref --verify --quiet "refs/remotes/$REMOTE_BRANCH" 2>/dev/null; then
            echo "Error: Remote branch '$REMOTE_BRANCH' not found" >&2
            echo "" >&2
            echo "Available remote branches:" >&2
            git branch -r --format='  %(refname:short)' | head -20 >&2
            exit 1
        fi

        # Check if worktree path already exists
        if [[ -d "$WORKTREE_PATH" ]]; then
            echo "Error: Worktree already exists at $WORKTREE_PATH" >&2
            exit 1
        fi

        # Create tracking branch + worktree
        echo "Creating tracking branch and worktree..."
        echo "  Remote: $REMOTE_BRANCH"
        echo "  Local:  $LOCAL_BRANCH"
        echo "  Path:   $WORKTREE_PATH"

        git worktree add -b "$LOCAL_BRANCH" "$WORKTREE_PATH" "$REMOTE_BRANCH"
        BRANCH="$LOCAL_BRANCH"
        ;;

    local)
        # Mode 3: Existing local branch
        if [[ -z "$BRANCH" ]]; then
            echo "Error: --mode local requires --branch <branch>" >&2
            exit 1
        fi

        # Extract date and slug from branch name
        if [[ "$BRANCH" =~ ^(feat|fix|refactor|chore)/([0-9]{4}-[0-9]{2}-[0-9]{2})-(.+)$ ]]; then
            DATE="${BASH_REMATCH[2]}"
            SLUG="${BASH_REMATCH[3]}"
        elif [[ "$BRANCH" =~ ^(feat|fix|refactor|chore)/(.+)$ ]]; then
            DATE=$(date +%Y-%m-%d)
            SLUG="${BASH_REMATCH[2]}"
        else
            DATE=$(date +%Y-%m-%d)
            SLUG="${BRANCH##*/}"
        fi

        WORKTREE_NAME="alpha-forge.worktree-${DATE}-${SLUG}"
        WORKTREE_PATH="${WORKTREE_BASE}/${WORKTREE_NAME}"

        # Validate local branch exists
        if ! git show-ref --verify --quiet "refs/heads/$BRANCH" 2>/dev/null; then
            echo "Error: Local branch '$BRANCH' not found" >&2
            echo "" >&2
            echo "Available local branches:" >&2
            git branch --format='  %(refname:short)' | head -20 >&2
            exit 1
        fi

        # Check if worktree path already exists
        if [[ -d "$WORKTREE_PATH" ]]; then
            echo "Error: Worktree already exists at $WORKTREE_PATH" >&2
            exit 1
        fi

        # Check if branch already has a worktree
        EXISTING_WT=$(git worktree list | grep "\[$BRANCH\]" | awk '{print $1}' || true)
        if [[ -n "$EXISTING_WT" ]]; then
            echo "Error: Branch '$BRANCH' already has a worktree at $EXISTING_WT" >&2
            exit 1
        fi

        # Create worktree for existing branch
        echo "Creating worktree for existing branch..."
        echo "  Branch: $BRANCH"
        echo "  Path:   $WORKTREE_PATH"

        git worktree add "$WORKTREE_PATH" "$BRANCH"
        ;;

    *)
        echo "Error: Unknown mode '$MODE'. Use: new|remote|local" >&2
        exit 1
        ;;
esac

# Generate tab name from slug
ACRONYM=$(echo "$SLUG" | tr '-' '\n' | cut -c1 | tr -d '\n' | tr '[:upper:]' '[:lower:]')
TAB_NAME="AF-${ACRONYM}"

# Create .envrc for direnv (auto-load environment variables)
ENVRC_PATH="${WORKTREE_PATH}/.envrc"
ENV_SHARED="${WORKTREE_BASE}/.env.alpha-forge"

if [[ -f "$ENV_SHARED" ]]; then
    cat > "$ENVRC_PATH" << EOF
# alpha-forge worktree direnv config
# Auto-generated by create-worktree.sh

# Load shared alpha-forge secrets (ClickHouse, API keys, etc.)
dotenv ${ENV_SHARED}

# Worktree-specific overrides can be added below
EOF
    echo "  Created .envrc (loads shared secrets)"

    # Auto-allow direnv if available
    if command -v direnv &> /dev/null; then
        (cd "$WORKTREE_PATH" && direnv allow) 2>/dev/null || true
    fi
else
    echo "  Note: No shared .env found at $ENV_SHARED"
    echo "        Create it to auto-load secrets in worktrees"
fi

echo ""
echo "✓ Worktree created successfully"
echo ""
echo "  Path:   $WORKTREE_PATH"
echo "  Branch: $BRANCH"
echo "  Tab:    $TAB_NAME"
echo ""
echo "  Note: Restart iTerm2 to see the new tab in your layout."

#!/usr/bin/env bash
# Detect stale (merged) worktrees in alpha-forge
# ADR: /docs/adr/2025-12-14-alpha-forge-worktree-management.md
#
# Usage: detect-stale.sh
# Output: List of stale worktrees (branch merged to main)

set -euo pipefail

# Dynamic worktree detection (ADR: 2025-12-29-ralph-constraint-scanning.md)
# Uses git rev-parse --git-common-dir instead of hardcoded path
detect_alpha_forge_root() {
    local git_common_dir
    git_common_dir=$(git rev-parse --git-common-dir 2>/dev/null || echo "")

    if [[ -z "$git_common_dir" ]]; then
        echo ""
        return
    fi

    if [[ "$git_common_dir" == ".git" ]]; then
        # Main worktree - we're in the repo root
        pwd
    else
        # Linked worktree - git-common-dir points to main's .git
        dirname "$git_common_dir"
    fi
}

AF_ROOT="${AF_ROOT:-$(detect_alpha_forge_root)}"

# Fallback to legacy path if detection fails
if [[ -z "$AF_ROOT" ]]; then
    AF_ROOT="$HOME/eon/alpha-forge"
fi

# Validate alpha-forge repo exists
if [[ ! -d "$AF_ROOT/.git" ]]; then
    echo "Error: alpha-forge repo not found at $AF_ROOT" >&2
    exit 1
fi

cd "$AF_ROOT"

# Get branches merged to main (excluding main itself and current branch)
MERGED=$(git branch --merged main 2>/dev/null | grep -v '^\*' | grep -v 'main' | tr -d ' ' || true)

if [[ -z "$MERGED" ]]; then
    echo "No merged branches found."
    exit 0
fi

# Get worktree information
WORKTREES=$(git worktree list --porcelain 2>/dev/null || true)

if [[ -z "$WORKTREES" ]]; then
    echo "No worktrees found."
    exit 0
fi

# Track if we found any stale worktrees
FOUND_STALE=0

# Check each worktree
while IFS= read -r line; do
    if [[ "$line" =~ ^worktree\ (.+)$ ]]; then
        CURRENT_PATH="${BASH_REMATCH[1]}"
    elif [[ "$line" =~ ^branch\ refs/heads/(.+)$ ]]; then
        BRANCH_NAME="${BASH_REMATCH[1]}"

        # Skip if this is the main worktree
        if [[ "$CURRENT_PATH" == "$AF_ROOT" ]]; then
            continue
        fi

        # Check if branch is in merged list
        if echo "$MERGED" | grep -q "^${BRANCH_NAME}$"; then
            if [[ $FOUND_STALE -eq 0 ]]; then
                echo "Stale worktrees (branch merged to main):"
                echo ""
                FOUND_STALE=1
            fi

            # Extract slug and generate tab name for context
            SLUG=$(basename "$CURRENT_PATH" | sed 's/alpha-forge\.worktree-[0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}-//')
            ACRONYM=$(echo "$SLUG" | tr '-' '\n' | cut -c1 | tr -d '\n' | tr '[:upper:]' '[:lower:]')

            echo "  STALE: $BRANCH_NAME"
            echo "    Path: $CURRENT_PATH"
            echo "    Tab:  AF-${ACRONYM}"
            echo ""
        fi
    fi
done <<< "$WORKTREES"

if [[ $FOUND_STALE -eq 0 ]]; then
    echo "No stale worktrees found. All worktree branches are unmerged."
fi