beads/internal/utils/issue_id.go
Kevin Glynn c5961c4f6f
fix(sort): natural numeric sort for issue IDs with dotted suffixes (GH#3477) (#3486)
Issue IDs like bd-E.10 now sort after bd-E.9 instead of before bd-E.2.
Adds NaturalCompareIDs to internal/utils and replaces string comparison
in list, graph, swarm, todo, and tree display code.

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-27 07:04:37 -07:00

191 lines
5.7 KiB
Go

package utils
import (
"fmt"
"sort"
"strconv"
"strings"
)
// ExtractIssuePrefix extracts the prefix from an issue ID like "bd-123" -> "bd"
// Uses the last hyphen before a numeric or hash-like suffix:
// - "beads-vscode-1" -> "beads-vscode" (numeric suffix)
// - "web-app-a3f8e9" -> "web-app" (hash suffix with digits)
// - "my-cool-app-123" -> "my-cool-app" (numeric suffix)
// - "bd-a3f" -> "bd" (3-char hash)
//
// Falls back to first hyphen when suffix looks like an English word (4+ chars, no digits):
// - "vc-baseline-test" -> "vc" (word-like suffix: "test" is not a hash)
// - "bd-multi-part-id" -> "bd" (word-like suffix: "id" is too short but "part-id" path)
//
// This distinguishes hash IDs (which may contain letters but have digits or are 3 chars)
// from multi-part IDs where the suffix after the first hyphen is the entire ID.
func ExtractIssuePrefix(issueID string) string {
// Try last hyphen first (handles multi-part prefixes like "beads-vscode-1")
lastIdx := strings.LastIndex(issueID, "-")
if lastIdx <= 0 {
return ""
}
suffix := issueID[lastIdx+1:]
if len(suffix) == 0 {
// Trailing hyphen like "bd-" - return prefix before the hyphen
return issueID[:lastIdx]
}
// Extract the base part before any dot (handle "123.1.2" -> check "123")
basePart := suffix
if dotIdx := strings.Index(suffix, "."); dotIdx > 0 {
basePart = suffix[:dotIdx]
}
// Check if this looks like a valid issue ID suffix (numeric or hash-like)
// Use isLikelyHash which requires digits for 4+ char suffixes to avoid
// treating English words like "test", "gate", "part" as hash IDs
if isNumeric(basePart) || isLikelyHash(basePart) {
return issueID[:lastIdx]
}
// Suffix looks like an English word (4+ chars, no digits) or contains special chars
// Fall back to first hyphen - the entire part after first hyphen is the ID
firstIdx := strings.Index(issueID, "-")
if firstIdx <= 0 {
return ""
}
return issueID[:firstIdx]
}
// isNumeric checks if a string contains only digits
func isNumeric(s string) bool {
if len(s) == 0 {
return false
}
for _, c := range s {
if c < '0' || c > '9' {
return false
}
}
return true
}
// isLikelyHash checks if a string looks like a hash ID suffix.
// Returns true for base36 strings of 3-8 characters (0-9, a-z).
//
// For 3-char suffixes: accepts all base36 (including all-letter like "bat", "dev").
// For 4+ char suffixes: requires at least one digit to distinguish from English words.
//
// Rationale (word collision probability):
// - 3-char: 36³ = 46K hashes, ~1000 common words = ~2% (accept false positives)
// - 4-char: 36⁴ = 1.6M hashes, ~3000 words = ~0.2% (digit requirement is safe)
// - 5+ char: collision rate negligible
//
// Hash IDs in beads use adaptive length scaling from 3-8 characters.
func isLikelyHash(s string) bool {
if len(s) < 3 || len(s) > 8 {
return false
}
// 3-char suffixes get a free pass (word collision acceptable)
// 4+ char suffixes require at least one digit
hasDigit := len(s) == 3
// Check if all characters are base36 (0-9, a-z)
for _, c := range s {
if c >= '0' && c <= '9' {
hasDigit = true
}
if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
return false
}
}
return hasDigit
}
// ExtractIssuePrefixKnown extracts the prefix from an issue ID using a list of
// known-valid prefixes before falling back to the heuristic ExtractIssuePrefix.
//
// When the valid prefixes are known from config (issue_prefix + allowed_prefixes),
// this gives deterministic results for multi-hyphen prefixes that the heuristic
// might misclassify (e.g., "me-py-toolkit-abcd" where "abcd" looks word-like).
//
// Prefixes are checked longest-first so overlapping entries (e.g., "hq" and "hq-cv")
// resolve to the most specific match.
func ExtractIssuePrefixKnown(issueID string, knownPrefixes []string) string {
// Normalize: trim whitespace, strip trailing hyphens, drop empties
var cleaned []string
for _, p := range knownPrefixes {
p = strings.TrimSpace(p)
p = strings.TrimSuffix(p, "-")
if p != "" {
cleaned = append(cleaned, p)
}
}
// Sort by length descending so longest match wins
sort.Slice(cleaned, func(i, j int) bool {
return len(cleaned[i]) > len(cleaned[j])
})
for _, p := range cleaned {
if strings.HasPrefix(issueID, p+"-") {
return p
}
}
// No known prefix matched; fall back to heuristic
return ExtractIssuePrefix(issueID)
}
// NaturalCompareIDs compares two issue IDs with numeric-aware sorting.
// Segments separated by "." or "-" are compared numerically when both
// are pure digits, otherwise lexicographically. This ensures bd-E.4
// sorts before bd-E.10 (GH#3477).
func NaturalCompareIDs(a, b string) int {
sa := splitIDSegments(a)
sb := splitIDSegments(b)
for i := 0; i < len(sa) && i < len(sb); i++ {
if sa[i] == sb[i] {
continue
}
na, aErr := strconv.Atoi(sa[i])
nb, bErr := strconv.Atoi(sb[i])
if aErr == nil && bErr == nil {
if na != nb {
return na - nb
}
continue
}
if sa[i] < sb[i] {
return -1
}
return 1
}
return len(sa) - len(sb)
}
// splitIDSegments splits an ID into segments by "." and "-" separators.
func splitIDSegments(id string) []string {
var segments []string
start := 0
for i, r := range id {
if r == '.' || r == '-' {
if i > start {
segments = append(segments, id[start:i])
}
start = i + 1
}
}
if start < len(id) {
segments = append(segments, id[start:])
}
return segments
}
// ExtractIssueNumber extracts the number from an issue ID like "bd-123" -> 123
func ExtractIssueNumber(issueID string) int {
idx := strings.LastIndex(issueID, "-")
if idx < 0 || idx == len(issueID)-1 {
return 0
}
var num int
_, _ = fmt.Sscanf(issueID[idx+1:], "%d", &num)
return num
}