beads/internal/utils/id_parser.go
Joseph Turian b597fa168f fix: config-aware prefix detection in ResolvePartialID
Make issue ID resolution config-aware by using issue_prefix and
allowed_prefixes as ground truth for prefix detection, instead of
relying solely on heuristics.

Changes:
- Add ExtractIssuePrefixKnown() in issue_id.go: deterministic prefix
  extraction that checks known prefixes (longest-first) before falling
  back to the existing heuristic ExtractIssuePrefix()
- Add hasKnownPrefix() in id_parser.go: checks if input starts with
  any known/allowed prefix
- Modify ResolvePartialID() to read allowed_prefixes from config and
  use config-aware detection in both normalization (preventing
  accidental prefix prepending) and hash extraction (correct prefix
  boundary for multi-hyphen prefixes)
- Do NOT change looksLikePrefixedID() or ExtractIssuePrefix() —
  existing heuristic behavior is preserved as fallback

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-05 17:19:33 -05:00

257 lines
8.4 KiB
Go

// Package utils provides utility functions for issue ID parsing and resolution.
package utils
import (
"context"
"fmt"
"strings"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/types"
)
// parseIssueID ensures an issue ID has the configured prefix.
// If the input already has the prefix (e.g., "bd-a3f8e9"), returns it as-is.
// If the input lacks the prefix (e.g., "a3f8e9"), adds the configured prefix.
// Works with hierarchical IDs too: "a3f8e9.1.2" → "bd-a3f8e9.1.2"
func parseIssueID(input string, prefix string) string {
if prefix == "" {
prefix = "bd-"
}
if strings.HasPrefix(input, prefix) {
return input
}
return prefix + input
}
// ResolvePartialID resolves a potentially partial issue ID to a full ID.
// Supports:
// - Full IDs: "bd-a3f8e9" or "a3f8e9" → "bd-a3f8e9"
// - Without hyphen: "bda3f8e9" or "wya3f8e9" → "bd-a3f8e9"
// - Partial IDs: "a3f8" → "bd-a3f8e9" (if unique match)
// - Hierarchical: "a3f8e9.1" → "bd-a3f8e9.1"
//
// Returns an error if:
// - No issue found matching the ID
// - Multiple issues match (ambiguous prefix)
func ResolvePartialID(ctx context.Context, store storage.Storage, input string) (string, error) {
if store == nil {
return "", fmt.Errorf("cannot resolve issue ID %q: storage is nil", input)
}
// Fast path: Use SearchIssues with exact ID filter (GH#942).
// This uses the same query path as "bd list --id", ensuring consistency.
// Previously we used GetIssue which could fail in cases where SearchIssues
// with filter.IDs succeeded, likely due to subtle query differences.
exactFilter := types.IssueFilter{IDs: []string{input}}
if issues, err := store.SearchIssues(ctx, "", exactFilter); err == nil && len(issues) > 0 {
return issues[0].ID, nil
}
// Get the configured prefix
prefix, err := store.GetConfig(ctx, "issue_prefix")
if err != nil || prefix == "" {
prefix = "bd"
}
// Ensure prefix has hyphen for ID format
prefixWithHyphen := prefix
if !strings.HasSuffix(prefix, "-") {
prefixWithHyphen = prefix + "-"
}
// Build known prefixes from config for deterministic multi-hyphen prefix handling.
// This avoids relying solely on looksLikePrefixedID heuristics when the repo
// explicitly declares which prefixes are valid.
knownPrefixes := []string{strings.TrimSuffix(prefix, "-")}
if allowed, aErr := store.GetConfig(ctx, "allowed_prefixes"); aErr == nil && allowed != "" {
for _, p := range strings.Split(allowed, ",") {
p = strings.TrimSpace(p)
p = strings.TrimSuffix(p, "-")
if p != "" {
knownPrefixes = append(knownPrefixes, p)
}
}
}
// Normalize input:
// 1. If it has the full prefix with hyphen (bd-a3f8e9), use as-is
// 2. If it starts with any known/allowed prefix, use as-is (config-aware cross-prefix)
// 3. If it has ANY prefix (heuristic fallback), use as-is for cross-prefix lookup
// 4. Otherwise, add prefix with hyphen (handles both bare hashes and prefix-without-hyphen cases)
var normalizedID string
if strings.HasPrefix(input, prefixWithHyphen) {
// Already has configured prefix with hyphen: "bd-a3f8e9"
normalizedID = input
} else if hasKnownPrefix(input, knownPrefixes) {
// Starts with a known/allowed prefix (e.g., "hacker-news-ko4" when allowed_prefixes includes "hacker-news")
normalizedID = input
} else if looksLikePrefixedID(input) {
// Has a different prefix (e.g., "aap-4ar" when configured prefix is "hq-")
// Don't prepend configured prefix - use as-is for cross-prefix lookup (GH#1513)
normalizedID = input
} else {
// Bare hash or prefix without hyphen: "a3f8e9", "07b8c8", "bda3f8e9" → all get prefix with hyphen added
normalizedID = prefixWithHyphen + input
}
// Try exact match on normalized ID using SearchIssues (GH#942)
normalizedFilter := types.IssueFilter{IDs: []string{normalizedID}}
if issues, err := store.SearchIssues(ctx, "", normalizedFilter); err == nil && len(issues) > 0 {
return issues[0].ID, nil
}
// If exact match failed, try substring search.
// Use the hash part as a search query to leverage SQL-level filtering
// (id LIKE %hash%) instead of loading ALL issues into memory.
// On large databases (23k+ issues over MySQL wire protocol), loading all
// issues took 60+ seconds; with SQL filtering it's near-instant.
hashPart := strings.TrimPrefix(normalizedID, prefixWithHyphen)
filter := types.IssueFilter{}
issues, err := store.SearchIssues(ctx, hashPart, filter)
if err != nil {
return "", fmt.Errorf("failed to search issues: %w", err)
}
var matches []string
var exactMatch string
for _, issue := range issues {
// Check for exact full ID match first (case: user typed full ID with different prefix)
if issue.ID == input {
exactMatch = issue.ID
break
}
// Extract hash from each issue using config-aware prefix extraction.
// This correctly handles multi-hyphen prefixes (e.g., "hacker-news-ko4"
// yields hash "ko4", not "news-ko4" from naive first-hyphen split).
var issueHash string
if p := ExtractIssuePrefixKnown(issue.ID, knownPrefixes); p != "" && strings.HasPrefix(issue.ID, p+"-") {
issueHash = issue.ID[len(p)+1:]
} else {
issueHash = issue.ID
}
// Check for exact hash match (excluding hierarchical children)
if issueHash == hashPart {
exactMatch = issue.ID
// Don't break - keep searching in case there's a full ID match
}
// Check if the issue hash contains the input hash as substring
if strings.Contains(issueHash, hashPart) {
matches = append(matches, issue.ID)
}
}
// Prefer exact match over substring matches
if exactMatch != "" {
return exactMatch, nil
}
// Fallback: explicitly search wisps table for partial ID resolution.
// DoltStore.SearchIssues merges wisps when Ephemeral is nil, but
// transaction-level SearchIssues does not. This ensures wisps are
// always resolvable by partial ID.
if len(matches) == 0 {
ephTrue := true
wispFilter := types.IssueFilter{Ephemeral: &ephTrue}
if wisps, wispErr := store.SearchIssues(ctx, hashPart, wispFilter); wispErr == nil {
for _, w := range wisps {
if w.ID == input {
return w.ID, nil
}
var wHash string
if p := ExtractIssuePrefixKnown(w.ID, knownPrefixes); p != "" && strings.HasPrefix(w.ID, p+"-") {
wHash = w.ID[len(p)+1:]
} else {
wHash = w.ID
}
if wHash == hashPart {
exactMatch = w.ID
}
if strings.Contains(wHash, hashPart) {
matches = append(matches, w.ID)
}
}
if exactMatch != "" {
return exactMatch, nil
}
}
}
if len(matches) == 0 {
return "", fmt.Errorf("no issue found matching %q", input)
}
if len(matches) > 1 {
return "", fmt.Errorf("ambiguous ID %q matches %d issues: %v\nUse more characters to disambiguate", input, len(matches), matches)
}
return matches[0], nil
}
// ResolvePartialIDs resolves multiple potentially partial issue IDs.
// Returns the resolved IDs and any errors encountered.
func ResolvePartialIDs(ctx context.Context, store storage.Storage, inputs []string) ([]string, error) {
var resolved []string
for _, input := range inputs {
fullID, err := ResolvePartialID(ctx, store, input)
if err != nil {
return nil, err
}
resolved = append(resolved, fullID)
}
return resolved, nil
}
// looksLikePrefixedID checks if input appears to already have a prefix.
// A prefixed ID has the format "prefix-hash" where prefix is 1-8 lowercase
// letters/numbers and hash is alphanumeric (potentially with dots for hierarchical IDs).
// Examples: "aap-4ar", "bd-a3f8e9", "myproject-abc.1"
func looksLikePrefixedID(input string) bool {
idx := strings.Index(input, "-")
if idx <= 0 || idx > 8 {
// No hyphen, hyphen at start, or prefix too long
return false
}
prefix := input[:idx]
suffix := input[idx+1:]
// Prefix must be non-empty lowercase alphanumeric
for _, c := range prefix {
if !((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')) {
return false
}
}
// Suffix must be non-empty and start with alphanumeric
if len(suffix) == 0 {
return false
}
first := rune(suffix[0])
if !((first >= 'a' && first <= 'z') || (first >= '0' && first <= '9')) {
return false
}
return true
}
// hasKnownPrefix checks if input starts with any of the known prefixes followed
// by a hyphen. Used to detect already-prefixed input before falling back to the
// looksLikePrefixedID heuristic.
func hasKnownPrefix(input string, knownPrefixes []string) bool {
for _, p := range knownPrefixes {
if p != "" && strings.HasPrefix(input, p+"-") {
return true
}
}
return false
}