Zora Monorepo Rebuild Script - Automated rebuild of monorepo from latest commits in all 3 repos

rebuild-monorepo-from-latest.sh

#!/bin/bash
set -euo pipefail

# Automated Monorepo Rebuild Script
# Rebuilds the monorepo from scratch using the latest commits from all 3 repos

RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
BOLD='\033[1m'
NC='\033[0m'

# Repository URLs
BACKEND_REPO="[email protected]:ourzora/zora-backend-v2.git"
FRONTEND_REPO="[email protected]:ourzora/zora-co.git"
PROTOCOL_REPO="[email protected]:ourzora/zora-protocol-private.git"

# Working directory
WORK_DIR="$(pwd)"
REBUILD_DIR="$WORK_DIR/zora-monorepo-rebuild-$(date +%Y%m%d-%H%M%S)"

# Backup old monorepo
OLD_MONOREPO_BACKUP="$WORK_DIR/zora-monorepo-backup-$(date +%Y%m%d-%H%M%S)"

echo -e "${PURPLE}"
cat << 'EOF'
╔═══════════════════════════════════════════════════════════╗
║                                                           ║
║   Automated Monorepo Rebuild from Latest Commits         ║
║                                                           ║
╚═══════════════════════════════════════════════════════════╝
EOF
echo -e "${NC}\n"

#############################################################################
# Dependency Checks
#############################################################################

check_dependencies() {
    echo -e "${BLUE}Checking dependencies...${NC}\n"

    if ! command -v git &> /dev/null; then
        echo -e "${RED}✗ git not found${NC}"
        exit 1
    fi

    if ! command -v git-filter-repo &> /dev/null; then
        echo -e "${RED}✗ git-filter-repo not found${NC}"
        echo "Install with: pip install git-filter-repo"
        echo "Or: brew install git-filter-repo"
        exit 1
    fi

    echo -e "${GREEN}✓ All dependencies satisfied${NC}\n"
}

#############################################################################
# Clone and Update Repos
#############################################################################

clone_and_update_repos() {
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
    echo -e "${BLUE}     Step 1: Clone/Update Original Repos${NC}"
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}\n"

    # Backend
    if [ -d "zora-backend-v2-original" ]; then
        echo -e "${CYAN}Updating zora-backend-v2...${NC}"
        (cd zora-backend-v2-original && git fetch origin && git checkout main && git pull origin main)
    else
        echo -e "${CYAN}Cloning zora-backend-v2...${NC}"
        git clone "$BACKEND_REPO" zora-backend-v2-original
    fi
    BACKEND_COMMIT=$(cd zora-backend-v2-original && git rev-parse HEAD)
    echo -e "${GREEN}✓ Backend: $BACKEND_COMMIT${NC}\n"

    # Frontend
    if [ -d "zora-co-original" ]; then
        echo -e "${CYAN}Updating zora-co...${NC}"
        (cd zora-co-original && git fetch origin && git checkout main && git pull origin main)
    else
        echo -e "${CYAN}Cloning zora-co...${NC}"
        git clone "$FRONTEND_REPO" zora-co-original
    fi
    FRONTEND_COMMIT=$(cd zora-co-original && git rev-parse HEAD)
    echo -e "${GREEN}✓ Frontend: $FRONTEND_COMMIT${NC}\n"

    # Protocol
    if [ -d "zora-protocol-private-original" ]; then
        echo -e "${CYAN}Updating zora-protocol-private...${NC}"
        (cd zora-protocol-private-original && git fetch origin && git checkout main && git pull origin main)
    else
        echo -e "${CYAN}Cloning zora-protocol-private...${NC}"
        git clone "$PROTOCOL_REPO" zora-protocol-private-original
    fi
    PROTOCOL_COMMIT=$(cd zora-protocol-private-original && git rev-parse HEAD)
    echo -e "${GREEN}✓ Protocol: $PROTOCOL_COMMIT${NC}\n"
}

#############################################################################
# Rewrite Repos with git-filter-repo
#############################################################################

rewrite_repos() {
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
    echo -e "${BLUE}     Step 2: Rewrite Repos into Subdirectories${NC}"
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}\n"

    # Backend
    echo -e "${CYAN}Rewriting backend into backend/...${NC}"
    rm -rf zora-backend-v2-rewritten
    cp -R zora-backend-v2-original zora-backend-v2-rewritten
    (cd zora-backend-v2-rewritten && git-filter-repo --to-subdirectory-filter backend --force)
    echo -e "${GREEN}✓ Backend rewritten${NC}\n"

    # Frontend
    echo -e "${CYAN}Rewriting frontend into frontend/...${NC}"
    rm -rf zora-co-rewritten
    cp -R zora-co-original zora-co-rewritten
    (cd zora-co-rewritten && git-filter-repo --to-subdirectory-filter frontend --force)
    echo -e "${GREEN}✓ Frontend rewritten${NC}\n"

    # Protocol
    echo -e "${CYAN}Rewriting protocol into protocol/...${NC}"
    rm -rf zora-protocol-private-rewritten
    cp -R zora-protocol-private-original zora-protocol-private-rewritten
    (cd zora-protocol-private-rewritten && git-filter-repo --to-subdirectory-filter protocol --force)
    echo -e "${GREEN}✓ Protocol rewritten${NC}\n"
}

