squash-only 2.0.0 → 3.0.0

package/README.md

@@ -15,7 +15,11 @@ This script updates all repositories you own on GitHub to:
 - ❌ Disable merge commits
 - ❌ Disable rebase merges
 
-It automatically skips repositories you don't own and provides a summary of the results.
+It automatically:
+- Skips repositories you don't own
+- Skips repositories that are already configured for squash-only (efficient reruns; no unnecessary network requests)
+- Only processes repositories that need updating
+- Provides a summary of the results
 
 ## Requirements
 
@@ -68,6 +72,11 @@ With custom sleep interval:
 npx github:pRizz/squash-only --sleep 0.5
 ```
 
+With force flag (process all repos, including already squash-only):
+```bash
+npx github:pRizz/squash-only --force
+```
+
 **Note:** If the package is published to npm, you can also use:
 ```bash
 npx squash-only
@@ -87,6 +96,13 @@ With custom sleep interval:
 ./scripts/squash-only.sh -s 1.0
 ```
 
+With force flag (process all repos, including already squash-only):
+```bash
+./scripts/squash-only.sh --force
+# or
+./scripts/squash-only.sh -f
+```
+
 ### Option 3: Run Locally with npm (Development)
 
 If you've cloned the repository, you can run it locally using npm scripts:
@@ -101,6 +117,11 @@ With custom sleep interval:
 npm start -- --sleep 0.5
 ```
 
+With force flag:
+```bash
+npm start -- --force
+```
+
 You can also use `npx` to run the local version:
 ```bash
 npx .
@@ -149,19 +170,51 @@ npm start -- --sleep 0.5
 ./scripts/squash-only.sh -s 1.0
 ```
 
+### Force mode
+Process all repositories, including those already configured for squash-only:
+```bash
+# Using npx
+npx github:pRizz/squash-only --force
+
+# Or run locally with npm
+npm start -- --force
+
+# Or using the bash script
+./scripts/squash-only.sh --force
+# or
+./scripts/squash-only.sh -f
+```
+
+Combine options:
+```bash
+npx github:pRizz/squash-only --force --sleep 0.5
+```
+
 ## Options
 
