squash-only 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peter Ryszkiewicz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,210 @@
+# squash-only
+
+A bash script to automatically configure all your GitHub repositories to use squash-only merge strategy.
+
+## What it does
+
+This script updates all repositories you own on GitHub to:
+- ✅ Enable squash merges
+- ❌ Disable merge commits
+- ❌ Disable rebase merges
+
+It automatically skips repositories you don't own and provides a summary of the results.
+
+## Requirements
+
+- `bash` (version 4+)
+- `curl`
+- `jq`
+- GitHub authentication (see below)
+
+**Note:** If using the Node.js binary wrapper, you'll also need Node.js installed.
+
+## Authentication
+
+The script supports three methods for GitHub authentication (in order of preference):
+
+### 1. Environment Variable
+Set `GITHUB_TOKEN` in your environment:
+```bash
+export GITHUB_TOKEN=your_token_here
+./scripts/squash-only.sh
+```
+
+### 2. GitHub CLI (`gh`)
+If you have the GitHub CLI installed and authenticated:
+```bash
+gh auth login
+./scripts/squash-only.sh
+```
+
+### 3. Personal Access Token (PAT)
+If neither of the above are available, the script will display instructions for creating a PAT with the required permissions.
+
+**Required PAT permissions:**
+- `repo` (Full control of private repositories)
+
+## Installation & Usage
+
+You can run this tool in several ways:
+
+### Option 1: Using npx (Recommended - No Installation Required)
+
+Run directly from the GitHub repository without installing:
+```bash
+npx github:pRizz/squash-only
+```
+
+With custom sleep interval:
+```bash
+npx github:pRizz/squash-only --sleep 0.5
+```
+
+**Note:** If the package is published to npm, you can also use:
+```bash
+npx squash-only
+```
+
+### Option 2: Using the Bash Script Directly
+
+Run the bash script directly:
+```bash
+./scripts/squash-only.sh
+```
+
+With custom sleep interval:
+```bash
+./scripts/squash-only.sh --sleep 0.5
+# or
+./scripts/squash-only.sh -s 1.0
+```
+
+### Option 3: Run Locally with npm (Development)
+
+If you've cloned the repository, you can run it locally using npm scripts:
+```bash
+npm start
+# or
+npm run squash-only
+```
+
+With custom sleep interval:
+```bash
+npm start -- --sleep 0.5
+```
+
+You can also use `npx` to run the local version:
+```bash
+npx .
+```
+
+### Option 4: Install Globally via npm/pnpm
+
+Install the package globally:
+```bash
+npm install -g squash-only
+# or
+pnpm install -g squash-only
+```
+
+Then run it from anywhere:
+```bash
+squash-only
+```
+
+## Usage Examples
+
+### Basic usage
+```bash
+# Using npx (recommended)
+npx github:pRizz/squash-only
+
+# Or run locally with npm
+npm start
+
+# Or using the bash script directly
+./scripts/squash-only.sh
+```
+
+### Custom sleep interval
+Control the delay between API requests (default: 0.2 seconds):
+```bash
+# Using npx
+npx github:pRizz/squash-only --sleep 0.5
+
+# Or run locally with npm
+npm start -- --sleep 0.5
+
+# Or using the bash script
+./scripts/squash-only.sh --sleep 0.5
+# or
+./scripts/squash-only.sh -s 1.0
+```
+
+## Options
+
+- `-s, --sleep SECONDS` - Set the sleep interval between API requests (must be a number)
+
+## Features
+
+- 🔐 **Automatic authentication** - Tries multiple authentication methods
+- 📄 **Pagination support** - Handles users with 100+ repositories
+- 🔍 **Ownership filtering** - Only updates repositories you own
+- 📊 **Progress tracking** - Shows success, skipped, and failed counts
+- ⏱️ **Performance metrics** - Displays elapsed time
+- 🛡️ **Error handling** - Validates inputs and provides clear error messages
+
+## Output
+
+The script provides:
+- Real-time progress updates for each repository
+- Success/failure status for each update
+- A summary at the end showing:
+  - Number of successfully updated repositories
+  - Number of skipped repositories (not owned by you)
+  - Number of failed updates (if any)
+  - Total elapsed time
+
+Example output:
+```
+────────────────────────────────────
+Summary:
+  ✅ Successfully updated: 15
+  ⏭️  Skipped: 3
+  ⏱️  Elapsed time: 2m 30s
+```
+
+## Examples
+
+Update all your repos with default settings:
+```bash
+# Using npx (recommended)
+npx github:pRizz/squash-only
+
+# Or run locally with npm
+npm start
+
+# Or using the bash script
+./scripts/squash-only.sh
+```
+
+Update with a longer delay between requests:
+```bash
+# Using npx
+npx github:pRizz/squash-only --sleep 1.0
+
+# Or using the bash script
+./scripts/squash-only.sh --sleep 1.0
+```
+
+Use with environment variable:
+```bash
+# Using npx
+GITHUB_TOKEN=ghp_xxxxx npx github:pRizz/squash-only
+
+# Or run locally with npm
+GITHUB_TOKEN=ghp_xxxxx npm start
+
+# Or using the bash script
+GITHUB_TOKEN=ghp_xxxxx ./scripts/squash-only.sh
+```

