Changes not staged for commit:
  deleted:    Screenshot 2026-04-12 at 5.32.00 PM.png
  deleted:    Screen Recording 2026-04-13 at 10.00.04 PM.mov
  ...

# 1. Install Git LFS (on macOS)
brew install git-lfs

# 2. Initialize LFS in your folder
git lfs install

# 3. Track heavy video formats with LFS
git lfs track "*.mov"
git lfs track "*.mp4"

# 4. Commit LFS configurations
git add .gitattributes
git commit -m "setup: track video formats via LFS"

# 1. Enable sparse-checkout in non-cone (custom pattern) mode
git sparse-checkout init --no-cone

# 2. Set the exclusion rules in Git's sparse config
echo '/*
!/images/
!/videos/' > .git/info/sparse-checkout

# 3. Apply the rules
git sparse-checkout reapply

#!/usr/bin/env bash
# backup.sh - Automatically organize, backup new screenshots/videos to subfolders, update INDEX.md, push to GitHub, and clean up local space.

set -e

REPO_URL="https://raw.githubusercontent.com/YOUR_USERNAME/YOUR_REPO"
INDEX_FILE="INDEX.md"
BRANCH="main"

echo "🔍 Scanning for new media files to back up..."

# Find new untracked/modified media files at root or inside subdirs
NEW_FILES=()
while IFS= read -r -d '' file; do
    relative="${file#./}"
    if [[ "$relative" =~ \.(png|jpg|jpeg|mov|mp4)$ ]]; then
        NEW_FILES+=("$relative")
    fi
done < <(git status --porcelain -z | grep -z -E '^\?\?|^ M' | cut -z -c4- | sort -z)

