#!/bin/sh
# sync.sh - Parallel sync of all repos with commit access

# Configuration
JOBS="${JOBS:-$(nproc)}"
REPO_ROOT="${REPO_ROOT:-$HOME/repos}"
MAX_RETRIES=3
RETRY_DELAY=30

echo "Syncing repositories with $JOBS parallel jobs..."

# Rate limiting helper with exponential backoff
sync_with_retry() {
    local repo="$1"
    local attempt=1
    local repo_path="$REPO_ROOT/github.com/$repo"

    while [ $attempt -le $MAX_RETRIES ]; do
        if [ -d "$repo_path" ]; then
            git -C "$repo_path" pull --ff-only && return 0
        else
            git clone "https://github.com/$repo" "$repo_path" && return 0
        fi

        echo "Retry $attempt/$MAX_RETRIES for $repo (rate limit?)"
        sleep $((RETRY_DELAY * attempt))
        attempt=$((attempt + 1))
    done
    return 1
}

export -f sync_with_retry
export REPO_ROOT MAX_RETRIES RETRY_DELAY

# Get repos with push access, sync in parallel
gh repo list --limit 1000 --json nameWithOwner,viewerPermission \
    --jq '.[] | select(.viewerPermission == "ADMIN" or
                       .viewerPermission == "WRITE") |
          .nameWithOwner' | \
    parallel -j "$JOBS" 'sync_with_retry {}'

echo "Sync complete!"

# Configure git to use SSH instead of HTTPS
git config --global url."git@github.com:".insteadOf "https://github.com/"

# Ensure SSH agent is running with your key
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# For organizations with SSO, authorize your SSH key:
# https://github.com/settings/keys → Configure SSO

project/
├── .git/                    # Shared git database
├── worktrees/               # All branch checkouts
│   ├── feature-auth/        # origin/feature/auth
│   ├── fix-login-bug/       # origin/fix/login-bug
│   └── release-v2/          # origin/release/v2
└── (main checkout)          # Default branch

# List all worktrees
git worktree list

# Create worktree for existing remote branch
git worktree add worktrees/feature-x origin/feature/x

# Create worktree with new branch
git worktree add -b feature/new worktrees/feature-new

# Remove worktree
git worktree remove worktrees/feature-x

# Clean up stale references
git worktree prune

# Lock a worktree (prevents accidental removal)
git worktree lock worktrees/feature-x --reason "Long-running experiment"

# Check lock status
git worktree list --porcelain | grep -A2 "worktree"

# Unlock when done
git worktree unlock worktrees/feature-x

# Check total worktree disk usage
du -sh ~/repos/github.com/*/*/worktrees 2>/dev/null | sort -h | tail -20

# Count total worktrees
find ~/repos -type d -name worktrees -exec ls -1 {} \; 2>/dev/null | wc -l

# Prune all stale worktrees across repos
find ~/repos -name .git -type d -execdir git worktree prune \;

# For each repo, create worktrees for all remote branches
create_worktrees() {
    local repo_path="$1"
    local worktrees_dir="$repo_path/worktrees"

    mkdir -p "$worktrees_dir"
    cd "$repo_path"

    # Get default branch
    default_branch=$(git symbolic-ref refs/remotes/origin/HEAD |
                     sed 's@^refs/remotes/origin/@@')

    # Fetch and create worktrees
    git fetch --prune origin

    for branch in $(git branch -r | grep -v HEAD | sed 's/origin\///'); do
        [ "$branch" = "$default_branch" ] && continue

        safe_name=$(echo "$branch" | tr '/' '-')
        worktree_path="$worktrees_dir/$safe_name"

        if [ ! -d "$worktree_path" ]; then
            git worktree add "$worktree_path" "origin/$branch"
        fi
    done

    git worktree prune
}

# Initialize task tracking in a project
cd ~/repos/github.com/org/project
task init
git add .tasks && git commit -m "chore: initialize task tracking"

# Discovery
task list                    # List all issues
task ready                   # Show unblocked work
task blocked                 # Show blocked issues
task search "keyword"        # Search issues

# Working
task create "Title" -p 1     # Create issue (priority 0-4)
task show <id>               # View details
task update <id> --status in_progress
task close <id>              # Complete issue

# Sync
task sync && git push        # Always push when done

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│ task ready  │────►│  Work on    │────►│ task close  │
│             │     │   task      │     │             │
└─────────────┘     └─────────────┘     └─────────────┘
      │                   │                   │
      ▼                   ▼                   ▼
┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│ Pick issue  │     │ git commit  │     │ task sync   │
│ (unblocked) │     │ small steps │     │ git push    │
└─────────────┘     └─────────────┘     └─────────────┘

# Create named session
tmux new -s project-name

# Recommended window layout:
# Window 0: Claude Code / AI assistant
# Window 1: Editor (vim/emacs/code)
# Window 2: Logs / monitoring
# Window 3: Git / tasks

#!/bin/sh
# dev-session.sh - Start development session

PROJECT="${1:-default}"

tmux has-session -t "$PROJECT" 2>/dev/null

if [ $? != 0 ]; then
    tmux new-session -d -s "$PROJECT" -n claude
    tmux new-window -t "$PROJECT" -n editor
    tmux new-window -t "$PROJECT" -n logs
    tmux new-window -t "$PROJECT" -n git
    tmux select-window -t "$PROJECT:0"
fi

tmux attach -t "$PROJECT"

┌─────────────────────────────────────────────────┐
│              Prompt Cache Layers                 │
├─────────────────────────────────────────────────┤
│                                                  │
│  ~/.claude/CLAUDE.md     ──► CACHED (static)    │
│  Global instructions          Rarely changes     │
│                                                  │
│  repo/CLAUDE.md          ──► CACHED (per-repo)  │
│  Project instructions         Changes with repo  │
│                                                  │
│  repo/CONTINUE.md        ──► DYNAMIC            │
│  Session state                Changes each session│
│                                                  │
└─────────────────────────────────────────────────┘

## AI Context Hints

### Key Files (read these first)
- src/main.py - Application entry point
- src/api/routes.py - API definitions
- src/models/ - Data models

### Ignore Patterns
- node_modules/, vendor/, .git/
- *.log, *.tmp, *.cache
- build/, dist/, coverage/

### Architecture Summary
- Pattern: MVC with service layer
- Database: PostgreSQL with SQLAlchemy
- API: REST, OpenAPI 3.0 spec in docs/api.yaml

# Claude Code Global Instructions

## Session Startup

At the start of every session:
- Check task tracker: `task ready`
- Check worktrees: `git worktree list`
- Read CONTINUE.md if it exists

## Tool Preferences

- Read tool for reading files
- Write tool for creating new files
- Edit tool for modifying existing files
- Never use `git add .` or `git add -A`

## Commit Protocol

- Atomic changes: one logical change per commit
- Always buildable: never commit broken code
- Test before commit: run tests before each commit

## Commit Format

<type>(<scope>): <description>

Types: feat, fix, docs, test, chore, refactor

# Project Instructions

## Quick Start

```bash
# Build
make build

# Test
make test

# Run
make run
```

## Architecture Notes

- Uses MVC pattern
- Database: PostgreSQL
- API: REST with OpenAPI spec

## Key Files

- src/main.py - Application entry point
- src/api/ - REST endpoints
- tests/ - Test suite

## Next Session

- **Active Task:** project-123
- **Current Focus:** Implementing auth middleware
- **Blockers:** Waiting for API spec review

## Recent Changes

- Added JWT validation
- Updated user model

## Notes

See experiments/notes/session-2026-01-10.md