#############################################################################
# Create New Monorepo
#############################################################################

create_monorepo() {
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
    echo -e "${BLUE}     Step 3: Create Fresh Monorepo${NC}"
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}\n"

    # Create new empty repo
    echo -e "${CYAN}Creating new monorepo at: ${REBUILD_DIR}${NC}"
    mkdir -p "$REBUILD_DIR"
    cd "$REBUILD_DIR"
    git init --initial-branch=main
    git commit --allow-empty -m "Initial commit"

    # Add origin remote
    git remote add origin [email protected]:ourzora/zora-monorepo-poc.git

    # Add rewritten repos as remotes
    git remote add backend "$WORK_DIR/zora-backend-v2-rewritten"
    git remote add frontend "$WORK_DIR/zora-co-rewritten"
    git remote add protocol "$WORK_DIR/zora-protocol-private-rewritten"

    echo -e "${GREEN}✓ Monorepo initialized${NC}\n"

    # Fetch all histories
    echo -e "${CYAN}Fetching histories...${NC}"
    git fetch backend --quiet
    git fetch frontend --quiet
    git fetch protocol --quiet
    echo -e "${GREEN}✓ Histories fetched${NC}\n"

    # Merge backend
    echo -e "${CYAN}Merging backend...${NC}"
    git merge backend/main --allow-unrelated-histories -m "merge: add backend from zora-backend-v2"
    echo -e "${GREEN}✓ Backend merged${NC}\n"

    # Merge frontend
    echo -e "${CYAN}Merging frontend...${NC}"
    git merge frontend/main --allow-unrelated-histories -m "merge: add frontend from zora-co"
    echo -e "${GREEN}✓ Frontend merged${NC}\n"

    # Merge protocol
    echo -e "${CYAN}Merging protocol...${NC}"
    git merge protocol/main --allow-unrelated-histories -m "merge: add protocol from zora-protocol-private"
    echo -e "${GREEN}✓ Protocol merged${NC}\n"

    TOTAL_COMMITS=$(git rev-list --count HEAD)
    echo -e "${GREEN}✓ Monorepo created with ${TOTAL_COMMITS} commits${NC}\n"
}

#############################################################################
# Copy Configuration and Scripts
#############################################################################