package/bin/squash-only.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const scriptPath = path.join(__dirname, '..', 'scripts', 'squash-only.sh');
+
+// Check if script exists
+if (!fs.existsSync(scriptPath)) {
+  console.error(`❌ Error: Script not found at ${scriptPath}`);
+  process.exit(1);
+}
+
+// Get all arguments except node and script name
+const args = process.argv.slice(2);
+
+// Spawn the bash script with all arguments
+const child = spawn('bash', [scriptPath, ...args], {
+  stdio: 'inherit',
+  cwd: path.join(__dirname, '..'),
+});
+
+let isExiting = false;
+
+// Handle termination signals (Ctrl-C, etc.)
+const handleSignal = (signal) => {
+  if (isExiting) {
+    return;
+  }
+  isExiting = true;
+  
+  // Forward the signal to the child process
+  if (child && !child.killed) {
+    child.kill(signal);
+  }
+};
+
+process.on('SIGINT', handleSignal);
+process.on('SIGTERM', handleSignal);
+
+// Cleanup on process exit
+process.on('exit', () => {
+  if (child && !child.killed) {
+    child.kill('SIGTERM');
+  }
+});
+
+child.on('error', (error) => {
+  console.error(`❌ Error executing script: ${error.message}`);
+  process.exit(1);
+});
+
+child.on('exit', (code, signal) => {
+  // If child was killed by a signal, exit with appropriate code
+  if (signal) {
+    process.exit(signal === 'SIGINT' ? 130 : 143);
+  } else {
+    process.exit(code || 0);
+  }
+});
+

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "squash-only",
+  "version": "1.0.0",
+  "description": "Scripts for making all your repos on GitHub Squash Only!",
+  "bin": {
+    "squash-only": "./bin/squash-only.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "preferGlobal": true,
+  "scripts": {
+    "start": "node bin/squash-only.js",
+    "squash-only": "node bin/squash-only.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pRizz/squash-only.git"
+  },
+  "keywords": [
+    "squash",
+    "github",
+    "merge",
+    "squash-merge",
+    "cli",
+    "automation",
+    "git"
+  ],
+  "author": "Peter Ryszkiewicz",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pRizz/squash-only/issues"
+  },
+  "homepage": "https://github.com/pRizz/squash-only#readme"
+}

package/scripts/squash-only.sh

