fix(scripts): deduplicate number extraction and branch scanning logic

rhuss · rhuss · commit 8d4710dc8b98 · 2026-03-28T07:09:55.000+01:00
Extract shared _extract_highest_number helper (bash) and
Get-HighestNumberFromNames (PowerShell) to eliminate duplicated
number extraction patterns between local branch and remote ref
scanning.

Add SkipFetch/skip_fetch parameter to check_existing_branches /
Get-NextBranchNumber so dry-run reuses the same function instead
of inlining duplicate max-of-branches-and-specs logic.

Assisted-By: 🤖 Claude Code
diff --git a/scripts/bash/create-new-feature.sh b/scripts/bash/create-new-feature.sh
@@ -115,27 +115,23 @@ get_highest_from_specs() {
 
 # Function to get highest number from git branches
 get_highest_from_branches() {
+    git branch -a 2>/dev/null | sed 's/^[* ]*//; s|^remotes/[^/]*/||' | _extract_highest_number
+}
+
+# Extract the highest sequential feature number from a list of ref names (one per line).
+# Shared by get_highest_from_branches and get_highest_from_remote_refs.
+_extract_highest_number() {
     local highest=0
-    
-    # Get all branches (local and remote)
-    branches=$(git branch -a 2>/dev/null || echo "")
-    
-    if [ -n "$branches" ]; then
-        while IFS= read -r branch; do
-            # Clean branch name: remove leading markers and remote prefixes
-            clean_branch=$(echo "$branch" | sed 's/^[* ]*//; s|^remotes/[^/]*/||')
-            
-            # Extract sequential feature number (>=3 digits), skip timestamp branches.
-            if echo "$clean_branch" | grep -Eq '^[0-9]{3,}-' && ! echo "$clean_branch" | grep -Eq '^[0-9]{8}-[0-9]{6}-'; then
-                number=$(echo "$clean_branch" | grep -Eo '^[0-9]+' || echo "0")
-                number=$((10#$number))
-                if [ "$number" -gt "$highest" ]; then
-                    highest=$number
-                fi
+    while IFS= read -r name; do
+        [ -z "$name" ] && continue
+        if echo "$name" | grep -Eq '^[0-9]{3,}-' && ! echo "$name" | grep -Eq '^[0-9]{8}-[0-9]{6}-'; then
+            number=$(echo "$name" | grep -Eo '^[0-9]+' || echo "0")
+            number=$((10#$number))
+            if [ "$number" -gt "$highest" ]; then
+                highest=$number
             fi
-        done <<< "$branches"
-    fi
-    
+        fi
+    done
     echo "$highest"
 }
 
@@ -144,32 +140,34 @@ get_highest_from_remote_refs() {
     local highest=0
 
     for remote in $(git remote 2>/dev/null); do
-        while IFS= read -r line; do
-            [ -z "$line" ] && continue
-            # Extract ref name from ls-remote output (hash\trefs/heads/branch-name)
-            ref="${line##*/}"
-            if echo "$ref" | grep -Eq '^[0-9]{3,}-' && ! echo "$ref" | grep -Eq '^[0-9]{8}-[0-9]{6}-'; then
-                number=$(echo "$ref" | grep -Eo '^[0-9]+' || echo "0")
-                number=$((10#$number))
-                if [ "$number" -gt "$highest" ]; then
-                    highest=$number
-                fi
-            fi
-        done <<< "$(git ls-remote --heads "$remote" 2>/dev/null || echo "")"
+        local remote_highest
+        remote_highest=$(git ls-remote --heads "$remote" 2>/dev/null | sed 's|.*refs/heads/||' | _extract_highest_number)
+        if [ "$remote_highest" -gt "$highest" ]; then
+            highest=$remote_highest
+        fi
     done
 
     echo "$highest"
 }
 
-# Function to check existing branches (local and remote) and return next available number
+# Function to check existing branches (local and remote) and return next available number.
+# When skip_fetch is true, queries remotes via ls-remote (read-only) instead of fetching.
 check_existing_branches() {
     local specs_dir="$1"
-
-    # Fetch all remotes to get latest branch info (suppress errors if no remotes)
-    git fetch --all --prune >/dev/null 2>&1 || true
-
-    # Get highest number from ALL branches (not just matching short name)
-    local highest_branch=$(get_highest_from_branches)
+    local skip_fetch="${2:-false}"
+
+    if [ "$skip_fetch" = true ]; then
+        # Side-effect-free: query remotes via ls-remote
+        local highest_remote=$(get_highest_from_remote_refs)
+        local highest_branch=$(get_highest_from_branches)
+        if [ "$highest_remote" -gt "$highest_branch" ]; then
+            highest_branch=$highest_remote
+        fi
+    else
+        # Fetch all remotes to get latest branch info (suppress errors if no remotes)
+        git fetch --all --prune >/dev/null 2>&1 || true
+        local highest_branch=$(get_highest_from_branches)
+    fi
 
     # Get highest number from ALL specs (not just matching short name)
     local highest_spec=$(get_highest_from_specs "$specs_dir")
@@ -280,22 +278,13 @@ if [ "$USE_TIMESTAMP" = true ]; then
 else
     # Determine branch number
     if [ -z "$BRANCH_NUMBER" ]; then
-        if [ "$DRY_RUN" = true ]; then
-            # Dry-run: query remote refs without fetching (side-effect-free)
-            _highest_branch=0
-            if [ "$HAS_GIT" = true ]; then
-                _highest_branch=$(get_highest_from_branches)
-                _highest_remote=$(get_highest_from_remote_refs)
-                if [ "$_highest_remote" -gt "$_highest_branch" ]; then
-                    _highest_branch=$_highest_remote
-                fi
-            fi
-            _highest_spec=$(get_highest_from_specs "$SPECS_DIR")
-            _max_num=$_highest_branch
-            if [ "$_highest_spec" -gt "$_max_num" ]; then
-                _max_num=$_highest_spec
-            fi
-            BRANCH_NUMBER=$((_max_num + 1))
+        if [ "$DRY_RUN" = true ] && [ "$HAS_GIT" = true ]; then
+            # Dry-run: query remotes via ls-remote (side-effect-free, no fetch)
+            BRANCH_NUMBER=$(check_existing_branches "$SPECS_DIR" true)
+        elif [ "$DRY_RUN" = true ]; then
+            # Dry-run without git: local spec dirs only
+            HIGHEST=$(get_highest_from_specs "$SPECS_DIR")
+            BRANCH_NUMBER=$((HIGHEST + 1))
         elif [ "$HAS_GIT" = true ]; then
             # Check existing branches on remotes
             BRANCH_NUMBER=$(check_existing_branches "$SPECS_DIR")
diff --git a/scripts/powershell/create-new-feature.ps1 b/scripts/powershell/create-new-feature.ps1
@@ -67,31 +67,38 @@ function Get-HighestNumberFromSpecs {
     return $highest
 }
 
+# Extract the highest sequential feature number from a list of branch/ref names.
+# Shared by Get-HighestNumberFromBranches and Get-HighestNumberFromRemoteRefs.
+function Get-HighestNumberFromNames {
+    param([string[]]$Names)
+
+    [long]$highest = 0
+    foreach ($name in $Names) {
+        if ($name -match '^(\d{3,})-' -and $name -notmatch '^\d{8}-\d{6}-') {
+            [long]$num = 0
+            if ([long]::TryParse($matches[1], [ref]$num) -and $num -gt $highest) {
+                $highest = $num
+            }
+        }
+    }
+    return $highest
+}
+
 function Get-HighestNumberFromBranches {
     param()
 
-    [long]$highest = 0
     try {
         $branches = git branch -a 2>$null
-        if ($LASTEXITCODE -eq 0) {
-            foreach ($branch in $branches) {
-                # Clean branch name: remove leading markers and remote prefixes
-                $cleanBranch = $branch.Trim() -replace '^\*?\s+', '' -replace '^remotes/[^/]+/', ''
-
-                # Extract sequential feature number (>=3 digits), skip timestamp branches.
-                if ($cleanBranch -match '^(\d{3,})-' -and $cleanBranch -notmatch '^\d{8}-\d{6}-') {
-                    [long]$num = 0
-                    if ([long]::TryParse($matches[1], [ref]$num) -and $num -gt $highest) {
-                        $highest = $num
-                    }
-                }
+        if ($LASTEXITCODE -eq 0 -and $branches) {
+            $cleanNames = $branches | ForEach-Object {
+                $_.Trim() -replace '^\*?\s+', '' -replace '^remotes/[^/]+/', ''
             }
+            return Get-HighestNumberFromNames -Names $cleanNames
         }
     } catch {
-        # If git command fails, return 0
         Write-Verbose "Could not check Git branches: $_"
     }
-    return $highest
+    return 0
 }
 
 function Get-HighestNumberFromRemoteRefs {
@@ -102,18 +109,11 @@ function Get-HighestNumberFromRemoteRefs {
             foreach ($remote in $remotes) {
                 $refs = git ls-remote --heads $remote 2>$null
                 if ($LASTEXITCODE -eq 0 -and $refs) {
-                    foreach ($line in $refs) {
-                        # Extract branch name from refs/heads/branch-name
-                        if ($line -match 'refs/heads/(.+)$') {
-                            $ref = $matches[1]
-                            if ($ref -match '^(\d{3,})-' -and $ref -notmatch '^\d{8}-\d{6}-') {
-                                [long]$num = 0
-                                if ([long]::TryParse($matches[1], [ref]$num) -and $num -gt $highest) {
-                                    $highest = $num
-                                }
-                            }
-                        }
-                    }
+                    $refNames = $refs | ForEach-Object {
+                        if ($_ -match 'refs/heads/(.+)$') { $matches[1] }
+                    } | Where-Object { $_ }
+                    $remoteHighest = Get-HighestNumberFromNames -Names $refNames
+                    if ($remoteHighest -gt $highest) { $highest = $remoteHighest }
                 }
             }
         }
@@ -123,21 +123,29 @@ function Get-HighestNumberFromRemoteRefs {
     return $highest
 }
 
+# Return next available branch number. When SkipFetch is true, queries remotes
+# via ls-remote (read-only) instead of fetching.
 function Get-NextBranchNumber {
     param(
-        [string]$SpecsDir
+        [string]$SpecsDir,
+        [switch]$SkipFetch
     )
 
-    # Fetch all remotes to get latest branch info (suppress errors if no remotes)
-    try {
-        git fetch --all --prune 2>$null | Out-Null
-    } catch {
-        # Ignore fetch errors
+    if ($SkipFetch) {
+        # Side-effect-free: query remotes via ls-remote
+        $highestBranch = Get-HighestNumberFromBranches
+        $highestRemote = Get-HighestNumberFromRemoteRefs
+        $highestBranch = [Math]::Max($highestBranch, $highestRemote)
+    } else {
+        # Fetch all remotes to get latest branch info (suppress errors if no remotes)
+        try {
+            git fetch --all --prune 2>$null | Out-Null
+        } catch {
+            # Ignore fetch errors
+        }
+        $highestBranch = Get-HighestNumberFromBranches
     }
 
-    # Get highest number from ALL branches (not just matching short name)
-    $highestBranch = Get-HighestNumberFromBranches
-
     # Get highest number from ALL specs (not just matching short name)
     $highestSpec = Get-HighestNumberFromSpecs -SpecsDir $SpecsDir
 
@@ -236,16 +244,12 @@ if ($Timestamp) {
 } else {
     # Determine branch number
     if ($Number -eq 0) {
-        if ($DryRun) {
-            # Dry-run: query remote refs without fetching (side-effect-free)
-            $highestBranch = 0
-            if ($hasGit) {
-                $highestBranch = Get-HighestNumberFromBranches
-                $highestRemote = Get-HighestNumberFromRemoteRefs
-                $highestBranch = [Math]::Max($highestBranch, $highestRemote)
-            }
-            $highestSpec = Get-HighestNumberFromSpecs -SpecsDir $specsDir
-            $Number = [Math]::Max($highestBranch, $highestSpec) + 1
+        if ($DryRun -and $hasGit) {
+            # Dry-run: query remotes via ls-remote (side-effect-free, no fetch)
+            $Number = Get-NextBranchNumber -SpecsDir $specsDir -SkipFetch
+        } elseif ($DryRun) {
+            # Dry-run without git: local spec dirs only
+            $Number = (Get-HighestNumberFromSpecs -SpecsDir $specsDir) + 1
         } elseif ($hasGit) {
             # Check existing branches on remotes
             $Number = Get-NextBranchNumber -SpecsDir $specsDir