setup_monorepo() {
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
    echo -e "${BLUE}     Step 4: Configure Monorepo${NC}"
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}\n"

    # Copy from old monorepo if it exists
    if [ -d "$WORK_DIR/zora-monorepo" ]; then
        echo -e "${CYAN}Copying configuration from existing monorepo...${NC}"

        # Root config files
        cp "$WORK_DIR/zora-monorepo/pyproject.toml" . 2>/dev/null || echo "No pyproject.toml"
        cp "$WORK_DIR/zora-monorepo/package.json" . 2>/dev/null || echo "No package.json"
        cp "$WORK_DIR/zora-monorepo/.env.example" . 2>/dev/null || echo "No .env.example"
        cp "$WORK_DIR/zora-monorepo/.gitignore" . 2>/dev/null || echo "No .gitignore"
        cp "$WORK_DIR/zora-monorepo/setup.sh" . 2>/dev/null && chmod +x setup.sh || echo "No setup.sh"

        # Scripts directory
        if [ -d "$WORK_DIR/zora-monorepo/scripts" ]; then
            echo -e "${CYAN}Copying scripts...${NC}"
            cp -R "$WORK_DIR/zora-monorepo/scripts" .
            chmod +x scripts/*.sh 2>/dev/null || true
        fi

        # GitHub workflows
        if [ -d "$WORK_DIR/zora-monorepo/.github" ]; then
            echo -e "${CYAN}Copying GitHub workflows...${NC}"
            cp -R "$WORK_DIR/zora-monorepo/.github" .
        fi

        # Documentation
        cp "$WORK_DIR/zora-monorepo/README.md" . 2>/dev/null || echo "No README.md"
        cp "$WORK_DIR/zora-monorepo/SETUP.md" . 2>/dev/null || echo "No SETUP.md"

        echo -e "${GREEN}✓ Configuration copied${NC}\n"
    else
        echo -e "${YELLOW}⚠ No existing monorepo found at $WORK_DIR/zora-monorepo${NC}"
        echo -e "${YELLOW}  You'll need to set up configuration manually${NC}\n"
    fi

    # Commit configuration
    git add -A
    git commit -m "chore: add monorepo configuration and tooling" || echo "Nothing to commit"

    echo -e "${GREEN}✓ Monorepo configured${NC}\n"
}

#############################################################################
# Finalize
#############################################################################

finalize() {
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
    echo -e "${BLUE}     Step 5: Finalize${NC}"
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}\n"

    # Backup old monorepo
    if [ -d "$WORK_DIR/zora-monorepo" ]; then
        echo -e "${CYAN}Backing up old monorepo...${NC}"
        mv "$WORK_DIR/zora-monorepo" "$OLD_MONOREPO_BACKUP"
        echo -e "${GREEN}✓ Old monorepo backed up to: ${OLD_MONOREPO_BACKUP}${NC}\n"
    fi

    # Move new monorepo into place
    echo -e "${CYAN}Moving new monorepo into place...${NC}"
    mv "$REBUILD_DIR" "$WORK_DIR/zora-monorepo"
    cd "$WORK_DIR/zora-monorepo"
    echo -e "${GREEN}✓ New monorepo ready at: $WORK_DIR/zora-monorepo${NC}\n"

    # Show summary
    BACKEND_COMMITS=$(git log --oneline backend/ | wc -l | tr -d ' ')
    FRONTEND_COMMITS=$(git log --oneline frontend/ | wc -l | tr -d ' ')
    PROTOCOL_COMMITS=$(git log --oneline protocol/ | wc -l | tr -d ' ')
    TOTAL_COMMITS=$(git rev-list --count HEAD)

    echo -e "${GREEN}═══════════════════════════════════════════════════════════${NC}"
    echo -e "${GREEN}     Rebuild Complete! 🎉${NC}"
    echo -e "${GREEN}═══════════════════════════════════════════════════════════${NC}\n"
    echo -e "${BOLD}Commit Summary:${NC}"
    echo -e "  Backend:   ${CYAN}${BACKEND_COMMITS}${NC} commits"
    echo -e "  Frontend:  ${CYAN}${FRONTEND_COMMITS}${NC} commits"
    echo -e "  Protocol:  ${CYAN}${PROTOCOL_COMMITS}${NC} commits"
    echo -e "  ${BOLD}Total:     ${CYAN}${TOTAL_COMMITS}${NC} commits${NC}\n"

    echo -e "${BOLD}Old monorepo backed up to:${NC}"
    echo -e "  ${YELLOW}${OLD_MONOREPO_BACKUP}${NC}\n"

    echo -e "${BOLD}Next steps:${NC}"
    echo -e "  1. cd zora-monorepo"
    echo -e "  2. rye run setup"
    echo -e "  3. rye run start"
    echo -e "  4. Test PR migration: ./scripts/migrate-pr.sh\n"

    echo -e "${YELLOW}Note: If you need to restore the old monorepo:${NC}"
    echo -e "  rm -rf zora-monorepo"
    echo -e "  mv ${OLD_MONOREPO_BACKUP} zora-monorepo\n"

    # Optional: Push to remote
    echo -e "${YELLOW}⚠️  The rebuilt monorepo has a new git history${NC}"
    read -p "Push to remote with --force? (Y/n): " push_confirm
    if [[ ! "$push_confirm" =~ ^[Nn]$ ]]; then
        echo -e "\n${CYAN}Pushing to origin/main...${NC}"
        if git push origin main --force; then
            echo -e "${GREEN}✓ Successfully pushed to remote${NC}\n"
        else
            echo -e "${RED}✗ Push failed${NC}"
            echo -e "${YELLOW}You can manually push later with: git push origin main --force${NC}\n"
        fi
    else
        echo -e "${YELLOW}Skipped push. You can push later with:${NC}"
        echo -e "  cd zora-monorepo && git push origin main --force\n"
    fi
}

#############################################################################
# Main
#############################################################################

main() {
    echo -e "${YELLOW}This script will:${NC}"
    echo -e "  1. Clone/update original repos from GitHub"
    echo -e "  2. Rewrite each repo into subdirectories"
    echo -e "  3. Create fresh monorepo with latest commits"
    echo -e "  4. Copy configuration from existing monorepo"
    echo -e "  5. Backup old monorepo and replace with new one\n"

    echo -e "${YELLOW}Working directory: ${WORK_DIR}${NC}"
    echo -e "${YELLOW}Temp build location: ${REBUILD_DIR}${NC}"
    echo -e "${YELLOW}Final monorepo location: ${WORK_DIR}/zora-monorepo${NC}"
    if [ -d "$WORK_DIR/zora-monorepo" ]; then
        echo -e "${YELLOW}Old monorepo backup: ${OLD_MONOREPO_BACKUP}${NC}"
    fi
    echo ""

    read -p "Continue? (Y/n): " confirm
    if [[ "$confirm" =~ ^[Nn]$ ]]; then
        echo -e "${YELLOW}Rebuild cancelled${NC}"
        exit 0
    fi

    echo ""

    check_dependencies
    clone_and_update_repos
    rewrite_repos
    create_monorepo
    setup_monorepo
    finalize
}

main