fix(ids): report a hash two prefixes share as ambiguous (mc-ke8mg)
resolvePartialID kept the last candidate whose hash equalled the input's, so with hacker-news-abc123 and ops-abc123 in one workspace, `abc123` resolved to whichever the store listed last. That is an exact hash match, not an abbreviation, so the partial-id notice stayed silent: on the base build `bd update abc123`, `bd comment abc123` and the `bd delete abc123` preview all targeted ops-abc123 without a word. Collect every exact-hash candidate, in the main search and in the wisp fallback, and resolve only when there is exactly one. Two or more return ErrAmbiguousID naming the sorted candidates and asking for the full ID, the same shape as the abbreviation ambiguity. A full-ID match still wins, the configured prefix's own spelling is still looked up first, and the HTTP backend's exact-only path never searched other prefixes. Agent-Signature: claude-code-claude-opus-5-5-max on behalf of Julian Knutsen Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
babf8d7ed7
commit
e9a99a8154
3 changed files with 127 additions and 4 deletions
17
CHANGELOG.md
17
CHANGELOG.md
|
|
@ -557,6 +557,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
|||
|
||||
### Fixed
|
||||
|
||||
- **A bare hash that two prefixes share is reported as ambiguous instead of
|
||||
resolving to one of them.** With `hacker-news-abc123` and `ops-abc123` in
|
||||
one workspace (under `allowed_prefixes`, say), `abc123` matched both
|
||||
exactly, and the resolver kept whichever the store listed last:
|
||||
`bd update abc123 --status in_progress` updated `ops-abc123` and printed a
|
||||
success line, `bd comment abc123` wrote to it, and `bd delete abc123`
|
||||
previewed it and printed `bd delete ops-abc123 --force` as the next step.
|
||||
An exact hash match is not an abbreviation, so the partial-id notice stayed
|
||||
silent too. Every command that resolves an id through the shared resolver
|
||||
now refuses such a hash with `ambiguous issue ID: "abc123" matches 2
|
||||
issues: [hacker-news-abc123 ops-abc123]` and asks for the full id, as
|
||||
[Working with IDs](docs/core-concepts/hash-ids.md#working-with-ids)
|
||||
documents for ambiguous cases; ephemeral wisps follow the same rule. A hash
|
||||
that only one prefix uses, a full id, and the workspace's own prefix
|
||||
(`bd-abc123` in a `bd` workspace, still looked up first) resolve as before.
|
||||
A connected HTTP workspace resolves exact ids only and was not affected.
|
||||
|
||||
- **`bd gate check` works over a connected HTTP workspace.** Its open-gate
|
||||
listing built the same raw `SearchIssues` filter `bd gate list` did before
|
||||
S20, so the HTTP backend refused the command before reading a gate and gc's
|
||||
|
|
|
|||
|
|
@ -101,6 +101,7 @@ func parseIssueID(input string, prefix string) string {
|
|||
// - The input is a bare tooling sentinel ("", "null", "undefined", "none", "nil")
|
||||
// - No issue found matching the ID
|
||||
// - Multiple issues match (ambiguous prefix)
|
||||
// - Multiple issues share the input's hash under different prefixes
|
||||
func ResolvePartialID(ctx context.Context, store PartialIDResolverStore, input string) (string, error) {
|
||||
return resolvePartialID(ctx, store, input, true)
|
||||
}
|
||||
|
|
@ -232,6 +233,9 @@ func resolvePartialID(ctx context.Context, store PartialIDResolverStore, input s
|
|||
|
||||
var matches []string
|
||||
var exactMatch string
|
||||
// hashMatches collects every candidate whose hash equals the input's, so
|
||||
// a hash that two prefixes share is reported, not picked (soleHashMatch).
|
||||
var hashMatches []string
|
||||
// abbrevOnly collects candidates that matched ONLY via leading-prefix
|
||||
// abbreviation while allowAbbrev is false — never resolved to, only used
|
||||
// to make the final "not found" error truthful (see ErrAbbreviatedIDNotAllowed).
|
||||
|
|
@ -256,7 +260,7 @@ func resolvePartialID(ctx context.Context, store PartialIDResolverStore, input s
|
|||
|
||||
// Check for exact hash match (excluding hierarchical children)
|
||||
if issueHash == hashPart {
|
||||
exactMatch = id
|
||||
hashMatches = append(hashMatches, id)
|
||||
// Don't break - keep searching in case there's a full ID match
|
||||
} else if strings.HasPrefix(issueHash, hashPart) {
|
||||
// Leading-prefix abbreviation (documented UX, e.g. "a3f8" -> "a3f8e9...").
|
||||
|
|
@ -277,6 +281,9 @@ func resolvePartialID(ctx context.Context, store PartialIDResolverStore, input s
|
|||
if exactMatch != "" {
|
||||
return exactMatch, nil
|
||||
}
|
||||
if len(hashMatches) > 0 {
|
||||
return soleHashMatch(input, hashMatches)
|
||||
}
|
||||
|
||||
// Fallback: explicitly search wisps table for partial ID resolution.
|
||||
// DoltStore.SearchIssues merges wisps when Ephemeral is nil, but
|
||||
|
|
@ -302,7 +309,7 @@ func resolvePartialID(ctx context.Context, store PartialIDResolverStore, input s
|
|||
// against the isolated hash, not the full "wisp-t3st" string.
|
||||
wispHash := strings.TrimPrefix(wHash, "wisp-")
|
||||
if wHash == hashPart || wispHash == hashPart {
|
||||
exactMatch = wID
|
||||
hashMatches = append(hashMatches, wID)
|
||||
} else if strings.HasPrefix(wispHash, hashPart) {
|
||||
if allowAbbrev {
|
||||
matches = append(matches, wID)
|
||||
|
|
@ -311,8 +318,8 @@ func resolvePartialID(ctx context.Context, store PartialIDResolverStore, input s
|
|||
}
|
||||
}
|
||||
}
|
||||
if exactMatch != "" {
|
||||
return exactMatch, nil
|
||||
if len(hashMatches) > 0 {
|
||||
return soleHashMatch(input, hashMatches)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -350,6 +357,19 @@ func resolvePartialID(ctx context.Context, store PartialIDResolverStore, input s
|
|||
return resolved, nil
|
||||
}
|
||||
|
||||
// soleHashMatch resolves to the one candidate whose hash equals the input's.
|
||||
// Two prefixes can share a hash (hacker-news-abc123 and ops-abc123), and the
|
||||
// store's return order is not a contract, so with more than one candidate the
|
||||
// input is ambiguous and nothing is picked. Typing more characters cannot tell
|
||||
// such IDs apart; only the full ID can.
|
||||
func soleHashMatch(input string, candidates []string) (string, error) {
|
||||
if len(candidates) == 1 {
|
||||
return candidates[0], nil
|
||||
}
|
||||
sort.Strings(candidates)
|
||||
return "", fmt.Errorf("%w: %q matches %d issues: %v\nUse the full ID to disambiguate", ErrAmbiguousID, input, len(candidates), candidates)
|
||||
}
|
||||
|
||||
// resolveExactIDOnly is resolvePartialID for an ExactIDLookupStore: the exact
|
||||
// lookups only, with the same input normalization, and a not-found that says
|
||||
// why no abbreviation was tried.
|
||||
|
|
|
|||
|
|
@ -394,3 +394,89 @@ func TestResolvePartialID_FakeStore_QualifiedInputsNeverResolveToAnotherBead(t *
|
|||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestResolvePartialID_FakeStore_SharedHashAcrossPrefixesIsAmbiguous pins
|
||||
// mc-ke8mg. When two prefixes share a hash and neither is the configured
|
||||
// prefix, the bare hash names both issues equally well. The resolver used to
|
||||
// keep whichever one the store returned last, silently, and without the
|
||||
// partial-ID notice, because the match counts as exact. So the store's return
|
||||
// order picked the issue a command acted on. Both resolvers must refuse with
|
||||
// ErrAmbiguousID and name every candidate, whatever order the store answers in.
|
||||
func TestResolvePartialID_FakeStore_SharedHashAcrossPrefixesIsAmbiguous(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
config := map[string]string{"issue_prefix": "bd", "allowed_prefixes": "hacker-news,ops"}
|
||||
resolvers := []struct {
|
||||
name string
|
||||
resolve func(context.Context, utils.PartialIDResolverStore, string) (string, error)
|
||||
}{
|
||||
{"ResolvePartialID", utils.ResolvePartialID},
|
||||
{"ResolvePartialIDExact", utils.ResolvePartialIDExact},
|
||||
}
|
||||
|
||||
cases := []struct {
|
||||
name string
|
||||
a, b fakeIssue
|
||||
input string
|
||||
wantErr string
|
||||
}{
|
||||
{
|
||||
name: "issues",
|
||||
a: fakeIssue{id: "hacker-news-abc123"},
|
||||
b: fakeIssue{id: "ops-abc123"},
|
||||
input: "abc123",
|
||||
wantErr: "ambiguous issue ID: \"abc123\" matches 2 issues: [hacker-news-abc123 ops-abc123]\nUse the full ID to disambiguate",
|
||||
},
|
||||
{
|
||||
// The wisp fallback strips the "wisp-" infix before it compares
|
||||
// hashes, so it reaches the same choice on its own.
|
||||
name: "wisps",
|
||||
a: fakeIssue{id: "hacker-news-wisp-t3st", ephemeral: true},
|
||||
b: fakeIssue{id: "ops-wisp-t3st", ephemeral: true},
|
||||
input: "t3st",
|
||||
wantErr: "ambiguous issue ID: \"t3st\" matches 2 issues: [hacker-news-wisp-t3st ops-wisp-t3st]\nUse the full ID to disambiguate",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
// Try both store orders, since the order is what used to decide.
|
||||
for _, issues := range [][]fakeIssue{{tc.a, tc.b}, {tc.b, tc.a}} {
|
||||
store := &fakeResolverStore{issues: issues, config: config}
|
||||
for _, r := range resolvers {
|
||||
got, err := r.resolve(ctx, store, tc.input)
|
||||
if !errors.Is(err, utils.ErrAmbiguousID) {
|
||||
t.Errorf("%s(%q) with %s first = (%q, %v); want an ErrAmbiguousID error", r.name, tc.input, issues[0].id, got, err)
|
||||
} else if err.Error() != tc.wantErr {
|
||||
t.Errorf("%s(%q) error = %q; want %q", r.name, tc.input, err, tc.wantErr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// A full ID still names exactly one issue. A hash that only one
|
||||
// prefix uses is still an exact match.
|
||||
for _, r := range resolvers {
|
||||
store := &fakeResolverStore{issues: []fakeIssue{tc.a, tc.b}, config: config}
|
||||
if got, err := r.resolve(ctx, store, tc.b.id); err != nil || got != tc.b.id {
|
||||
t.Errorf("%s(%q) = (%q, %v); want (%q, nil)", r.name, tc.b.id, got, err, tc.b.id)
|
||||
}
|
||||
store = &fakeResolverStore{issues: []fakeIssue{tc.a}, config: config}
|
||||
if got, err := r.resolve(ctx, store, tc.input); err != nil || got != tc.a.id {
|
||||
t.Errorf("%s(%q) with only %s = (%q, %v); want (%q, nil)", r.name, tc.input, tc.a.id, got, err, tc.a.id)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// The configured prefix's own spelling is looked up before any search.
|
||||
// So a bare hash that prefix uses still resolves to it, even when other
|
||||
// prefixes share the hash.
|
||||
store := &fakeResolverStore{
|
||||
issues: []fakeIssue{{id: "hacker-news-abc123"}, {id: "ops-abc123"}, {id: "bd-abc123"}},
|
||||
config: config,
|
||||
}
|
||||
for _, r := range resolvers {
|
||||
if got, err := r.resolve(ctx, store, "abc123"); err != nil || got != "bd-abc123" {
|
||||
t.Errorf("%s(%q) = (%q, %v); want (%q, nil)", r.name, "abc123", got, err, "bd-abc123")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue