Disk Space Management for Git Worktrees

# Install pnpm globally
npm install -g pnpm

# Configure global store location (optional)
pnpm config set store-dir ~/.pnpm-store

# Migrate existing project from npm
cd ~/project
rm -rf node_modules package-lock.json
pnpm import  # Converts package-lock.json to pnpm-lock.yaml
pnpm install

# Create additional worktrees
git worktree add ../project-feature feature-branch
cd ../project-feature
pnpm install  # Uses shared global store

echo "package-manager=pnpm@latest" > .npmrc
git add .npmrc
git commit -m "Enforce pnpm for worktree-friendly dependency management"

# Initialize Yarn Berry in repository
corepack enable
yarn set version stable
yarn config set nodeLinker pnp

# Install dependencies
yarn install

# Create worktree
git worktree add ../project-feature feature-branch
cd ../project-feature
yarn install  # Reuses cached .yarn/cache/ from main worktree

# Configure shared bundle path in main worktree
cd ~/project
bundle config set --local path '../shared-gems'
bundle install

# Create additional worktrees
git worktree add ../project-hotfix hotfix-branch
cd ../project-hotfix

# Configure to use same shared gem path
bundle config set --local path '../shared-gems'
bundle install  # Reuses existing gems

# Create shared venv outside worktree directories
python -m venv ~/project-shared-venv
source ~/project-shared-venv/bin/activate
pip install -r requirements.txt

# Use in multiple worktrees
cd ~/project
source ~/project-shared-venv/bin/activate
python script.py

cd ../project-feature
source ~/project-shared-venv/bin/activate
python script.py

# Create venv in main worktree
cd ~/project
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

# Create venv in second worktree with symlinked site-packages
cd ../project-feature
python -m venv .venv
rm -rf .venv/lib/python3.11/site-packages
ln -s ~/project/.venv/lib/python3.11/site-packages .venv/lib/python3.11/site-packages

# Create worktree with sparse checkout for authentication service
git worktree add --no-checkout ../monorepo-auth
cd ../monorepo-auth

# Initialize sparse checkout
git sparse-checkout init --cone

# Specify required directories
git sparse-checkout set services/authentication shared/libraries

# Checkout the branch
git checkout feature/auth-improvements

# Working directory contains only:
# - services/authentication/  (500MB)
# - shared/libraries/         (400MB)
# Total: 900MB (vs 3.2GB for full checkout)

# Set multiple paths including build artifacts
git sparse-checkout set \
  services/authentication \
  shared/libraries \
  build-configs

# Exclude test directories
git sparse-checkout set services/authentication '!services/authentication/tests'

# View current sparse checkout patterns
git sparse-checkout list

#!/bin/bash
# create-focused-worktree.sh
# Creates sparse checkout worktree for specific service

SERVICE=$1
BRANCH=${2:-main}

if [ -z "$SERVICE" ]; then
    echo "Usage: $0 <service-name> [branch]"
    echo "Available services: authentication payment notification analytics"
    exit 1
fi

WORKTREE_PATH="../monorepo-$SERVICE"

# Create worktree without checkout
git worktree add --no-checkout "$WORKTREE_PATH"
cd "$WORKTREE_PATH"

# Configure sparse checkout
git sparse-checkout init --cone
git sparse-checkout set "services/$SERVICE" shared/libraries

# Checkout specified branch
git checkout "$BRANCH"

echo "✅ Sparse worktree created: $WORKTREE_PATH"
echo "   Service: $SERVICE"
echo "   Branch: $BRANCH"
echo "   Storage saved: ~$(du -sh . | awk '{print $1}') vs full checkout"

# CI environment: sparse + shallow
git clone --depth=1 --filter=blob:none --sparse <repo-url>
cd <repo>
git sparse-checkout set services/authentication

// webpack.config.js
const path = require("path");

module.exports = {
  cache: {
    type: "filesystem",
    cacheDirectory: path.resolve(__dirname, "../.shared-webpack-cache"),
    compression: "gzip",
    hashAlgorithm: "md5",
  },
  // ... rest of config
};

// vite.config.js
import { defineConfig } from "vite";

export default defineConfig({
  cacheDir: "../.shared-vite-cache",
  // ... rest of config
});

# Clear shared cache if issues arise
rm -rf ../.shared-vite-cache/*

# Shared Gradle user home (contains cache, wrappers, daemons)
org.gradle.user.home=../.shared-gradle-home

# Enable build cache
org.gradle.caching=true

# Configure local cache directory
org.gradle.cache.local.directory=../.shared-gradle-home/caches

# Check active Gradle daemons
gradle --status

# Stop all daemons (useful when cleaning up)
gradle --stop

# Install sccache
cargo install sccache

# Configure Cargo to use sccache
export RUSTC_WRAPPER=sccache
export SCCACHE_DIR=~/.cache/sccache

# Add to shell profile for persistence
echo 'export RUSTC_WRAPPER=sccache' >> ~/.bashrc
echo 'export SCCACHE_DIR=~/.cache/sccache' >> ~/.bashrc

# Build in multiple worktrees (cache is shared)
cd ~/project
cargo build

cd ../project-feature
cargo build  # Reuses cached compilation units

# Create build worktree without installing dependencies locally
git worktree add ../project-ci-build
cd ../project-ci-build

# Dockerfile for containerized build
cat > Dockerfile.build <<EOF
FROM node:20-alpine

WORKDIR /app

# Copy dependency manifests
COPY package*.json ./
RUN npm ci --production

# Copy source code
COPY . .

# Build application
RUN npm run build

# Output artifacts to mounted volume
CMD ["sh", "-c", "cp -r dist/* /output/"]
EOF

# Execute build in container
docker build -f Dockerfile.build -t project-builder .
docker run --rm \
  -v "$(pwd)/dist-output:/output" \
  project-builder

# Artifacts are now in ./dist-output/, no node_modules in working tree

# kubernetes-build-job.yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: worktree-build-feature-x
spec:
  template:
    spec:
      containers:
        - name: builder
          image: project-builder:latest
          volumeMounts:
            - name: worktree-source
              mountPath: /workspace
            - name: build-cache
              mountPath: /cache
          command: ["npm", "run", "build"]
      volumes:
        - name: worktree-source
          gitRepo:
            repository: "https://github.com/org/project"
            revision: "feature-x"
        - name: build-cache
          persistentVolumeClaim:
            claimName: shared-build-cache
      restartPolicy: Never

# Create worktree-specific exclusion file
cd ~/project-build-worktree
cat > .git/info/exclude <<EOF
# Worktree-specific ignores (not tracked in version control)
build/intermediate/
*.tmp
.build-cache/
EOF

#!/bin/bash
# worktree-storage-audit.sh
# Analyzes storage usage across all worktrees

echo "=== Git Worktree Storage Audit ==="
echo ""

# Shared Git object database size
GIT_DIR_SIZE=$(du -sh .git 2>/dev/null | awk '{print $1}')
echo "Shared Git objects: $GIT_DIR_SIZE"
echo ""

# Per-worktree analysis
echo "Worktree breakdown:"
git worktree list | awk '{print $1}' | while read worktree; do
    if [ -d "$worktree" ]; then
        WORKTREE_SIZE=$(du -sh "$worktree" 2>/dev/null | awk '{print $1}')

        # Identify large subdirectories
        NODE_MODULES=$(du -sh "$worktree/node_modules" 2>/dev/null | awk '{print $1}')
        VENV=$(du -sh "$worktree/.venv" 2>/dev/null | awk '{print $1}')
        BUILD=$(du -sh "$worktree/build" 2>/dev/null | awk '{print $1}')

        echo "  $worktree: $WORKTREE_SIZE"
        [ -n "$NODE_MODULES" ] && echo "    ├─ node_modules/: $NODE_MODULES"
        [ -n "$VENV" ] && echo "    ├─ .venv/: $VENV"
        [ -n "$BUILD" ] && echo "    └─ build/: $BUILD"
    fi
done

echo ""
echo "=== Optimization Recommendations ==="

# Check for duplicate node_modules
if find . -maxdepth 2 -name "node_modules" -type d 2>/dev/null | grep -q node_modules; then
    echo "⚠️  Multiple node_modules directories detected"
    echo "   Consider using pnpm for deduplication"
fi

# Check for large untracked files
echo ""
echo "Largest untracked files:"
git worktree list | awk '{print $1}' | while read worktree; do
    if [ -d "$worktree" ]; then
        find "$worktree" -type f -not -path '*/\.git/*' -exec du -h {} + 2>/dev/null | \
            sort -rh | head -5 | sed "s|^|  |"
    fi
done

chmod +x worktree-storage-audit.sh
./worktree-storage-audit.sh

# Output example:
=== Git Worktree Storage Audit ===

Shared Git objects: 512M

Worktree breakdown:
  /home/user/project: 2.8G
    ├─ node_modules/: 2.1G
    └─ build/: 450M
  /home/user/project-feature: 2.6G
    ├─ node_modules/: 2.0G
    └─ build/: 380M
  /home/user/project-review: 1.2G
    ├─ node_modules/: 890M

=== Optimization Recommendations ===
⚠️  Multiple node_modules directories detected
   Consider using pnpm for deduplication

Largest untracked files:
  2.1G    /home/user/project/node_modules
  2.0G    /home/user/project-feature/node_modules
  890M    /home/user/project-review/node_modules

# Add to crontab: crontab -e
# Clean stale worktree artifacts weekly
0 2 * * 0 find ~/projects -name "node_modules" -type d -mtime +30 -exec rm -rf {} +
0 2 * * 0 find ~/projects -name ".venv" -type d -mtime +30 -exec rm -rf {} +
0 2 * * 0 find ~/projects -name "build" -type d -mtime +30 -exec rm -rf {} +

#!/bin/bash
# .git/hooks/pre-push

# Check for worktrees with stale dependencies
git worktree list | awk '{print $1}' | while read worktree; do
    if [ -d "$worktree/node_modules" ]; then
        LAST_MODIFIED=$(stat -f "%Sm" -t "%Y-%m-%d" "$worktree/node_modules" 2>/dev/null || \
                        stat -c "%y" "$worktree/node_modules" 2>/dev/null | cut -d' ' -f1)
        DAYS_OLD=$(( ($(date +%s) - $(date -d "$LAST_MODIFIED" +%s 2>/dev/null || date -j -f "%Y-%m-%d" "$LAST_MODIFIED" +%s)) / 86400 ))

        if [ "$DAYS_OLD" -gt 30 ]; then
            echo "⚠️  Worktree $worktree has stale dependencies ($DAYS_OLD days old)"
            echo "   Consider running: cd $worktree && rm -rf node_modules && pnpm install"
        fi
    fi
done

# Example: Large Node.js monorepo with CI worktrees

# 1. Use pnpm for dependency management
pnpm install

# 2. Configure sparse checkout for service-specific worktrees
git sparse-checkout set services/authentication shared/libraries

# 3. Share build cache
# (configured in webpack.config.js or vite.config.js)

# 4. Use containers for CI worktrees
docker build -f Dockerfile.ci -t ci-builder .

# Result:
# - Base storage: 3.2GB (monorepo full checkout)
# - With optimizations: 950MB per worktree (~70% reduction)

Error: ENOENT: no such file or directory, open 'node_modules/.pnpm/...'

# Reinstall to recreate hard links
pnpm install --force

# Clear Yarn cache
yarn cache clean

# Rebuild PnP manifests
rm -rf .pnp.* .yarn/cache
yarn install

# Create shared pip cache
mkdir -p ~/.pip-cache

# Configure pip to use shared cache
pip config set global.cache-dir ~/.pip-cache

# Install dependencies (uses shared cache but isolated venv)
cd ~/project
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

cd ../project-feature
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt  # Reuses ~/.pip-cache downloads

# Enable verbose sparse-checkout to see what's excluded
git sparse-checkout list

# Add missing build configuration paths
git sparse-checkout add build-configs scripts/deploy

# If build requires full repo, disable sparse-checkout for that worktree
git sparse-checkout disable

# Create ZFS pool with deduplication
zpool create -o dedup=on dev-pool /dev/sdX

# Create dataset for worktrees
zfs create dev-pool/worktrees

# Mount point
zfs set mountpoint=/home/user/worktrees dev-pool/worktrees

# Enable compression without deduplication
zfs set compression=lz4 dev-pool/worktrees

# Copy worktree directory as reflink (instant, zero storage overhead)
cp --reflink=always -r ~/project ~/project-copy

# Both directories share underlying storage blocks
# Storage is duplicated only when files are modified

#!/bin/bash
# create-worktree-reflink.sh
# Creates worktree and uses reflink for dependencies

WORKTREE_PATH=$1
BRANCH=$2

# Create worktree
git worktree add "$WORKTREE_PATH" "$BRANCH"

# Reflink copy dependencies from main worktree
if [ -d "node_modules" ]; then
    cp --reflink=always -r node_modules "$WORKTREE_PATH/"
fi

echo "✅ Worktree created with reflinked dependencies"
echo "   Storage overhead: ~0MB (until dependencies modified)"