-- `-s, --sleep SECONDS` - Set the sleep interval between API requests (must be a number)
+- `-s, --sleep SECONDS` - Set the sleep interval between API requests (default: 0.1 seconds). This delay helps prevent triggering GitHub's rate limits. Authenticated requests (OAuth or PAT) are limited to ~5,000 requests per hour per user or app. See [GitHub's API rate limits documentation](https://github.com/orgs/community/discussions/163553) for more details.
+- `-f, --force` - Process all repositories, including those already configured for squash-only (default: skip already configured repos)
 
 ## 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
+- ⚡ **Smart skipping** - Automatically skips repositories already configured for squash-only (efficient reruns and new repo handling)
+- 📊 **Progress tracking** - Shows success, skipped, already configured, and failed counts
 - ⏱️ **Performance metrics** - Displays elapsed time
 - 🛡️ **Error handling** - Validates inputs and provides clear error messages
 
+## Technical Details
+
+This script uses a hybrid approach for GitHub API access:
+
+- **GraphQL API** - Used to fetch repositories and their merge strategies in a single, efficient query with cursor-based pagination. This allows us to retrieve all repository information and merge strategy settings in fewer API calls.
+
+- **REST API** - Used to update repository merge strategies. As of January 11, 2026, the GitHub GraphQL API does not support mutations for repository merge strategy settings, so the REST API is required for this operation. Therefore, we must call the REST endpoint for each repository individually to update its merge strategy settings.
+
+- **Rate Limiting** - To avoid hitting GitHub's API rate limits, the script includes a configurable sleep interval between REST API requests (default: 0.1 seconds). Authenticated requests (OAuth or PAT) are limited to ~5,000 requests per hour per user or app. The sleep delay helps ensure we stay well below this limit when processing large numbers of repositories. See [GitHub's API rate limits documentation](https://github.com/orgs/community/discussions/163553) for more details.
+
 ## Output
 
 The script provides:
@@ -169,6 +222,7 @@ The script provides:
 - Success/failure status for each update
 - A summary at the end showing:
   - Number of successfully updated repositories
+  - Number of repositories already configured for squash-only (skipped)
   - Number of skipped repositories (not owned by you)
   - Number of failed updates (if any)
   - Total elapsed time
@@ -177,9 +231,10 @@ Example output:
 ```
 ────────────────────────────────────
 Summary:
-  ✅ Successfully updated: 15
-  ⏭️  Skipped: 3
-  ⏱️  Elapsed time: 2m 30s
+  ✅ Successfully updated: 5
+  ⏭️  Already squash-only (skipped): 10
+  ⏭️  Skipped (not owned by you): 3
+  ⏱️  Elapsed time: 1m 15s
 ```
 
 ## Examples
@@ -205,6 +260,15 @@ npx github:pRizz/squash-only --sleep 1.0
 ./scripts/squash-only.sh --sleep 1.0
 ```
 
+Force update all repositories (including already configured):
+```bash
+# Using npx
+npx github:pRizz/squash-only --force
+
+# Or using the bash script
+./scripts/squash-only.sh --force
+```
+
 Use with environment variable:
 ```bash
 # Using npx

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squash-only",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Scripts for making all your repos on GitHub Squash Only!",
   "bin": {
     "squash-only": "./bin/squash-only.js"

package/scripts/squash-only.sh

@@ -2,16 +2,20 @@
 
 set -uo pipefail
 
-SLEEP_SECS=0.2
+SLEEP_SECS=0.1
 SHOULD_EXIT=0
 
 # Temporary files for tracking counts across subshells
 SUCCESS_COUNT_FILE=$(mktemp)
 SKIP_COUNT_FILE=$(mktemp)
 FAILED_COUNT_FILE=$(mktemp)
+ALREADY_SQUASH_ONLY_COUNT_FILE=$(mktemp)
+
+# Flag to force processing all repos even if they already have squash-only enabled
+FORCE_FLAG=0
 
 cleanup() {
-  rm -f "$SUCCESS_COUNT_FILE" "$SKIP_COUNT_FILE" "$FAILED_COUNT_FILE"
+  rm -f "$SUCCESS_COUNT_FILE" "$SKIP_COUNT_FILE" "$FAILED_COUNT_FILE" "$ALREADY_SQUASH_ONLY_COUNT_FILE"
 }
 trap cleanup EXIT
 
@@ -99,9 +103,36 @@ increment_counter() {
   echo $((current + 1)) > "$counter_file"
 }
 
+is_squash_only() {
+  local allow_squash_merge=$1
+  local allow_merge_commit=$2
+  local allow_rebase_merge=$3
+
+  # Treat empty, "null", or missing values as false
+  [ -z "$allow_squash_merge" ] && allow_squash_merge="false"
+  [ "$allow_squash_merge" = "null" ] && allow_squash_merge="false"
+  [ -z "$allow_merge_commit" ] && allow_merge_commit="false"
+  [ "$allow_merge_commit" = "null" ] && allow_merge_commit="false"
+  [ -z "$allow_rebase_merge" ] && allow_rebase_merge="false"
+  [ "$allow_rebase_merge" = "null" ] && allow_rebase_merge="false"
+
+  # Normalize case (in case of unexpected casing)
+  allow_squash_merge=$(echo "$allow_squash_merge" | tr '[:upper:]' '[:lower:]')
+  allow_merge_commit=$(echo "$allow_merge_commit" | tr '[:upper:]' '[:lower:]')
+  allow_rebase_merge=$(echo "$allow_rebase_merge" | tr '[:upper:]' '[:lower:]')
+
+  if [ "$allow_squash_merge" = "true" ] && [ "$allow_merge_commit" = "false" ] && [ "$allow_rebase_merge" = "false" ]; then
+    return 0
+  fi
+  return 1
+}
+
 process_repo() {
   local repo=$1
   local owner=$2
+  local allow_squash_merge=$3
+  local allow_merge_commit=$4
+  local allow_rebase_merge=$5
 
   # Check if we should exit
   [ "$SHOULD_EXIT" -eq 1 ] && return 1
@@ -117,8 +148,20 @@ process_repo() {
     return 0
   fi
 
+  # Check if repo already has squash-only enabled
+  if [ "$FORCE_FLAG" -eq 0 ] && is_squash_only "$allow_squash_merge" "$allow_merge_commit" "$allow_rebase_merge"; then
+    echo "────────────────────────────────────"
+    echo "⏭️  Skipping repo: $repo (already squash-only)"
+    increment_counter "$ALREADY_SQUASH_ONLY_COUNT_FILE"
+    return 0
+  fi
+
   echo "────────────────────────────────────"
-  echo "Updating repo: $repo"
+  if [ "$FORCE_FLAG" -eq 1 ] && is_squash_only "$allow_squash_merge" "$allow_merge_commit" "$allow_rebase_merge"; then
+    echo "Updating repo: $repo (forced, already squash-only)"
+  else
+    echo "Updating repo: $repo"
+  fi
 
   local http_code
   http_code=$(curl -s --max-time 30 -o /dev/null -w "%{http_code}" \
@@ -151,42 +194,174 @@ process_repo() {
   sleep "$SLEEP_SECS"
 }
 
-fetch_all_repos() {
-  local page=1
-  local per_page=100
+# Executes a GraphQL query and returns the response
+execute_graphql_query() {
+  local query=$1
+  local variables_json=$2
+
+  local payload
+  if [ -n "$variables_json" ]; then
+    payload=$(jq -n \
+      --arg query "$query" \
+      --argjson variables "$variables_json" \
+      '{query: $query, variables: $variables}')
+  else
+    payload=$(jq -n \
+      --arg query "$query" \
+      '{query: $query}')
+  fi
+
+  local response
+  response=$(curl -sS --max-time 30 \
+    -H "Authorization: Bearer $GITHUB_TOKEN" \
+    -H "Content-Type: application/json" \
+    -H "Accept: application/vnd.github+json" \
+    https://api.github.com/graphql \
+    -d "$payload")
+
+  # Check for GraphQL errors
+  local errors
+  errors=$(echo "$response" | jq -r '.errors // empty')
+  if [ -n "$errors" ]; then
+    echo "GraphQL error: $errors" >&2
+    return 1
+  fi
+
+  echo "$response"
+}
+
+# Fetches all repos with merge strategies for a given owner using GraphQL
+# Uses repositoryOwner query with pagination
+# Returns JSON array with repos and their merge strategy info
+fetch_repos_with_strategies() {
+  local owner=$1
+
+  read -r -d '' QUERY <<'GRAPHQL'
+query($login: String!, $first: Int!, $after: String) {
+  repositoryOwner(login: $login) {
+    repositories(first: $first, after: $after) {
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+      nodes {
+        name
+        owner {
+          login
+        }
+        mergeCommitAllowed
+        squashMergeAllowed
+        rebaseMergeAllowed
+        autoMergeAllowed
+      }
+    }
+  }
+}
+GRAPHQL
+
+  local all_repos="[]"
+  local after_cursor=""
+  local first=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")
+    # Build variables JSON
+    local variables_json
+    if [ -n "$after_cursor" ]; then
+      variables_json=$(jq -n \
+        --arg login "$owner" \
+        --argjson first "$first" \
+        --arg after "$after_cursor" \
+        '{login: $login, first: $first, after: $after}')
+    else
+      variables_json=$(jq -n \
+        --arg login "$owner" \
+        --argjson first "$first" \
+        '{login: $login, first: $first}')
+    fi
+
+    # Execute GraphQL query
+    local response
+    response=$(execute_graphql_query "$QUERY" "$variables_json")
+    if [ $? -ne 0 ]; then
+      return 1
+    fi
 
-    # Check if we should exit after curl
     [ "$SHOULD_EXIT" -eq 1 ] && break
 
+    # Extract repos from response
+    local repos
+    repos=$(echo "$response" | jq '.data.repositoryOwner.repositories.nodes // []')
+
+    # Check if we got any repos
     local repo_count
-    repo_count=$(echo "$body" | jq '. | length')
-    if [ -z "$repo_count" ] || [ "$repo_count" = "0" ] || [ "$repo_count" = "null" ]; then
+    repo_count=$(echo "$repos" | jq '. | length')
+    if [ "$repo_count" -eq 0 ]; then
       break
     fi
 
-    # NOTE: Avoid a pipeline into `while` here; that runs the loop in a subshell and
-    # breaks exit/interrupt handling and control flow.
-    while IFS='|' read -r repo owner; do
-      [ "$SHOULD_EXIT" -eq 1 ] && break
-      process_repo "$repo" "$owner" || break
-    done < <(echo "$body" | jq -r '.[] | "\(.full_name)|\(.owner.login)"')
+    # Merge repos into all_repos
+    all_repos=$(echo "$all_repos" "$repos" | jq -s 'add')
 
-    [ "$SHOULD_EXIT" -eq 1 ] && break
+    # Check pagination info
+    local has_next_page
+    has_next_page=$(echo "$response" | jq -r '.data.repositoryOwner.repositories.pageInfo.hasNextPage')
+    after_cursor=$(echo "$response" | jq -r '.data.repositoryOwner.repositories.pageInfo.endCursor // ""')
 
-    if [ "$repo_count" -lt "$per_page" ]; then
+    if [ "$has_next_page" != "true" ] || [ -z "$after_cursor" ]; then
       break
     fi
-
-    page=$((page + 1))
   done
+
+  echo "$all_repos"
+}
+
+# Processes repos with their merge strategies
+# Takes JSON array of repos with name, owner.login, and merge strategy flags
+process_repos_with_strategies() {
+  local repos_json=$1
+
+  while IFS= read -r line; do
+    [ "$SHOULD_EXIT" -eq 1 ] && break
+
+    # Parse the line: full_name|owner|squash|merge|rebase
+    IFS='|' read -r repo owner allow_squash_merge allow_merge_commit allow_rebase_merge <<< "$line"
+
+    # Trim leading/trailing whitespace
+    repo=$(echo "$repo" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+    owner=$(echo "$owner" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+    allow_squash_merge=$(echo "$allow_squash_merge" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+    allow_merge_commit=$(echo "$allow_merge_commit" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+    allow_rebase_merge=$(echo "$allow_rebase_merge" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+
+    process_repo "$repo" "$owner" "$allow_squash_merge" "$allow_merge_commit" "$allow_rebase_merge" || break
+  done < <(echo "$repos_json" | jq -r '.[] | 
+    "\(.owner.login)/\(.name)|\(.owner.login)|\(
+      if .squashMergeAllowed == null then false else .squashMergeAllowed end
+    )|\(
+      if .mergeCommitAllowed == null then false else .mergeCommitAllowed end
+    )|\(
+      if .rebaseMergeAllowed == null then false else .rebaseMergeAllowed end
+    )"')
+}
+
+fetch_all_repos() {
+  # Fetch all repos with merge strategies using GraphQL
+  local repos_json
+  repos_json=$(fetch_repos_with_strategies "$GITHUB_USER")
+  if [ $? -ne 0 ]; then
+    echo "❌ Failed to fetch repos" >&2
+    return 1
+  fi
+
+  if [ -z "$repos_json" ] || [ "$repos_json" = "[]" ]; then
+    echo "❌ No repos found" >&2
+    return 0
+  fi
+
+  # Process repos with their merge strategies
+  process_repos_with_strategies "$repos_json"
 }
 
 is_number() {
@@ -212,9 +387,13 @@ parse_args() {
         SLEEP_SECS="$2"
         shift 2
         ;;
+      -f|--force)
+        FORCE_FLAG=1
+        shift
+        ;;
       *)
         echo "❌ Error: Unknown option: $1"
-        echo "Usage: $0 [--sleep SECONDS]"
+        echo "Usage: $0 [--sleep SECONDS] [--force]"
         exit 1
         ;;
     esac
@@ -232,11 +411,17 @@ main() {
   echo "0" > "$SUCCESS_COUNT_FILE"
   echo "0" > "$SKIP_COUNT_FILE"
   echo "0" > "$FAILED_COUNT_FILE"
+  echo "0" > "$ALREADY_SQUASH_ONLY_COUNT_FILE"
 
   echo "Updating all your repos to Squash Only!"
   echo "→ Disables merge commits"
   echo "→ Disables rebase merges"
   echo "→ Enables squash merges"
+  if [ "$FORCE_FLAG" -eq 1 ]; then
+    echo "→ Force mode: processing all repos (including already squash-only)"
+  else
+    echo "→ Skipping repos that are already squash-only (use --force to process all)"
+  fi
 
   echo "→ Logging in to GitHub…"
   GITHUB_TOKEN=$(get_github_token)
@@ -271,8 +456,14 @@ main() {
   SUCCESS_COUNT=$(cat "$SUCCESS_COUNT_FILE")
   SKIP_COUNT=$(cat "$SKIP_COUNT_FILE")
   FAILED_COUNT=$(cat "$FAILED_COUNT_FILE")
+  ALREADY_SQUASH_ONLY_COUNT=$(cat "$ALREADY_SQUASH_ONLY_COUNT_FILE")
   echo "  ✅ Successfully updated: $SUCCESS_COUNT"
-  echo "  ⏭️  Skipped: $SKIP_COUNT"
+  if [ "$ALREADY_SQUASH_ONLY_COUNT" -gt 0 ]; then
+    echo "  ⏭️  Already squash-only (skipped): $ALREADY_SQUASH_ONLY_COUNT"
+  fi
+  if [ "$SKIP_COUNT" -gt 0 ]; then
+    echo "  ⏭️  Skipped (not owned by you): $SKIP_COUNT"
+  fi
   if [ "$FAILED_COUNT" -gt 0 ]; then
     echo "  ❌ Failed: $FAILED_COUNT"
   fi