TOTAL=${#NEW_FILES[@]}

if [ "$TOTAL" -eq 0 ]; then
    echo "✅ No new media files found to back up."
    exit 0
fi

echo "📊 Found $TOTAL new files to process."

# Move files to date-based folders if they are at the root level
MOVED_FILES=()
for f in "${NEW_FILES[@]}"; do
    if [[ ! "$f" == *"/"* ]]; then
        # Parse date from name or default to current year-month
        if [[ "$f" =~ [0-9]{4}-[0-9]{2}-[0-9]{2} ]]; then
            DATE_STR="${BASH_REMATCH[0]}"
            YM="${DATE_STR:0:7}" # YYYY-MM
        else
            YM=$(date '+%Y-%m') # Fallback to current year-month
        fi

        if [[ "$f" =~ \.(png|jpg|jpeg)$ ]]; then
            dest_dir="images/$YM"
        else
            dest_dir="videos/$YM"
        fi

        mkdir -p "$dest_dir"
        dest_path="$dest_dir/$f"
        echo "📂 Moving root file: $f -> $dest_path"
        mv "$f" "$dest_path"
        git add "$dest_path"
        MOVED_FILES+=("$dest_path")
    else
        git add "$f"
        MOVED_FILES+=("$f")
    fi
done

# Commit and Push the files first to get the commit SHA
echo "💾 Committing new organized files..."
git commit -m "backup: add $TOTAL new files organized by date"
echo "🚀 Pushing files to GitHub..."
git push origin "$BRANCH"

# Get the full 40-character commit SHA
COMMIT_SHA=$(git rev-parse HEAD)
echo "✅ Pushed successfully! Commit: $COMMIT_SHA"

# Rebuild INDEX.md using Python to keep it clean and ordered
echo "📝 Rebuilding INDEX.md..."
python3 -c "
import os
import urllib.parse
from datetime import datetime

repo_url_base = '${REPO_URL}/${COMMIT_SHA}'
index_file_path = '${INDEX_FILE}'

def get_human_size(path):
    try:
        size = os.path.getsize(path)
        if size >= 1073741824:
            return f'{size / 1073741824:.1f} GB'
        elif size >= 1048576:
            return f'{size / 1048576:.1f} MB'
        elif size >= 1024:
            return f'{size / 1024:.1f} KB'
        else:
            return f'{size} B'
    except Exception:
        return 'Unknown'

# Collect images
images = []
for root, dirs, files in os.walk('images'):
    for f in files:
        if f.endswith('.png'):
            relative_path = os.path.join(root, f)
            images.append(relative_path)
images.sort()

# Collect videos
videos = []
for root, dirs, files in os.walk('videos'):
    for f in files:
        if f.endswith('.mov') or f.endswith('.mp4'):
            relative_path = os.path.join(root, f)
            videos.append(relative_path)
videos.sort()

# Read the first commit SHA for other files
first_sha = os.popen('git log --oneline | tail -1 | cut -d\" \" -f1').read().strip()

with open(index_file_path, 'w') as f_obj:
    f_obj.write('# 📁 Documents Index\n\n')
    f_obj.write('> Auto-generated index of all files backed up to this repository.\n')
    f_obj.write('> Use the Raw URL to download any file, even after local deletion.\n')
    f_obj.write(f'> Generated on: {datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}\n\n')

    f_obj.write('## 🖼️ Images (PNG Screenshots)\n\n')
    f_obj.write('| # | File | Size | Commit | Raw URL |\n')
    f_obj.write('|---|------|------|--------|---------|\n')
    for idx, path in enumerate(images, 1):
        size = get_human_size(path)
        encoded = urllib.parse.quote(path, safe='/')
        f_obj.write(f'| {idx} | `{path}` | {size} | `{COMMIT_SHA[:7]}` | [Download]({repo_url_base}/{encoded}) |\n')

    f_obj.write('\n## 🎥 Videos (Screen Recordings)\n\n')
    f_obj.write('| # | File | Size | Commit | Raw URL |\n')
    f_obj.write('|---|------|------|--------|---------|\n')
    for idx, path in enumerate(videos, 1):
        size = get_human_size(path)
        encoded = urllib.parse.quote(path, safe='/')
        f_obj.write(f'| {idx} | `{path}` | {size} | `{COMMIT_SHA[:7]}` | [Download]({repo_url_base}/{encoded}) |\n')

    f_obj.write('\n## 📄 Other Files\n\n')
    f_obj.write('| # | File | Size | Commit | Raw URL |\n')
    f_obj.write('|---|------|------|--------|---------|\n')
    f_obj.write(f'| 1 | `hls-video.excalidraw` | {get_human_size(\"hls-video.excalidraw\")} | `{first_sha}` | [Download]({repo_url_base}/hls-video.excalidraw) |\n')
"

# Commit and Push INDEX.md
git add "$INDEX_FILE"
git commit -m "index: update INDEX.md with new backup file mappings"
git push origin "$BRANCH"

# Reapply sparse checkout to reclaim local disk space
echo "🧹 Reclaiming local disk space (running sparse-checkout)..."
git sparse-checkout reapply

echo "🎉 Backup complete! Local space is cleared, and files are safe on GitHub."

chmod +x backup.sh

# Skill: Organized Documents Backup and Space Reclaiming

This skill provides instructions for AI coding agents to back up new screenshots, screen recordings, and media files from the local computer to the GitHub repository using Git LFS and Git Sparse-Checkout, keeping files organized by date and type.

## 📁 Repository Directory Structure

Files are organized in folders automatically by date and type:
* `/images/YYYY-MM/` — Screenshot PNGs grouped by month
* `/videos/YYYY-MM/` — Screen Recording MOVs and MP4s grouped by month

---

## 🛠️ How to Back Up New Files (Agent Flow)

If the user drops new files into the folder, you should run the automated script.

### Option A: Automated (Recommended)
Run the backup script directly:

This script will:
1. Detect any untracked or modified images/videos.
2. Automatically parse dates from filenames (e.g. `2026-04-12`) and move them to their respective `images/YYYY-MM/` or `videos/YYYY-MM/` subdirectory.
3. Stage, commit, and push them to GitHub.
4. Fetch the **full 40-character commit SHA** (required for raw GitHub usercontent links to prevent 404s).
5. Rebuild `INDEX.md` using python to catalog all files with their paths, sizes, and direct raw download links.
6. Commit and push the updated `INDEX.md`.
7. Run `git sparse-checkout reapply` to clean up the local disk.

### Option B: Manual Execution
If the script needs debugging or you want to run it manually:

1. **Move files into directories**:

2. **Stage and commit the new files**:

3. **Retrieve the full commit SHA**:

4. **Format entry for INDEX.md**:
   Add rows to `INDEX.md` under the appropriate table header:

5. **Push INDEX.md**:

6. **Reapply sparse checkout to delete local files**:

---

## 📥 How to Restore a File for the User

If the user requests to restore one or more files to their computer:
1. Locate the file in `INDEX.md` to get its path.
2. Tell Git to stop skipping the file:

   *Note: This will immediately download the file from GitHub to the local directory.*
3. To exclude it again after use:

git sparse-checkout add "images/2026-04/screenshot.png"

git sparse-checkout reapply