@@ -0,0 +1,260 @@
+#!/bin/bash
+set -uo pipefail
+
+SLEEP_SECS=0.2
+SHOULD_EXIT=0
+
+# Temporary files for tracking counts across subshells
+SUCCESS_COUNT_FILE=$(mktemp)
+SKIP_COUNT_FILE=$(mktemp)
+FAILED_COUNT_FILE=$(mktemp)
+
+cleanup() {
+  rm -f "$SUCCESS_COUNT_FILE" "$SKIP_COUNT_FILE" "$FAILED_COUNT_FILE"
+}
+trap cleanup EXIT
+
+# Handle termination signals
+handle_exit() {
+  SHOULD_EXIT=1
+  echo ""
+  echo "⚠️  Interrupted. Cleaning up..."
+  cleanup
+  exit 130
+}
+trap handle_exit INT TERM
+
+get_github_token() {
+  # Check if GITHUB_TOKEN is already in environment
+  if [ -n "${GITHUB_TOKEN:-}" ]; then
+    echo "$GITHUB_TOKEN"
+    return 0
+  fi
+
+  # Check if gh CLI is installed
+  if ! command -v gh &> /dev/null; then
+    print_pat_instructions
+    return 1
+  fi
+
+  # Try to get token from gh CLI
+  local maybeToken
+  maybeToken=$(gh auth token 2>/dev/null)
+  if [ -n "$maybeToken" ]; then
+    echo "$maybeToken"
+    return 0
+  fi
+
+  # gh is installed but no token available
+  print_pat_instructions
+  return 1
+}
+
+print_pat_instructions() {
+  cat << 'EOF'
+
+To use this script, you need a GitHub Personal Access Token (PAT).
+
+1. Go to https://github.com/settings/tokens/new
+2. Give your token a descriptive name (e.g., "Squash Only Script")
+3. Set an expiration (recommended: 90 days or custom)
+4. Select the following permissions:
+   - repo (Full control of private repositories)
+     - This includes: repo:status, repo_deployment, public_repo, repo:invite, security_events
+5. Click "Generate token"
+6. Copy the token and run this script with:
+   GITHUB_TOKEN=your_token_here ./scripts/squash-only.sh
+
+Alternatively, you can install the GitHub CLI (gh) and authenticate:
+  brew install gh
+  gh auth login
+
+EOF
+}
+
+increment_counter() {
+  local counter_file=$1
+  local current
+  current=$(cat "$counter_file")
+  echo $((current + 1)) > "$counter_file"
+}
+
+process_repo() {
+  local repo=$1
+  local owner=$2
+
+  # Check if we should exit
+  [ "$SHOULD_EXIT" -eq 1 ] && return 1
+
+  if [ -z "$repo" ] || [ "$repo" = "null" ]; then
+    return 0
+  fi
+
+  if [ "$owner" != "$GITHUB_USER" ]; then
+    echo "────────────────────────────────────"
+    echo "⏭️  Skipping repo: $repo (owned by $owner)"
+    increment_counter "$SKIP_COUNT_FILE"
+    return 0
+  fi
+
+  echo "────────────────────────────────────"
+  echo "Updating repo: $repo"
+
+  local http_code
+  http_code=$(curl -s --max-time 30 -o /dev/null -w "%{http_code}" \
+    -X PATCH \
+    -H "Authorization: token $GITHUB_TOKEN" \
+    -H "Accept: application/vnd.github+json" \
+    https://api.github.com/repos/$repo \
+    -d '{
+      "allow_merge_commit": false,
+      "allow_rebase_merge": false,
+      "allow_squash_merge": true
+    }')
+
+  # Check if we should exit after curl
+  [ "$SHOULD_EXIT" -eq 1 ] && return 1
+
+  if [ "$http_code" -eq 200 ]; then
+    echo "✅ Success ($http_code)"
+    echo "   https://github.com/$repo"
+    increment_counter "$SUCCESS_COUNT_FILE"
+  else
+    echo "❌ Failed ($http_code)"
+    increment_counter "$FAILED_COUNT_FILE"
+  fi
+
+  # Check again before sleeping
+  [ "$SHOULD_EXIT" -eq 1 ] && return 1
+
+  echo "Sleeping ${SLEEP_SECS}s…"
+  sleep "$SLEEP_SECS"
+}
+
+fetch_all_repos() {
+  local page=1
+  local per_page=100
+
+  while true; do
+    # Check if we should exit
+    [ "$SHOULD_EXIT" -eq 1 ] && break
+
+    local body
+    body=$(curl -s --max-time 30 -H "Authorization: token $GITHUB_TOKEN" \
+      "https://api.github.com/user/repos?per_page=$per_page&page=$page")
+
+    # Check if we should exit after curl
+    [ "$SHOULD_EXIT" -eq 1 ] && break
+
+    local repo_count
+    repo_count=$(echo "$body" | jq '. | length')
+    if [ -z "$repo_count" ] || [ "$repo_count" = "0" ] || [ "$repo_count" = "null" ]; then
+      break
+    fi
+
+    echo "$body" | jq -r '.[] | "\(.full_name)|\(.owner.login)"' | while IFS='|' read -r repo owner; do
+      [ "$SHOULD_EXIT" -eq 1 ] && break
+      process_repo "$repo" "$owner" || break
+    done
+
+    [ "$SHOULD_EXIT" -eq 1 ] && break
+
+    if [ "$repo_count" -lt "$per_page" ]; then
+      break
+    fi
+
+    page=$((page + 1))
+  done
+}
+
+is_number() {
+  local value=$1
+  if [[ "$value" =~ ^[0-9]+\.?[0-9]*$ ]]; then
+    return 0
+  fi
+  return 1
+}
+
+parse_args() {
+  while [[ $# -gt 0 ]]; do
+    case $1 in
+      -s|--sleep)
+        if [ -z "${2:-}" ]; then
+          echo "❌ Error: --sleep requires a value"
+          exit 1
+        fi
+        if ! is_number "$2"; then
+          echo "❌ Error: --sleep value must be a number (got: $2)"
+          exit 1
+        fi
+        SLEEP_SECS="$2"
+        shift 2
+        ;;
+      *)
+        echo "❌ Error: Unknown option: $1"
+        echo "Usage: $0 [--sleep SECONDS]"
+        exit 1
+        ;;
+    esac
+  done
+}
+
+main() {
+  parse_args "$@"
+
+  # Initialize counters
+  echo "0" > "$SUCCESS_COUNT_FILE"
+  echo "0" > "$SKIP_COUNT_FILE"
+  echo "0" > "$FAILED_COUNT_FILE"
+
+  echo "Updating all your repos to Squash Only!"
+  echo "→ Disables merge commits"
+  echo "→ Disables rebase merges"
+  echo "→ Enables squash merges"
+
+  echo "→ Logging in to GitHub…"
+  GITHUB_TOKEN=$(get_github_token)
+  if [ $? -ne 0 ]; then
+    exit 1
+  fi
+
+  echo "Fetching your username…"
+  GITHUB_USER=$(curl -s --max-time 30 -H "Authorization: token $GITHUB_TOKEN" \
+    https://api.github.com/user | jq -r '.login')
+  
+  # Check if we should exit
+  [ "$SHOULD_EXIT" -eq 1 ] && exit 130
+
+  if [ -z "$GITHUB_USER" ] || [ "$GITHUB_USER" = "null" ]; then
+    echo "❌ Failed to get GitHub username"
+    exit 1
+  fi
+
+  echo "Fetching your repos…"
+  START_TIME=$(date +%s)
+  fetch_all_repos
+  END_TIME=$(date +%s)
+
+  ELAPSED=$((END_TIME - START_TIME))
+  ELAPSED_MIN=$((ELAPSED / 60))
+  ELAPSED_SEC=$((ELAPSED % 60))
+
+  echo ""
+  echo "────────────────────────────────────"
+  echo "Summary:"
+  SUCCESS_COUNT=$(cat "$SUCCESS_COUNT_FILE")
+  SKIP_COUNT=$(cat "$SKIP_COUNT_FILE")
+  FAILED_COUNT=$(cat "$FAILED_COUNT_FILE")
+  echo "  ✅ Successfully updated: $SUCCESS_COUNT"
+  echo "  ⏭️  Skipped: $SKIP_COUNT"
+  if [ "$FAILED_COUNT" -gt 0 ]; then
+    echo "  ❌ Failed: $FAILED_COUNT"
+  fi
+  if [ "$ELAPSED_MIN" -gt 0 ]; then
+    echo "  ⏱️  Elapsed time: ${ELAPSED_MIN}m ${ELAPSED_SEC}s"
+  else
+    echo "  ⏱️  Elapsed time: ${ELAPSED}s"
+  fi
+}
+
+main "$@"