johno/beads
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove obsolete collision remapping code and tests

Browse Source 
- Deleted collision remapping tests (obsolete with hash IDs bd-8e05)
- Simplified collision.go from 704 to 138 lines
- Removed RemapCollisions, ScoreCollisions, and reference update code
- Removed issue_counters table dependencies (bd-807b)
- Added COLLISION_MATH.md documentation
- Fixed RenameCounterPrefix and ResetCounter to be no-ops
- Closed bd-a58f, bd-3d65, bd-807b

Hash-based IDs make collision remapping unnecessary since collisions
are extremely rare (same ID = same content).

Amp-Thread-ID: https://ampcode.com/threads/T-cbb0f111-6a95-4598-b03e-c137112f9875
Co-authored-by: Amp <amp@ampcode.com>
This commit is contained in:
Steve Yegge
2025-10-31 00:19:42 -07:00
parent 4e9f6e131c
commit 64fe51d6bb
19 changed files with 307 additions and 3888 deletions
Download Patch File Download Diff File Expand all files Collapse all files

784
cmd/bd/autoimport_collision_test.go
View File

@@ -1,784 +0,0 @@
package main
import (
"bytes"
"context"
"encoding/json"
"io"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/steveyegge/beads/internal/storage/sqlite"
"github.com/steveyegge/beads/internal/types"
)
// Helper function to create test database with issues
func createTestDBWithIssues(t *testing.T, issues []*types.Issue) (string, *sqlite.SQLiteStorage) {
t.Helper()
tmpDir, err := os.MkdirTemp("", "bd-collision-test-*")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
t.Cleanup(func() { os.RemoveAll(tmpDir) })
dbPath := filepath.Join(tmpDir, "test.db")
testStore, err := sqlite.New(dbPath)
if err != nil {
t.Fatalf("Failed to create storage: %v", err)
}
t.Cleanup(func() { testStore.Close() })
ctx := context.Background()
// Set issue_prefix to prevent "database not initialized" errors
if err := testStore.SetConfig(ctx, "issue_prefix", "test"); err != nil {
t.Fatalf("Failed to set issue_prefix: %v", err)
}
for _, issue := range issues {
if err := testStore.CreateIssue(ctx, issue, "test"); err != nil {
t.Fatalf("Failed to create issue %s: %v", issue.ID, err)
}
}
return tmpDir, testStore
}
// Helper function to write JSONL file
func writeJSONLFile(t *testing.T, dir string, issues []*types.Issue) {
t.Helper()
jsonlPath := filepath.Join(dir, "issues.jsonl")
f, err := os.Create(jsonlPath)
if err != nil {
t.Fatalf("Failed to create JSONL file: %v", err)
}
defer f.Close()
encoder := json.NewEncoder(f)
for _, issue := range issues {
if err := encoder.Encode(issue); err != nil {
t.Fatalf("Failed to encode issue %s: %v", issue.ID, err)
}
}
}
// Helper function to capture stderr output
func captureStderr(t *testing.T, fn func()) string {
t.Helper()
oldStderr := os.Stderr
r, w, _ := os.Pipe()
os.Stderr = w
fn()
w.Close()
os.Stderr = oldStderr
var buf bytes.Buffer
io.Copy(&buf, r)
return buf.String()
}
// Helper function to setup auto-import test environment
func setupAutoImportTest(t *testing.T, testStore *sqlite.SQLiteStorage, tmpDir string) {
t.Helper()
store = testStore
dbPath = filepath.Join(tmpDir, "test.db")
storeMutex.Lock()
storeActive = true
storeMutex.Unlock()
t.Cleanup(func() {
storeMutex.Lock()
storeActive = false
storeMutex.Unlock()
})
}
// TestAutoImportMultipleCollisionsRemapped tests that multiple collisions are auto-resolved
func TestAutoImportMultipleCollisionsRemapped(t *testing.T) {
// Create 5 issues in DB with local modifications
now := time.Now().UTC()
closedTime := now.Add(-1 * time.Hour)
dbIssues := []*types.Issue{
{
ID: "test-mc-1",
Title: "Local version 1",
Status: types.StatusClosed,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
ClosedAt: &closedTime,
},
{
ID: "test-mc-2",
Title: "Local version 2",
Status: types.StatusInProgress,
Priority: 2,
IssueType: types.TypeBug,
CreatedAt: now,
UpdatedAt: now,
},
{
ID: "test-mc-3",
Title: "Local version 3",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeFeature,
CreatedAt: now,
UpdatedAt: now,
},
{
ID: "test-mc-4",
Title: "Exact match",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
{
ID: "test-mc-5",
Title: "Another exact match",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
}
tmpDir, testStore := createTestDBWithIssues(t, dbIssues)
setupAutoImportTest(t, testStore, tmpDir)
// Create JSONL with 3 colliding issues, 2 exact matches, and 1 new issue
jsonlIssues := []*types.Issue{
{
ID: "test-mc-1",
Title: "Remote version 1 (conflict)",
Status: types.StatusOpen,
Priority: 3,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
{
ID: "test-mc-2",
Title: "Remote version 2 (conflict)",
Status: types.StatusClosed,
Priority: 1,
IssueType: types.TypeBug,
CreatedAt: now,
UpdatedAt: now.Add(-30 * time.Minute),
ClosedAt: &closedTime,
},
{
ID: "test-mc-3",
Title: "Remote version 3 (conflict)",
Status: types.StatusBlocked,
Priority: 3,
IssueType: types.TypeFeature,
CreatedAt: now,
UpdatedAt: now,
},
{
ID: "test-mc-4",
Title: "Exact match",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
{
ID: "test-mc-5",
Title: "Another exact match",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
{
ID: "test-mc-6",
Title: "Brand new issue",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
}
writeJSONLFile(t, tmpDir, jsonlIssues)
// Capture stderr and run auto-import
stderrOutput := captureStderr(t, autoImportIfNewer)
ctx := context.Background()
// Verify content-hash based collision resolution
// The winner is the version with the lexicographically lower content hash
// For deterministic testing, we check that the remapped version exists as new issue
// Check test-mc-1: Should have the winning version at original ID
issue1, _ := testStore.GetIssue(ctx, "test-mc-1")
if issue1 == nil {
t.Fatal("Expected test-mc-1 to exist")
}
// The winner should be either "Local version 1" or "Remote version 1 (conflict)"
// We don't assert which one, just that one exists at the original ID
// Check test-mc-2: Should have the winning version at original ID
issue2, _ := testStore.GetIssue(ctx, "test-mc-2")
if issue2 == nil {
t.Fatal("Expected test-mc-2 to exist")
}
// Check test-mc-3: Should have the winning version at original ID
issue3, _ := testStore.GetIssue(ctx, "test-mc-3")
if issue3 == nil {
t.Fatal("Expected test-mc-3 to exist")
}
// Verify new issue was imported
newIssue, _ := testStore.GetIssue(ctx, "test-mc-6")
if newIssue == nil {
t.Fatal("Expected new issue test-mc-6 to be imported")
}
if newIssue.Title != "Brand new issue" {
t.Errorf("Expected new issue title 'Brand new issue', got: %s", newIssue.Title)
}
// Verify remapping message was printed
if !strings.Contains(stderrOutput, "remapped") {
t.Errorf("Expected remapping message in stderr, got: %s", stderrOutput)
}
if !strings.Contains(stderrOutput, "test-mc-1") {
t.Errorf("Expected test-mc-1 in remapping message, got: %s", stderrOutput)
}
// Verify colliding issues were created with new IDs
// They should appear in the database with different IDs
allIssues, err := testStore.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
t.Fatalf("Failed to get all issues: %v", err)
}
// Should have: 5 original + 1 new + 3 remapped = 9 total
if len(allIssues) < 8 {
t.Errorf("Expected at least 8 issues (5 original + 1 new + 3 remapped), got %d", len(allIssues))
}
}
// TestAutoImportAllCollisionsRemapped tests when every issue has a collision
func TestAutoImportAllCollisionsRemapped(t *testing.T) {
now := time.Now().UTC()
closedTime := now.Add(-1 * time.Hour)
dbIssues := []*types.Issue{
{
ID: "test-ac-1",
Title: "Local 1",
Status: types.StatusClosed,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
ClosedAt: &closedTime,
},
{
ID: "test-ac-2",
Title: "Local 2",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeBug,
CreatedAt: now,
UpdatedAt: now,
},
}
tmpDir, testStore := createTestDBWithIssues(t, dbIssues)
setupAutoImportTest(t, testStore, tmpDir)
// JSONL with all conflicts (different content for same IDs)
jsonlIssues := []*types.Issue{
{
ID: "test-ac-1",
Title: "Remote 1 (conflict)",
Status: types.StatusOpen,
Priority: 3,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
{
ID: "test-ac-2",
Title: "Remote 2 (conflict)",
Status: types.StatusClosed,
Priority: 1,
IssueType: types.TypeBug,
CreatedAt: now,
UpdatedAt: now,
ClosedAt: &closedTime,
},
}
writeJSONLFile(t, tmpDir, jsonlIssues)
// Capture stderr and run auto-import
stderrOutput := captureStderr(t, autoImportIfNewer)
ctx := context.Background()
// Verify content-hash based collision resolution
// The winner is the version with the lexicographically lower content hash
// Check that original IDs exist with winning version
issue1, _ := testStore.GetIssue(ctx, "test-ac-1")
if issue1 == nil {
t.Fatal("Expected test-ac-1 to exist")
}
// Winner could be either "Local 1" or "Remote 1 (conflict)" - don't assert which
issue2, _ := testStore.GetIssue(ctx, "test-ac-2")
if issue2 == nil {
t.Fatal("Expected test-ac-2 to exist")
}
// Winner could be either "Local 2" or "Remote 2 (conflict)" - don't assert which
// Verify remapping message mentions both collisions
if !strings.Contains(stderrOutput, "remapped 2") {
t.Errorf("Expected '2' in remapping count, got: %s", stderrOutput)
}
}
// TestAutoImportExactMatchesOnly tests happy path with no conflicts
func TestAutoImportExactMatchesOnly(t *testing.T) {
now := time.Now().UTC()
dbIssues := []*types.Issue{
{
ID: "test-em-1",
Title: "Exact match issue",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
}
tmpDir, testStore := createTestDBWithIssues(t, dbIssues)
setupAutoImportTest(t, testStore, tmpDir)
// JSONL with exact match + new issue
jsonlIssues := []*types.Issue{
{
ID: "test-em-1",
Title: "Exact match issue",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
{
ID: "test-em-2",
Title: "New issue",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeBug,
CreatedAt: now,
UpdatedAt: now,
},
}
writeJSONLFile(t, tmpDir, jsonlIssues)
// Run auto-import (should not print collision warnings)
stderrOutput := captureStderr(t, autoImportIfNewer)
ctx := context.Background()
// Verify new issue imported
newIssue, _ := testStore.GetIssue(ctx, "test-em-2")
if newIssue == nil {
t.Fatal("Expected new issue to be imported")
}
if newIssue.Title != "New issue" {
t.Errorf("Expected title 'New issue', got: %s", newIssue.Title)
}
// Verify no collision warnings
if strings.Contains(stderrOutput, "remapped") {
t.Errorf("Expected no remapping message, got: %s", stderrOutput)
}
}
// TestAutoImportHashUnchanged tests fast path when JSONL hasn't changed
func TestAutoImportHashUnchanged(t *testing.T) {
now := time.Now().UTC()
dbIssues := []*types.Issue{
{
ID: "test-hu-1",
Title: "Test issue",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
}
tmpDir, testStore := createTestDBWithIssues(t, dbIssues)
setupAutoImportTest(t, testStore, tmpDir)
writeJSONLFile(t, tmpDir, dbIssues)
// Run auto-import first time
os.Setenv("BD_DEBUG", "1")
defer os.Unsetenv("BD_DEBUG")
stderrOutput1 := captureStderr(t, autoImportIfNewer)
// Should trigger import on first run
if !strings.Contains(stderrOutput1, "auto-import triggered") && !strings.Contains(stderrOutput1, "hash changed") {
t.Logf("First run: %s", stderrOutput1)
}
// Run auto-import second time (JSONL unchanged)
stderrOutput2 := captureStderr(t, autoImportIfNewer)
// Verify fast path was taken (hash match)
if !strings.Contains(stderrOutput2, "JSONL unchanged") {
t.Errorf("Expected 'JSONL unchanged' in debug output, got: %s", stderrOutput2)
}
}
// TestAutoImportParseError tests that parse errors are handled gracefully
func TestAutoImportParseError(t *testing.T) {
now := time.Now().UTC()
dbIssues := []*types.Issue{
{
ID: "test-pe-1",
Title: "Test issue",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
}
tmpDir, testStore := createTestDBWithIssues(t, dbIssues)
setupAutoImportTest(t, testStore, tmpDir)
// Create malformed JSONL
jsonlPath := filepath.Join(tmpDir, "issues.jsonl")
os.WriteFile(jsonlPath, []byte(`{"id":"test-pe-1","title":"Good issue","status":"open","priority":1,"issue_type":"task","created_at":"2025-10-16T00:00:00Z","updated_at":"2025-10-16T00:00:00Z"}
{invalid json here}
`), 0644)
// Run auto-import (should skip due to parse error)
stderrOutput := captureStderr(t, autoImportIfNewer)
// Verify parse error was reported
if !strings.Contains(stderrOutput, "parse error") {
t.Errorf("Expected parse error message, got: %s", stderrOutput)
}
}
// TestAutoImportEmptyJSONL tests behavior with empty JSONL file
func TestAutoImportEmptyJSONL(t *testing.T) {
now := time.Now().UTC()
dbIssues := []*types.Issue{
{
ID: "test-ej-1",
Title: "Existing issue",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
}
tmpDir, testStore := createTestDBWithIssues(t, dbIssues)
setupAutoImportTest(t, testStore, tmpDir)
// Create empty JSONL
jsonlPath := filepath.Join(tmpDir, "issues.jsonl")
os.WriteFile(jsonlPath, []byte(""), 0644)
// Run auto-import
autoImportIfNewer()
ctx := context.Background()
// Verify existing issue still exists (not deleted)
existing, _ := testStore.GetIssue(ctx, "test-ej-1")
if existing == nil {
t.Fatal("Expected existing issue to remain after empty JSONL import")
}
}
// TestAutoImportNewIssuesOnly tests importing only new issues
func TestAutoImportNewIssuesOnly(t *testing.T) {
now := time.Now().UTC()
dbIssues := []*types.Issue{
{
ID: "test-ni-1",
Title: "Existing issue",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
}
tmpDir, testStore := createTestDBWithIssues(t, dbIssues)
setupAutoImportTest(t, testStore, tmpDir)
// JSONL with only new issues (no collisions, no exact matches)
jsonlIssues := []*types.Issue{
{
ID: "test-ni-2",
Title: "New issue 1",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
},
{
ID: "test-ni-3",
Title: "New issue 2",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeBug,
CreatedAt: now,
UpdatedAt: now,
},
}
writeJSONLFile(t, tmpDir, jsonlIssues)
// Run auto-import
stderrOutput := captureStderr(t, autoImportIfNewer)
ctx := context.Background()
// Verify new issues imported
issue2, _ := testStore.GetIssue(ctx, "test-ni-2")
if issue2 == nil || issue2.Title != "New issue 1" {
t.Error("Expected new issue 1 to be imported")
}
issue3, _ := testStore.GetIssue(ctx, "test-ni-3")
if issue3 == nil || issue3.Title != "New issue 2" {
t.Error("Expected new issue 2 to be imported")
}
// Verify no collision warnings
if strings.Contains(stderrOutput, "remapped") {
t.Errorf("Expected no collision messages, got: %s", stderrOutput)
}
}
// TestAutoImportUpdatesExactMatches tests that exact matches update the DB
func TestAutoImportUpdatesExactMatches(t *testing.T) {
now := time.Now().UTC()
oldTime := now.Add(-24 * time.Hour)
dbIssues := []*types.Issue{
{
ID: "test-um-1",
Title: "Exact match",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: oldTime,
UpdatedAt: oldTime,
},
}
tmpDir, testStore := createTestDBWithIssues(t, dbIssues)
setupAutoImportTest(t, testStore, tmpDir)
// JSONL with exact match (same content, newer timestamp)
jsonlIssues := []*types.Issue{
{
ID: "test-um-1",
Title: "Exact match",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: oldTime,
UpdatedAt: now, // Newer timestamp
},
}
writeJSONLFile(t, tmpDir, jsonlIssues)
// Run auto-import
autoImportIfNewer()
ctx := context.Background()
// Verify issue was updated (UpdatedAt should be newer)
updated, _ := testStore.GetIssue(ctx, "test-um-1")
if updated.UpdatedAt.Before(now.Add(-1 * time.Second)) {
t.Errorf("Expected UpdatedAt to be updated to %v, got %v", now, updated.UpdatedAt)
}
}
// TestAutoImportJSONLNotFound tests behavior when JSONL doesn't exist
func TestAutoImportJSONLNotFound(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "bd-test-notfound-*")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
defer os.RemoveAll(tmpDir)
dbPath = filepath.Join(tmpDir, "test.db")
// Don't create JSONL file
testStore, err := sqlite.New(dbPath)
if err != nil {
t.Fatalf("Failed to create storage: %v", err)
}
defer testStore.Close()
store = testStore
storeMutex.Lock()
storeActive = true
storeMutex.Unlock()
defer func() {
storeMutex.Lock()
storeActive = false
storeMutex.Unlock()
}()
// Enable debug mode to see skip message
os.Setenv("BD_DEBUG", "1")
defer os.Unsetenv("BD_DEBUG")
// Run auto-import (should skip silently)
stderrOutput := captureStderr(t, autoImportIfNewer)
// Verify it skipped due to missing JSONL
if !strings.Contains(stderrOutput, "JSONL not found") {
t.Logf("Expected 'JSONL not found' message, got: %s", stderrOutput)
}
}
// TestAutoImportCollisionRemapMultipleFields tests remapping with different field conflicts
func TestAutoImportCollisionRemapMultipleFields(t *testing.T) {
now := time.Now().UTC()
// Create issue with many fields set
dbIssues := []*types.Issue{
{
ID: "test-fields-1",
Title: "Local title",
Description: "Local description",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
Notes: "Local notes",
Design: "Local design",
AcceptanceCriteria: "Local acceptance",
},
}
tmpDir, testStore := createTestDBWithIssues(t, dbIssues)
setupAutoImportTest(t, testStore, tmpDir)
ctx := context.Background()
// JSONL with conflicts in multiple fields
jsonlIssues := []*types.Issue{
{
ID: "test-fields-1",
Title: "Remote title (conflict)",
Description: "Remote description (conflict)",
Status: types.StatusClosed,
Priority: 3,
IssueType: types.TypeBug,
CreatedAt: now,
UpdatedAt: now,
ClosedAt: &now,
Notes: "Remote notes (conflict)",
Design: "Remote design (conflict)",
AcceptanceCriteria: "Remote acceptance (conflict)",
},
}
writeJSONLFile(t, tmpDir, jsonlIssues)
// Run auto-import
stderrOutput := captureStderr(t, autoImportIfNewer)
// Verify remapping occurred
if !strings.Contains(stderrOutput, "test-fields-1") {
t.Logf("Expected remapping message for test-fields-1: %s", stderrOutput)
}
// Verify content-hash based collision resolution
// The winning version (lower content hash) keeps the original ID
// The loser is remapped to a new ID
issue, _ := testStore.GetIssue(ctx, "test-fields-1")
if issue == nil {
t.Fatal("Expected test-fields-1 to exist")
}
// Verify the issue has consistent fields (all from the same version)
// Don't assert which version won, just that it's internally consistent
if issue.Title == "Local title" {
// If local won, verify all local fields
if issue.Description != "Local description" {
t.Errorf("Expected local description with local title, got: %s", issue.Description)
}
if issue.Status != types.StatusOpen {
t.Errorf("Expected local status with local title, got: %s", issue.Status)
}
if issue.Priority != 1 {
t.Errorf("Expected local priority with local title, got: %d", issue.Priority)
}
} else if issue.Title == "Remote title (conflict)" {
// If remote won, verify all remote fields
if issue.Description != "Remote description (conflict)" {
t.Errorf("Expected remote description with remote title, got: %s", issue.Description)
}
if issue.Status != types.StatusClosed {
t.Errorf("Expected remote status with remote title, got: %s", issue.Status)
}
if issue.Priority != 3 {
t.Errorf("Expected remote priority with remote title, got: %d", issue.Priority)
}
} else {
t.Errorf("Unexpected title: %s", issue.Title)
}
}
// TestAutoImportMetadataReadError tests error handling when metadata can't be read
func TestAutoImportMetadataReadError(t *testing.T) {
// This test is difficult to implement without mocking since metadata
// should always work in SQLite. We can document that this error path
// is defensive but hard to trigger in practice.
t.Skip("Metadata read error is defensive code path, hard to test without mocking")
}

307
cmd/bd/import_collision_regression_test.go
View File

@@ -1,307 +0,0 @@
package main
import (
"context"
"os"
"path/filepath"
"testing"
"github.com/steveyegge/beads/internal/storage/sqlite"
"github.com/steveyegge/beads/internal/types"
)
const (
testIssueBD1 = "bd-1"
testIssueBD2 = "bd-2"
)
// TestRemapCollisionsRemapsImportedNotExisting verifies the bug fix where collision
// resolution incorrectly modified existing issue dependencies.
//
// Bug (fixed): updateDependencyReferences() was updating ALL dependencies in the database
// based on the idMapping, without distinguishing between dependencies belonging to
// IMPORTED issues (should be updated) vs EXISTING issues (should NOT be touched).
//
// This test ensures existing issue dependencies are preserved during collision resolution.
func TestRemapCollisionsRemapsImportedNotExisting(t *testing.T) {
// Setup: Create temporary database
tmpDir, err := os.MkdirTemp("", "collision-bug-test-*")
if err != nil {
t.Fatalf("failed to create temp dir: %v", err)
}
defer os.RemoveAll(tmpDir)
dbPath := filepath.Join(tmpDir, "test.db")
store := newTestStoreWithPrefix(t, dbPath, "bd")
ctx := context.Background()
// Step 1: Create existing issues with dependencies
existingIssues := []*types.Issue{
{
ID: testIssueBD1,
Title: "Existing BD-1",
Description: "Original database issue 1, depends on bd-2",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
},
{
ID: testIssueBD2,
Title: "Existing BD-2",
Description: "Original database issue 2",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
},
{
ID: "bd-3",
Title: "Existing BD-3",
Description: "Original database issue 3, depends on " + testIssueBD1,
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
},
}
for _, issue := range existingIssues {
if err := store.CreateIssue(ctx, issue, "test"); err != nil {
t.Fatalf("failed to create existing issue %s: %v", issue.ID, err)
}
}
// Add dependencies between existing issues
dep1 := &types.Dependency{
IssueID: testIssueBD1,
DependsOnID: testIssueBD2,
Type: types.DepBlocks,
}
dep2 := &types.Dependency{
IssueID: "bd-3",
DependsOnID: testIssueBD1,
Type: types.DepBlocks,
}
if err := store.AddDependency(ctx, dep1, "test"); err != nil {
t.Fatalf("failed to add dependency bd-1 → bd-2: %v", err)
}
if err := store.AddDependency(ctx, dep2, "test"); err != nil {
t.Fatalf("failed to add dependency bd-3 → bd-1: %v", err)
}
// Step 2: Simulate importing issues with same IDs but different content
importedIssues := []*types.Issue{
{
ID: testIssueBD1,
Title: "Imported BD-1",
Description: "From import",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
},
{
ID: testIssueBD2,
Title: "Imported BD-2",
Description: "From import",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
},
{
ID: "bd-3",
Title: "Imported BD-3",
Description: "From import",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
},
}
// Step 3: Detect collisions
collisionResult, err := sqlite.DetectCollisions(ctx, store, importedIssues)
if err != nil {
t.Fatalf("collision detection failed: %v", err)
}
if len(collisionResult.Collisions) != 3 {
t.Fatalf("expected 3 collisions, got %d", len(collisionResult.Collisions))
}
// Step 4: Resolve collisions
allExisting, err := store.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
t.Fatalf("failed to get existing issues: %v", err)
}
if err := sqlite.ScoreCollisions(ctx, store, collisionResult.Collisions, allExisting); err != nil {
t.Fatalf("failed to score collisions: %v", err)
}
idMapping, err := sqlite.RemapCollisions(ctx, store, collisionResult.Collisions, allExisting)
if err != nil {
t.Fatalf("RemapCollisions failed: %v", err)
}
// Step 5: Verify dependencies are preserved on remapped issues
// With content-hash scoring, all existing issues get remapped to new IDs
t.Logf("\n=== Verifying Dependencies Preserved on Remapped Issues ===")
t.Logf("ID Mappings: %v", idMapping)
// The new bd-1, bd-2, bd-3 (incoming issues) should have NO dependencies
newBD1Deps, _ := store.GetDependencyRecords(ctx, "bd-1")
if len(newBD1Deps) != 0 {
t.Errorf("Expected 0 dependencies for new bd-1 (incoming), got %d", len(newBD1Deps))
}
newBD3Deps, _ := store.GetDependencyRecords(ctx, "bd-3")
if len(newBD3Deps) != 0 {
t.Errorf("Expected 0 dependencies for new bd-3 (incoming), got %d", len(newBD3Deps))
}
// The remapped issues should have their dependencies preserved
remappedBD1 := idMapping["bd-1"] // Old bd-1 → new ID
remappedBD2 := idMapping["bd-2"] // Old bd-2 → new ID
remappedBD3 := idMapping["bd-3"] // Old bd-3 → new ID
// Check remapped bd-1's dependency (was bd-1 → bd-2, now should be remappedBD1 → remappedBD2)
remappedBD1Deps, _ := store.GetDependencyRecords(ctx, remappedBD1)
t.Logf("%s dependencies: %d (expected: 1)", remappedBD1, len(remappedBD1Deps))
if len(remappedBD1Deps) != 1 {
t.Errorf("Expected 1 dependency for remapped %s (preserved from old bd-1), got %d",
remappedBD1, len(remappedBD1Deps))
} else if remappedBD1Deps[0].DependsOnID != remappedBD2 {
t.Errorf("Expected %s → %s, got %s → %s",
remappedBD1, remappedBD2, remappedBD1, remappedBD1Deps[0].DependsOnID)
}
// Check remapped bd-3's dependency (was bd-3 → bd-1, now should be remappedBD3 → remappedBD1)
remappedBD3Deps, _ := store.GetDependencyRecords(ctx, remappedBD3)
t.Logf("%s dependencies: %d (expected: 1)", remappedBD3, len(remappedBD3Deps))
if len(remappedBD3Deps) != 1 {
t.Errorf("Expected 1 dependency for remapped %s (preserved from old bd-3), got %d",
remappedBD3, len(remappedBD3Deps))
} else if remappedBD3Deps[0].DependsOnID != remappedBD1 {
t.Errorf("Expected %s → %s, got %s → %s",
remappedBD3, remappedBD1, remappedBD3, remappedBD3Deps[0].DependsOnID)
}
t.Logf("Fix verified: Dependencies preserved correctly on remapped issues with content-hash scoring")
}
// TestRemapCollisionsDoesNotUpdateNonexistentDependencies verifies that
// updateDependencyReferences is effectively a no-op during normal import flow,
// since imported dependencies haven't been added to the database yet when
// RemapCollisions runs.
//
// This test demonstrates that even if we had dependencies with the old imported IDs
// in the database, they are NOT touched because they don't have the NEW remapped IDs.
func TestRemapCollisionsDoesNotUpdateNonexistentDependencies(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "collision-noop-deps-*")
if err != nil {
t.Fatalf("failed to create temp dir: %v", err)
}
defer os.RemoveAll(tmpDir)
dbPath := filepath.Join(tmpDir, "test.db")
store := newTestStoreWithPrefix(t, dbPath, "bd")
ctx := context.Background()
// Step 1: Create existing issue with dependency
existing1 := &types.Issue{
ID: testIssueBD1,
Title: "Existing BD-1",
Description: "Original database issue",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
}
existing2 := &types.Issue{
ID: testIssueBD2,
Title: "Existing BD-2",
Description: "Original database issue",
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
}
if err := store.CreateIssue(ctx, existing1, "test"); err != nil {
t.Fatalf("failed to create existing issue bd-1: %v", err)
}
if err := store.CreateIssue(ctx, existing2, "test"); err != nil {
t.Fatalf("failed to create existing issue bd-2: %v", err)
}
// Add dependency between existing issues
existingDep := &types.Dependency{
IssueID: testIssueBD1,
DependsOnID: testIssueBD2,
Type: types.DepBlocks,
}
if err := store.AddDependency(ctx, existingDep, "test"); err != nil {
t.Fatalf("failed to add existing dependency: %v", err)
}
// Step 2: Import colliding issues (without dependencies in DB)
imported := []*types.Issue{
{
ID: testIssueBD1,
Title: "Imported BD-1",
Description: "From import, will be remapped",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
},
}
// Detect and resolve collisions
collisionResult, err := sqlite.DetectCollisions(ctx, store, imported)
if err != nil {
t.Fatalf("collision detection failed: %v", err)
}
allExisting, _ := store.SearchIssues(ctx, "", types.IssueFilter{})
if err := sqlite.ScoreCollisions(ctx, store, collisionResult.Collisions, allExisting); err != nil {
t.Fatalf("failed to score collisions: %v", err)
}
// Now remap collisions - this should NOT touch the existing bd-1 → bd-2 dependency
idMapping, err := sqlite.RemapCollisions(ctx, store, collisionResult.Collisions, allExisting)
if err != nil {
t.Fatalf("RemapCollisions failed: %v", err)
}
// Step 3: Verify dependencies are preserved correctly
// With content-hash scoring: existing hash > incoming hash, so RemapIncoming=false
// This means: existing bd-1 → remapped to new ID, incoming bd-1 takes over bd-1
// The remapped issue (old bd-1) should have its dependency preserved
remappedID := idMapping["bd-1"]
remappedDeps, err := store.GetDependencyRecords(ctx, remappedID)
if err != nil {
t.Fatalf("failed to get dependencies for %s: %v", remappedID, err)
}
if len(remappedDeps) != 1 {
t.Errorf("Expected 1 dependency for remapped %s (preserved from old bd-1), got %d",
remappedID, len(remappedDeps))
} else {
// The dependency should now be remappedID → bd-2 (updated from bd-1 → bd-2)
if remappedDeps[0].DependsOnID != testIssueBD2 {
t.Errorf("Expected %s → bd-2, got %s → %s", remappedID, remappedID, remappedDeps[0].DependsOnID)
}
}
// The new bd-1 (incoming issue) should have no dependencies
// (because dependencies are imported later in Phase 5)
newBD1Deps, err := store.GetDependencyRecords(ctx, "bd-1")
if err != nil {
t.Fatalf("failed to get dependencies for bd-1: %v", err)
}
if len(newBD1Deps) != 0 {
t.Errorf("Expected 0 dependencies for new bd-1 (dependencies added later), got %d", len(newBD1Deps))
}
t.Logf("Verified: Dependencies preserved correctly during collision resolution with content-hash scoring")
}

731
cmd/bd/import_collision_test.go
View File

@@ -1,731 +0,0 @@
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/steveyegge/beads/internal/storage/sqlite"
"github.com/steveyegge/beads/internal/types"
)
// TestImportSimpleCollision tests the basic collision detection and resolution
func TestImportSimpleCollision(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "bd-collision-test-*")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Logf("Warning: cleanup failed: %v", err)
}
}()
dbPath := filepath.Join(tmpDir, "test.db")
testStore := newTestStoreWithPrefix(t, dbPath, "bd")
ctx := context.Background()
// Create existing issue with a higher ID to avoid conflicts with auto-generated IDs
existing := &types.Issue{
ID: "bd-10",
Title: "Existing issue",
Description: "Original description",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
if err := testStore.CreateIssue(ctx, existing, "test"); err != nil {
t.Fatalf("Failed to create existing issue: %v", err)
}
// Prepare import with collision
incoming := &types.Issue{
ID: "bd-10",
Title: "MODIFIED issue",
Description: "Different description",
Status: types.StatusInProgress,
Priority: 2,
IssueType: types.TypeBug,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
incomingIssues := []*types.Issue{incoming}
// Test collision detection
result, err := sqlite.DetectCollisions(ctx, testStore, incomingIssues)
if err != nil {
t.Fatalf("DetectCollisions failed: %v", err)
}
if len(result.Collisions) != 1 {
t.Fatalf("Expected 1 collision, got %d", len(result.Collisions))
}
if result.Collisions[0].ID != "bd-10" {
t.Errorf("Expected collision ID bd-10, got %s", result.Collisions[0].ID)
}
// Test resolution
allExisting, _ := testStore.SearchIssues(ctx, "", types.IssueFilter{})
if err := sqlite.ScoreCollisions(ctx, testStore, result.Collisions, allExisting); err != nil {
t.Fatalf("ScoreCollisions failed: %v", err)
}
idMapping, err := sqlite.RemapCollisions(ctx, testStore, result.Collisions, allExisting)
if err != nil {
t.Fatalf("RemapCollisions failed: %v", err)
}
if len(idMapping) != 1 {
t.Fatalf("Expected 1 remapping, got %d", len(idMapping))
}
newID := idMapping["bd-10"]
if newID == "" {
t.Fatal("Expected bd-10 to be remapped")
}
// Verify remapped issue exists
remapped, err := testStore.GetIssue(ctx, newID)
if err != nil {
t.Fatalf("Failed to get remapped issue: %v", err)
}
if remapped == nil {
t.Fatal("Remapped issue not found")
}
if remapped.Title != "MODIFIED issue" {
t.Errorf("Remapped issue title = %s, want 'MODIFIED issue'", remapped.Title)
}
// Verify original issue unchanged
original, err := testStore.GetIssue(ctx, "bd-10")
if err != nil {
t.Fatalf("Failed to get original issue: %v", err)
}
if original.Title != "Existing issue" {
t.Errorf("Original issue modified: %s", original.Title)
}
}
// TestImportMultipleCollisions tests handling of multiple colliding issues
func TestImportMultipleCollisions(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "bd-collision-test-*")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Logf("Warning: cleanup failed: %v", err)
}
}()
dbPath := filepath.Join(tmpDir, "test.db")
testStore := newTestStoreWithPrefix(t, dbPath, "bd")
ctx := context.Background()
// Create existing issues with high IDs to avoid conflicts with auto-generated sequence
for i := 100; i <= 102; i++ {
issue := &types.Issue{
ID: fmt.Sprintf("bd-%d", i),
Title: fmt.Sprintf("Existing issue %d", i),
Description: "Original",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
if err := testStore.CreateIssue(ctx, issue, "test"); err != nil {
t.Fatalf("Failed to create issue %d: %v", i, err)
}
}
// Prepare import with multiple collisions
incomingIssues := []*types.Issue{
{
ID: "bd-100",
Title: "Modified 1",
Description: "Changed",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
},
{
ID: "bd-101",
Title: "Modified 2",
Description: "Changed",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
},
{
ID: "bd-102",
Title: "Modified 3",
Description: "Changed",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
},
}
result, err := sqlite.DetectCollisions(ctx, testStore, incomingIssues)
if err != nil {
t.Fatalf("DetectCollisions failed: %v", err)
}
if len(result.Collisions) != 3 {
t.Fatalf("Expected 3 collisions, got %d", len(result.Collisions))
}
// Resolve collisions
allExisting, _ := testStore.SearchIssues(ctx, "", types.IssueFilter{})
if err := sqlite.ScoreCollisions(ctx, testStore, result.Collisions, allExisting); err != nil {
t.Fatalf("ScoreCollisions failed: %v", err)
}
idMapping, err := sqlite.RemapCollisions(ctx, testStore, result.Collisions, allExisting)
if err != nil {
t.Fatalf("RemapCollisions failed: %v", err)
}
if len(idMapping) != 3 {
t.Fatalf("Expected 3 remappings, got %d", len(idMapping))
}
// Verify all remappings
for oldID, newID := range idMapping {
remapped, err := testStore.GetIssue(ctx, newID)
if err != nil {
t.Fatalf("Failed to get remapped issue %s: %v", newID, err)
}
if remapped == nil {
t.Fatalf("Remapped issue %s not found", newID)
}
if !strings.Contains(remapped.Title, "Modified") {
t.Errorf("Remapped issue %s has wrong title: %s", oldID, remapped.Title)
}
}
}
// TestImportTextReferenceUpdates tests that text references are updated during remapping
func TestImportTextReferenceUpdates(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "bd-collision-test-*")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Logf("Warning: cleanup failed: %v", err)
}
}()
dbPath := filepath.Join(tmpDir, "test.db")
testStore := newTestStoreWithPrefix(t, dbPath, "bd")
ctx := context.Background()
// Create existing issues with text references
issue1 := &types.Issue{
ID: "bd-10",
Title: "Issue 1",
Description: "This depends on bd-11 and bd-12",
Design: "Implementation uses bd-11 approach",
Notes: "See bd-12 for details",
AcceptanceCriteria: "Must work with bd-11",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
issue2 := &types.Issue{
ID: "bd-11",
Title: "Issue 2",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
issue3 := &types.Issue{
ID: "bd-12",
Title: "Issue 3",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
if err := testStore.CreateIssue(ctx, issue1, "test"); err != nil {
t.Fatalf("Failed to create issue 1: %v", err)
}
if err := testStore.CreateIssue(ctx, issue2, "test"); err != nil {
t.Fatalf("Failed to create issue 2: %v", err)
}
if err := testStore.CreateIssue(ctx, issue3, "test"); err != nil {
t.Fatalf("Failed to create issue 3: %v", err)
}
// Import colliding issues
incomingIssues := []*types.Issue{
{
ID: "bd-11",
Title: "Modified Issue 2",
Status: types.StatusInProgress,
Priority: 2,
IssueType: types.TypeBug,
},
{
ID: "bd-12",
Title: "Modified Issue 3",
Status: types.StatusInProgress,
Priority: 2,
IssueType: types.TypeBug,
},
}
result, err := sqlite.DetectCollisions(ctx, testStore, incomingIssues)
if err != nil {
t.Fatalf("DetectCollisions failed: %v", err)
}
if len(result.Collisions) != 2 {
t.Fatalf("Expected 2 collisions, got %d", len(result.Collisions))
}
// Resolve collisions
allExisting, _ := testStore.SearchIssues(ctx, "", types.IssueFilter{})
if err := sqlite.ScoreCollisions(ctx, testStore, result.Collisions, allExisting); err != nil {
t.Fatalf("ScoreCollisions failed: %v", err)
}
idMapping, err := sqlite.RemapCollisions(ctx, testStore, result.Collisions, allExisting)
if err != nil {
t.Fatalf("RemapCollisions failed: %v", err)
}
if len(idMapping) != 2 {
t.Fatalf("Expected 2 remappings, got %d", len(idMapping))
}
newID2 := idMapping["bd-11"]
newID3 := idMapping["bd-12"]
// Verify text references were updated in issue 1
updated, err := testStore.GetIssue(ctx, "bd-10")
if err != nil {
t.Fatalf("Failed to get updated issue 1: %v", err)
}
if !strings.Contains(updated.Description, newID2) {
t.Errorf("Description not updated: %s (should contain %s)", updated.Description, newID2)
}
if !strings.Contains(updated.Description, newID3) {
t.Errorf("Description not updated: %s (should contain %s)", updated.Description, newID3)
}
if !strings.Contains(updated.Design, newID2) {
t.Errorf("Design not updated: %s (should contain %s)", updated.Design, newID2)
}
if !strings.Contains(updated.Notes, newID3) {
t.Errorf("Notes not updated: %s (should contain %s)", updated.Notes, newID3)
}
if !strings.Contains(updated.AcceptanceCriteria, newID2) {
t.Errorf("AcceptanceCriteria not updated: %s (should contain %s)", updated.AcceptanceCriteria, newID2)
}
// Verify old IDs are NOT present
if strings.Contains(updated.Description, "bd-11") {
t.Error("Old ID bd-11 still present in Description")
}
if strings.Contains(updated.Description, "bd-12") {
t.Error("Old ID bd-12 still present in Description")
}
}
// TestImportPartialIDMatch tests word boundary matching (bd-10 vs bd-100)
func TestImportPartialIDMatch(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "bd-collision-test-*")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Logf("Warning: cleanup failed: %v", err)
}
}()
dbPath := filepath.Join(tmpDir, "test.db")
testStore := newTestStoreWithPrefix(t, dbPath, "bd")
ctx := context.Background()
// Create issues with similar IDs (use higher numbers to avoid conflicts)
issues := []*types.Issue{
{
ID: "bd-50",
Title: "Issue 50",
Description: "References bd-100 and bd-1000 and bd-10000",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
},
{
ID: "bd-100",
Title: "Issue 100",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
},
{
ID: "bd-1000",
Title: "Issue 1000",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
},
{
ID: "bd-10000",
Title: "Issue 10000",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
},
}
for _, issue := range issues {
if err := testStore.CreateIssue(ctx, issue, "test"); err != nil {
t.Fatalf("Failed to create %s: %v", issue.ID, err)
}
}
// Import colliding bd-100
incomingIssues := []*types.Issue{
{
ID: "bd-100",
Title: "Modified Issue 100",
Status: types.StatusInProgress,
Priority: 2,
IssueType: types.TypeBug,
},
}
result, err := sqlite.DetectCollisions(ctx, testStore, incomingIssues)
if err != nil {
t.Fatalf("DetectCollisions failed: %v", err)
}
// Resolve collision
allExisting, _ := testStore.SearchIssues(ctx, "", types.IssueFilter{})
if err := sqlite.ScoreCollisions(ctx, testStore, result.Collisions, allExisting); err != nil {
t.Fatalf("ScoreCollisions failed: %v", err)
}
idMapping, err := sqlite.RemapCollisions(ctx, testStore, result.Collisions, allExisting)
if err != nil {
t.Fatalf("RemapCollisions failed: %v", err)
}
newID100 := idMapping["bd-100"]
// Verify only bd-100 was replaced, not bd-1000 or bd-10000
updated, err := testStore.GetIssue(ctx, "bd-50")
if err != nil {
t.Fatalf("Failed to get updated issue: %v", err)
}
if !strings.Contains(updated.Description, newID100) {
t.Errorf("bd-100 not replaced: %s", updated.Description)
}
if !strings.Contains(updated.Description, "bd-1000") {
t.Errorf("bd-1000 incorrectly replaced: %s", updated.Description)
}
if !strings.Contains(updated.Description, "bd-10000") {
t.Errorf("bd-10000 incorrectly replaced: %s", updated.Description)
}
// Make sure old bd-100 reference is gone
if strings.Contains(updated.Description, " bd-100 ") || strings.Contains(updated.Description, " bd-100,") {
t.Errorf("Old bd-100 reference still present: %s", updated.Description)
}
}
// TestImportExactMatch tests idempotent import (no collision)
func TestImportExactMatch(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "bd-collision-test-*")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Logf("Warning: cleanup failed: %v", err)
}
}()
dbPath := filepath.Join(tmpDir, "test.db")
testStore := newTestStoreWithPrefix(t, dbPath, "bd")
ctx := context.Background()
// Create existing issue
existing := &types.Issue{
ID: "bd-10",
Title: "Test issue",
Description: "Description",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
if err := testStore.CreateIssue(ctx, existing, "test"); err != nil {
t.Fatalf("Failed to create issue: %v", err)
}
// Import identical issue
incoming := &types.Issue{
ID: "bd-10",
Title: "Test issue",
Description: "Description",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
}
result, err := sqlite.DetectCollisions(ctx, testStore, []*types.Issue{incoming})
if err != nil {
t.Fatalf("DetectCollisions failed: %v", err)
}
// Should be exact match, not collision
if len(result.Collisions) != 0 {
t.Errorf("Expected 0 collisions for exact match, got %d", len(result.Collisions))
}
if len(result.ExactMatches) != 1 {
t.Errorf("Expected 1 exact match, got %d", len(result.ExactMatches))
}
}
// TestImportMixedScenario tests import with exact matches, collisions, and new issues
func TestImportMixedScenario(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "bd-collision-test-*")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Logf("Warning: cleanup failed: %v", err)
}
}()
dbPath := filepath.Join(tmpDir, "test.db")
testStore := newTestStoreWithPrefix(t, dbPath, "bd")
ctx := context.Background()
// Create existing issues with high IDs
for i := 200; i <= 201; i++ {
issue := &types.Issue{
ID: fmt.Sprintf("bd-%d", i),
Title: fmt.Sprintf("Issue %d", i),
Description: "Original",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
if err := testStore.CreateIssue(ctx, issue, "test"); err != nil {
t.Fatalf("Failed to create issue %d: %v", i, err)
}
}
// Import: exact match (bd-200), collision (bd-201), new (bd-202)
incomingIssues := []*types.Issue{
{
ID: "bd-200",
Title: "Issue 200",
Description: "Original",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
},
{
ID: "bd-201",
Title: "Modified Issue 201",
Description: "Changed",
Status: types.StatusInProgress,
Priority: 2,
IssueType: types.TypeBug,
},
{
ID: "bd-202",
Title: "New Issue",
Description: "Brand new",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeFeature,
},
}
result, err := sqlite.DetectCollisions(ctx, testStore, incomingIssues)
if err != nil {
t.Fatalf("DetectCollisions failed: %v", err)
}
if len(result.ExactMatches) != 1 {
t.Errorf("Expected 1 exact match, got %d", len(result.ExactMatches))
}
if len(result.Collisions) != 1 {
t.Errorf("Expected 1 collision, got %d", len(result.Collisions))
}
if len(result.NewIssues) != 1 {
t.Errorf("Expected 1 new issue, got %d", len(result.NewIssues))
}
}
// TestImportWithDependenciesInJSONL tests importing issues with embedded dependencies
func TestImportWithDependenciesInJSONL(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "bd-collision-test-*")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Logf("Warning: cleanup failed: %v", err)
}
}()
dbPath := filepath.Join(tmpDir, "test.db")
testStore := newTestStoreWithPrefix(t, dbPath, "bd")
ctx := context.Background()
// Create JSONL with dependencies
jsonl := `{"id":"bd-10","title":"Issue 1","status":"open","priority":1,"issue_type":"task"}
{"id":"bd-11","title":"Issue 2","status":"open","priority":1,"issue_type":"task","dependencies":[{"issue_id":"bd-11","depends_on_id":"bd-10","type":"blocks"}]}`
// Parse JSONL
var issues []*types.Issue
for _, line := range strings.Split(strings.TrimSpace(jsonl), "\n") {
var issue types.Issue
if err := json.Unmarshal([]byte(line), &issue); err != nil {
t.Fatalf("Failed to parse JSONL: %v", err)
}
issues = append(issues, &issue)
}
// Create issues
for _, issue := range issues {
if err := testStore.CreateIssue(ctx, issue, "test"); err != nil {
t.Fatalf("Failed to create issue: %v", err)
}
}
// Add dependencies from JSONL
for _, issue := range issues {
for _, dep := range issue.Dependencies {
if err := testStore.AddDependency(ctx, dep, "test"); err != nil {
t.Fatalf("Failed to add dependency: %v", err)
}
}
}
// Verify dependency
deps, err := testStore.GetDependencyRecords(ctx, "bd-11")
if err != nil {
t.Fatalf("Failed to get dependencies: %v", err)
}
if len(deps) != 1 {
t.Fatalf("Expected 1 dependency, got %d", len(deps))
}
if deps[0].DependsOnID != "bd-10" {
t.Errorf("Dependency target = %s, want bd-1", deps[0].DependsOnID)
}
}
func TestImportCounterSyncAfterHighID(t *testing.T) {
tmpDir, err := os.MkdirTemp("", "bd-collision-test-*")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Logf("Warning: cleanup failed: %v", err)
}
}()
dbPath := filepath.Join(tmpDir, "test.db")
testStore := newTestStoreWithPrefix(t, dbPath, "bd")
ctx := context.Background()
if err := testStore.SetConfig(ctx, "issue_prefix", "bd"); err != nil {
t.Fatalf("Failed to set issue prefix: %v", err)
}
for i := 0; i < 3; i++ {
issue := &types.Issue{
Title: fmt.Sprintf("Auto issue %d", i+1),
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
}
if err := testStore.CreateIssue(ctx, issue, "test"); err != nil {
t.Fatalf("Failed to create auto issue %d: %v", i+1, err)
}
}
highIDIssue := &types.Issue{
ID: "bd-100",
Title: "High ID issue",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
if err := testStore.CreateIssue(ctx, highIDIssue, "import"); err != nil {
t.Fatalf("Failed to import high ID issue: %v", err)
}
// REMOVED (bd-c7af): Counter sync - no longer needed with hash IDs
// Step 5: Create another auto-generated issue
// This should get bd-101 (counter should have synced to 100), not bd-4
newIssue := &types.Issue{
Title: "New issue after import",
Status: types.StatusOpen,
Priority: 1,
IssueType: types.TypeTask,
}
if err := testStore.CreateIssue(ctx, newIssue, "test"); err != nil {
t.Fatalf("Failed to create new issue: %v", err)
}
if newIssue.ID != "bd-101" {
t.Errorf("Expected new issue to get ID bd-101, got %s", newIssue.ID)
}
}

14
cmd/bd/testdata/blocked.txt vendored
View File

@@ -1,7 +1,15 @@
# Test bd blocked command
bd init --prefix test
# Create first issue
bd create 'First issue'
bd create 'Second issue' --deps test-1
cp stdout first.txt
exec sh -c 'grep -oE "test-[a-f0-9]+" first.txt > first_id.txt'
# Create second issue that depends on first
exec sh -c 'bd create "Second issue" --deps $(cat first_id.txt)'
cp stdout second.txt
# Check for blocked issues
bd blocked
stdout 'Blocked issues'
stdout 'test-2'
stdout 'test-'

15
cmd/bd/testdata/close.txt vendored
View File

@@ -1,8 +1,15 @@
# Test bd close command
bd init --prefix test
bd create 'Issue to close'
bd close test-1 --reason 'Fixed'
stdout 'Closed test-1'
bd show test-1
# Create issue and capture its hash ID
bd create 'Issue to close'
cp stdout issue.txt
exec sh -c 'grep -oE "test-[a-f0-9]+" issue.txt > issue_id.txt'
# Close the issue
exec sh -c 'bd close $(cat issue_id.txt) --reason Fixed'
stdout 'Closed test-'
# Verify it's closed
exec sh -c 'bd show $(cat issue_id.txt)'
stdout 'closed'

22
cmd/bd/testdata/dep_add.txt vendored
View File

@@ -1,10 +1,24 @@
# Test bd dep add command
bd init --prefix test
# Create issues and capture their hash IDs from output
bd create 'First issue'
bd create 'Second issue'
bd dep add test-2 test-1
cp stdout first.txt
grep 'Created issue: test-' first.txt
bd create 'Second issue'
cp stdout second.txt
grep 'Created issue: test-' second.txt
# Extract IDs using grep (hash IDs are test-XXXXXXXX format)
exec sh -c 'grep -oE "test-[a-f0-9]+" first.txt > first_id.txt'
exec sh -c 'grep -oE "test-[a-f0-9]+" second.txt > second_id.txt'
# Add dependency: second depends on first
exec sh -c 'bd dep add $(cat second_id.txt) $(cat first_id.txt)'
stdout 'Added dependency'
bd show test-2
# Verify the dependency was added
exec sh -c 'bd show $(cat second_id.txt)'
stdout 'Depends on'
stdout 'test-1'
stdout 'test-'

20
cmd/bd/testdata/dep_remove.txt vendored
View File

@@ -1,10 +1,22 @@
# Test bd dep remove command
bd init --prefix test
# Create issues and capture their hash IDs
bd create 'First issue'
cp stdout first.txt
exec sh -c 'grep -oE "test-[a-f0-9]+" first.txt > first_id.txt'
bd create 'Second issue'
bd dep add test-2 test-1
bd dep remove test-2 test-1
cp stdout second.txt
exec sh -c 'grep -oE "test-[a-f0-9]+" second.txt > second_id.txt'
# Add dependency
exec sh -c 'bd dep add $(cat second_id.txt) $(cat first_id.txt)'
stdout 'Added dependency'
# Remove dependency
exec sh -c 'bd dep remove $(cat second_id.txt) $(cat first_id.txt)'
stdout 'Removed dependency'
bd show test-2
! stdout 'test-1'
# Verify dependency is gone
exec sh -c 'bd show $(cat second_id.txt) | grep -v "Depends on"'

17
cmd/bd/testdata/dep_tree.txt vendored
View File

@@ -1,7 +1,18 @@
# Test bd dep tree command
bd init --prefix test
# Create issues and capture their hash IDs
bd create 'Root issue'
cp stdout root.txt
exec sh -c 'grep -oE "test-[a-f0-9]+" root.txt > root_id.txt'
bd create 'Child issue'
bd dep add test-2 test-1
bd dep tree test-1
stdout 'test-1'
cp stdout child.txt
exec sh -c 'grep -oE "test-[a-f0-9]+" child.txt > child_id.txt'
# Add dependency: child depends on root
exec sh -c 'bd dep add $(cat child_id.txt) $(cat root_id.txt)'
# Show dependency tree for root
exec sh -c 'bd dep tree $(cat root_id.txt)'
stdout 'test-'

12
cmd/bd/testdata/show.txt vendored
View File

@@ -1,8 +1,16 @@
# Test bd show command
bd init --prefix test
bd create 'Test issue for show'
bd show test-1
# Create issue and capture its hash ID
bd create 'Test issue for show'
cp stdout issue.txt
grep 'Created issue: test-' issue.txt
# Extract ID using grep
exec sh -c 'grep -oE "test-[a-f0-9]+" issue.txt > issue_id.txt'
# Show the issue
exec sh -c 'bd show $(cat issue_id.txt)'
stdout 'Test issue for show'
stdout 'Status:'
stdout 'Priority:'

11
cmd/bd/testdata/stats.txt vendored
View File

@@ -1,8 +1,17 @@
# Test bd stats command
bd init --prefix test
# Create issues
bd create 'First issue'
cp stdout first.txt
exec sh -c 'grep -oE "test-[a-f0-9]+" first.txt > first_id.txt'
bd create 'Second issue'
bd close test-1
# Close one issue
exec sh -c 'bd close $(cat first_id.txt)'
# Check stats
bd stats
stdout 'Total Issues:'
stdout 'Open:'

14
cmd/bd/testdata/update.txt vendored
View File

@@ -1,8 +1,18 @@
# Test bd update command
bd init --prefix test
# Create issue and capture its hash ID
bd create 'Issue to update'
bd update test-1 --status in_progress
cp stdout issue.txt
grep 'Created issue: test-' issue.txt
# Extract ID using grep
exec sh -c 'grep -oE "test-[a-f0-9]+" issue.txt > issue_id.txt'
# Update the issue status
exec sh -c 'bd update $(cat issue_id.txt) --status in_progress'
stdout 'Updated issue:'
bd show test-1
# Verify the update
exec sh -c 'bd show $(cat issue_id.txt)'
stdout 'in_progress'

147
docs/COLLISION_MATH.md Normal file
View File

@@ -0,0 +1,147 @@
# Hash ID Collision Mathematics
This document explains the collision probability calculations for beads' adaptive hash-based IDs and the thresholds used for automatic length scaling.
## Birthday Paradox Formula
The collision probability for hash IDs is calculated using the birthday paradox:
```
P(collision) ≈ 1 - e^(-n²/2N)
```
Where:
- **n** = number of issues in database
- **N** = total possible IDs = 36^length (lowercase alphanumeric: `[a-z0-9]`)
## Collision Probability Table
| DB Size | 4-char | 5-char | 6-char | 7-char | 8-char |
|---------|--------|--------|--------|--------|--------|
| 50 | 0.07% | 0.00% | 0.00% | 0.00% | 0.00% |
| 100 | 0.30% | 0.01% | 0.00% | 0.00% | 0.00% |
| 200 | 1.18% | 0.03% | 0.00% | 0.00% | 0.00% |
| 500 | 7.17% | 0.21% | 0.01% | 0.00% | 0.00% |
| 1,000 | 25.75% | 0.82% | 0.02% | 0.00% | 0.00% |
| 2,000 | 69.60% | 3.25% | 0.09% | 0.00% | 0.00% |
| 5,000 | 99.94% | 18.68% | 0.57% | 0.02% | 0.00% |
| 10,000 | 100% | 56.26% | 2.27% | 0.06% | 0.00% |
### Key Insights
- **4-char IDs** are safe up to ~500 issues (7% collision risk)
- **5-char IDs** are safe up to ~1,500 issues (2% collision risk)
- **6-char IDs** are safe up to ~10,000 issues (2% collision risk)
- **7-char IDs** support 100,000+ issues with negligible collision risk
- **8-char IDs** support millions of issues
## Expected Number of Collisions
This shows the average number of actual hash collisions you'll encounter:
| DB Size | 4-char | 5-char | 6-char | 7-char | 8-char |
|---------|--------|--------|--------|--------|--------|
| 100 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
| 500 | 0.07 | 0.00 | 0.00 | 0.00 | 0.00 |
| 1,000 | 0.30 | 0.01 | 0.00 | 0.00 | 0.00 |
| 2,000 | 1.19 | 0.03 | 0.00 | 0.00 | 0.00 |
| 5,000 | 7.44 | 0.21 | 0.01 | 0.00 | 0.00 |
| 10,000 | 29.77 | 0.83 | 0.02 | 0.00 | 0.00 |
**Example:** With 5,000 issues using 4-char IDs, you'll likely see ~7 hash collisions (automatically retried with +1 nonce).
## Adaptive Scaling Strategy
Beads automatically increases ID length when the collision probability exceeds **25%** (configurable via `max_collision_prob`).
### Default Thresholds (25% max collision)
| Database Size | ID Length | Collision Probability at Max |
|---------------|-----------|------------------------------|
| 0-500 | 4 chars | 7.17% at 500 issues |
| 501-1,500 | 5 chars | 1.84% at 1,500 issues |
| 1,501-5,000 | 5 chars | 18.68% at 5,000 issues |
| 5,001-15,000 | 6 chars | 5.04% at 15,000 issues |
| 15,001+ | continues scaling as needed |
### Why 25%?
The 25% threshold balances:
- **Readability:** Keep IDs short for small databases
- **Safety:** Avoid frequent collision retries
- **Scalability:** Grow gracefully as database expands
Even at 25% collision *probability*, the *expected number* of actual collisions is low (< 1 collision per 1,000 issues created).
## Alternative Thresholds
You can customize the threshold with `bd config set max_collision_prob <value>`:
### Conservative (10% threshold)
| DB Size | ID Length |
|---------|-----------|
| 0-200 | 4 chars |
| 201-1,000 | 5 chars |
| 1,001-5,000 | 6 chars |
| 5,001+ | continues scaling |
### Aggressive (50% threshold)
| DB Size | ID Length |
|---------|-----------|
| 0-500 | 4 chars |
| 501-2,000 | 5 chars |
| 2,001-10,000 | 6 chars |
| 10,001+ | continues scaling |
## Collision Resolution
When a hash collision occurs (same ID generated twice), beads automatically:
1. Tries base length with different nonce (10 attempts)
2. Tries base+1 length with different nonce (10 attempts)
3. Tries base+2 length with different nonce (10 attempts)
**Total: 30 attempts** before failing (astronomically unlikely).
Example with 4-char base:
- `bd-a3f2` (nonce 0) - collision!
- `bd-a3f2` (nonce 1) - collision again!
- `bd-b7d4` (nonce 2) - success! ✓
## Mathematical Properties
### ID Space Size
| Length | Possible IDs | Notation |
|--------|--------------|----------|
| 3 chars | 46,656 | 36³ |
| 4 chars | 1,679,616 | 36⁴ ≈ 1.7M |
| 5 chars | 60,466,176 | 36⁵ ≈ 60M |
| 6 chars | 2,176,782,336 | 36⁶ ≈ 2.2B |
| 7 chars | 78,364,164,096 | 36⁷ ≈ 78B |
| 8 chars | 2,821,109,907,456 | 36⁸ ≈ 2.8T |
### Why Alphanumeric?
Using `[a-z0-9]` (36 characters) instead of hex (16 characters):
- **4-char alphanumeric** ≈ **6-char hex** in capacity
- More readable: `bd-a3f2` vs `bd-a3f2e1`
- Easier to type and communicate
## Verification
Run the collision calculator yourself:
```bash
go run scripts/collision-calculator.go
```
This generates the tables above and shows adaptive scaling strategy for any threshold.
## Related Documentation
- [ADAPTIVE_IDS.md](ADAPTIVE_IDS.md) - Configuration and usage guide
- [HASH_ID_DESIGN.md](HASH_ID_DESIGN.md) - Overall hash ID design rationale
- [CONFIG.md](../CONFIG.md) - All configuration options

90
internal/importer/importer.go
View File

@@ -207,35 +207,11 @@ func handleCollisions(ctx context.Context, sqliteStore *sqlite.SQLiteStorage, is
result.CollisionIDs = append(result.CollisionIDs, collision.ID)
}
// Handle collisions
// Handle collisions - with hash IDs, collisions shouldn't happen
if len(collisionResult.Collisions) > 0 {
if opts.DryRun {
return issues, nil
}
if !opts.ResolveCollisions {
return nil, fmt.Errorf("collision detected for issues: %v (use --resolve-collisions to auto-resolve)", result.CollisionIDs)
}
// Resolve collisions by scoring and remapping
allExistingIssues, err := sqliteStore.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
return nil, fmt.Errorf("failed to get existing issues for collision resolution: %w", err)
}
// Phase 2: Score collisions
if err := sqlite.ScoreCollisions(ctx, sqliteStore, collisionResult.Collisions, allExistingIssues); err != nil {
return nil, fmt.Errorf("failed to score collisions: %w", err)
}
// Phase 3: Remap collisions
idMapping, err := sqlite.RemapCollisions(ctx, sqliteStore, collisionResult.Collisions, allExistingIssues)
if err != nil {
return nil, fmt.Errorf("failed to remap collisions: %w", err)
}
result.IDMapping = idMapping
result.Created = len(collisionResult.Collisions)
// Hash-based IDs make collisions extremely unlikely (same ID = same content)
// If we get here, it's likely a bug or manual ID manipulation
return nil, fmt.Errorf("collision detected for issues: %v (this should not happen with hash-based IDs)", result.CollisionIDs)
// Remove colliding issues from the list (they're already processed)
filteredIssues := make([]*types.Issue, 0)
@@ -251,17 +227,8 @@ func handleCollisions(ctx context.Context, sqliteStore *sqlite.SQLiteStorage, is
return filteredIssues, nil
}
// Phase 4: Apply renames (deletions of old IDs) if any were detected
if len(collisionResult.Renames) > 0 && !opts.DryRun {
// Build mapping for renames: oldID -> newID
renameMapping := make(map[string]string)
for _, rename := range collisionResult.Renames {
renameMapping[rename.OldID] = rename.NewID
}
if err := sqlite.ApplyCollisionResolution(ctx, sqliteStore, collisionResult, renameMapping); err != nil {
return nil, fmt.Errorf("failed to apply rename resolutions: %w", err)
}
}
// Phase 4: Renames removed - obsolete with hash IDs (bd-8e05)
// Hash-based IDs are content-addressed, so renames don't occur
if opts.DryRun {
result.Created = len(collisionResult.NewIssues) + len(collisionResult.Renames)
@@ -405,49 +372,8 @@ func handleRename(ctx context.Context, s *sqlite.SQLiteStorage, existing *types.
return "", fmt.Errorf("failed to create renamed issue %s: %w", incoming.ID, err)
}
// Update references from old ID to new ID
idMapping := map[string]string{existing.ID: incoming.ID}
cache, err := sqlite.BuildReplacementCache(idMapping)
if err != nil {
return "", fmt.Errorf("failed to build replacement cache: %w", err)
}
// Get all issues to update references
dbIssues, err := s.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
return "", fmt.Errorf("failed to get issues for reference update: %w", err)
}
// Update text field references in all issues
for _, issue := range dbIssues {
updates := make(map[string]interface{})
newDesc := sqlite.ReplaceIDReferencesWithCache(issue.Description, cache)
if newDesc != issue.Description {
updates["description"] = newDesc
}
newDesign := sqlite.ReplaceIDReferencesWithCache(issue.Design, cache)
if newDesign != issue.Design {
updates["design"] = newDesign
}
newNotes := sqlite.ReplaceIDReferencesWithCache(issue.Notes, cache)
if newNotes != issue.Notes {
updates["notes"] = newNotes
}
newAC := sqlite.ReplaceIDReferencesWithCache(issue.AcceptanceCriteria, cache)
if newAC != issue.AcceptanceCriteria {
updates["acceptance_criteria"] = newAC
}
if len(updates) > 0 {
if err := s.UpdateIssue(ctx, issue.ID, updates, "import-rename"); err != nil {
return "", fmt.Errorf("failed to update references in issue %s: %w", issue.ID, err)
}
}
}
// Reference updates removed - obsolete with hash IDs (bd-8e05)
// Hash-based IDs are deterministic, so no reference rewriting needed
return oldID, nil
}

644
internal/storage/sqlite/collision.go
View File

@@ -4,8 +4,6 @@ import (
"context"
"crypto/sha256"
"fmt"
"regexp"
"strings"
"github.com/steveyegge/beads/internal/types"
)
@@ -49,64 +47,35 @@ func DetectCollisions(ctx context.Context, s *SQLiteStorage, incomingIssues []*t
NewIssues: make([]string, 0),
}
// Phase 1: Deduplicate within incoming batch
// Group by content hash to find duplicates with different IDs
deduped := deduplicateIncomingIssues(incomingIssues)
// Phase 2: Build content hash map of all DB issues
// This allows us to detect renames (different ID, same content)
dbIssues, err := s.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
return nil, fmt.Errorf("failed to get all DB issues: %w", err)
}
contentToDBIssue := make(map[string]*types.Issue)
for _, dbIssue := range dbIssues {
hash := hashIssueContent(dbIssue)
contentToDBIssue[hash] = dbIssue
// Build content hash map for rename detection
contentToID := make(map[string]string)
for _, incoming := range incomingIssues {
hash := hashIssueContent(incoming)
contentToID[hash] = incoming.ID
}
// Phase 3: Process each incoming issue
for _, incoming := range deduped {
incomingHash := hashIssueContent(incoming)
// Check if issue exists in database by ID
// Check each incoming issue
for _, incoming := range incomingIssues {
existing, err := s.GetIssue(ctx, incoming.ID)
if err != nil {
return nil, fmt.Errorf("failed to check issue %s: %w", incoming.ID, err)
}
if existing == nil {
// Issue doesn't exist by ID - check for rename by content
if dbMatch, found := contentToDBIssue[incomingHash]; found {
// Same content, different ID - this is a rename/remap
// The incoming ID is the NEW canonical ID, existing DB ID is OLD
// Record this as a rename to be handled later (read-only detection)
result.Renames = append(result.Renames, &RenameDetail{
OldID: dbMatch.ID,
NewID: incoming.ID,
Issue: incoming,
})
// Don't add to NewIssues - will be handled by ApplyCollisionResolution
} else {
// Truly new issue
result.NewIssues = append(result.NewIssues, incoming.ID)
}
if err != nil || existing == nil {
// Issue doesn't exist in DB - it's new
result.NewIssues = append(result.NewIssues, incoming.ID)
continue
}
// Issue exists by ID - compare content
conflicts := compareIssues(existing, incoming)
if len(conflicts) == 0 {
// No differences - exact match (idempotent)
// Issue ID exists - check if content matches
conflictingFields := compareIssues(existing, incoming)
if len(conflictingFields) == 0 {
// Exact match - idempotent import
result.ExactMatches = append(result.ExactMatches, incoming.ID)
} else {
// Same ID but different content - collision
// Same ID, different content - collision
// With hash IDs, this shouldn't happen unless manually edited
result.Collisions = append(result.Collisions, &CollisionDetail{
ID: incoming.ID,
IncomingIssue: incoming,
ExistingIssue: existing,
ConflictingFields: conflicts,
ConflictingFields: conflictingFields,
})
}
}
@@ -114,28 +83,16 @@ func DetectCollisions(ctx context.Context, s *SQLiteStorage, incomingIssues []*t
return result, nil
}
// compareIssues compares two issues and returns a list of field names that differ
// Timestamps (CreatedAt, UpdatedAt, ClosedAt) are intentionally not compared
// Dependencies are also not compared (handled separately in import)
// compareIssues returns list of field names that differ between two issues
func compareIssues(existing, incoming *types.Issue) []string {
conflicts := make([]string, 0)
conflicts := []string{}
// Compare all relevant fields
if existing.Title != incoming.Title {
conflicts = append(conflicts, "title")
}
if existing.Description != incoming.Description {
conflicts = append(conflicts, "description")
}
if existing.Design != incoming.Design {
conflicts = append(conflicts, "design")
}
if existing.AcceptanceCriteria != incoming.AcceptanceCriteria {
conflicts = append(conflicts, "acceptance_criteria")
}
if existing.Notes != incoming.Notes {
conflicts = append(conflicts, "notes")
}
if existing.Status != incoming.Status {
conflicts = append(conflicts, "status")
}
@@ -148,557 +105,38 @@ func compareIssues(existing, incoming *types.Issue) []string {
if existing.Assignee != incoming.Assignee {
conflicts = append(conflicts, "assignee")
}
// Compare EstimatedMinutes (handle nil cases)
if !equalIntPtr(existing.EstimatedMinutes, incoming.EstimatedMinutes) {
conflicts = append(conflicts, "estimated_minutes")
if existing.Design != incoming.Design {
conflicts = append(conflicts, "design")
}
// Compare ExternalRef (handle nil cases)
if !equalStringPtr(existing.ExternalRef, incoming.ExternalRef) {
if existing.AcceptanceCriteria != incoming.AcceptanceCriteria {
conflicts = append(conflicts, "acceptance_criteria")
}
if existing.Notes != incoming.Notes {
conflicts = append(conflicts, "notes")
}
if (existing.ExternalRef == nil && incoming.ExternalRef != nil) ||
(existing.ExternalRef != nil && incoming.ExternalRef == nil) ||
(existing.ExternalRef != nil && incoming.ExternalRef != nil && *existing.ExternalRef != *incoming.ExternalRef) {
conflicts = append(conflicts, "external_ref")
}
return conflicts
}
// equalIntPtr compares two *int pointers for equality
func equalIntPtr(a, b *int) bool {
if a == nil && b == nil {
return true
}
if a == nil || b == nil {
return false
}
return *a == *b
}
// equalStringPtr compares two *string pointers for equality
func equalStringPtr(a, b *string) bool {
if a == nil && b == nil {
return true
}
if a == nil || b == nil {
return false
}
return *a == *b
}
// hashIssueContent creates a deterministic hash of an issue's content.
// Uses all substantive fields (excluding timestamps and ID) to ensure
// that identical content produces identical hashes across all clones.
// hashIssueContent creates a deterministic hash of issue content (excluding ID and timestamps)
func hashIssueContent(issue *types.Issue) string {
h := sha256.New()
// Hash all substantive fields in a stable order
h.Write([]byte(issue.Title))
h.Write([]byte{0}) // separator
h.Write([]byte(issue.Description))
h.Write([]byte{0})
h.Write([]byte(issue.Design))
h.Write([]byte{0})
h.Write([]byte(issue.AcceptanceCriteria))
h.Write([]byte{0})
h.Write([]byte(issue.Notes))
h.Write([]byte{0})
h.Write([]byte(issue.Status))
h.Write([]byte{0})
h.Write([]byte(fmt.Sprintf("%d", issue.Priority)))
h.Write([]byte{0})
h.Write([]byte(issue.IssueType))
h.Write([]byte{0})
h.Write([]byte(issue.Assignee))
h.Write([]byte{0})
fmt.Fprintf(h, "title:%s\n", issue.Title)
fmt.Fprintf(h, "description:%s\n", issue.Description)
fmt.Fprintf(h, "status:%s\n", issue.Status)
fmt.Fprintf(h, "priority:%d\n", issue.Priority)
fmt.Fprintf(h, "type:%s\n", issue.IssueType)
fmt.Fprintf(h, "assignee:%s\n", issue.Assignee)
fmt.Fprintf(h, "design:%s\n", issue.Design)
fmt.Fprintf(h, "acceptance:%s\n", issue.AcceptanceCriteria)
fmt.Fprintf(h, "notes:%s\n", issue.Notes)
if issue.ExternalRef != nil {
h.Write([]byte(*issue.ExternalRef))
fmt.Fprintf(h, "external_ref:%s\n", *issue.ExternalRef)
}
return fmt.Sprintf("%x", h.Sum(nil))
}
// ApplyCollisionResolution applies the modifications detected during collision detection.
// This function handles:
// 1. Rename deletions (delete old IDs for renamed issues)
// 2. Creating remapped issues (based on mapping)
// 3. Updating all references to use new IDs
//
// This is the write-phase counterpart to the read-only DetectCollisions.
func ApplyCollisionResolution(ctx context.Context, s *SQLiteStorage, result *CollisionResult, mapping map[string]string) error {
// Phase 1: Handle renames (delete old IDs)
for _, rename := range result.Renames {
if err := s.DeleteIssue(ctx, rename.OldID); err != nil {
return fmt.Errorf("failed to delete renamed issue %s (renamed to %s): %w",
rename.OldID, rename.NewID, err)
}
}
// Phase 2: Update references using the mapping
if len(mapping) > 0 {
if err := updateReferences(ctx, s, mapping); err != nil {
return fmt.Errorf("failed to update references: %w", err)
}
}
return nil
}
// ScoreCollisions determines which version of each colliding issue to keep vs. remap.
// Uses deterministic content-based hashing to ensure all clones make the same decision.
//
// Decision process:
// 1. Hash both versions (existing and incoming) based on content
// 2. Keep the version with the lexicographically LOWER hash
// 3. Mark the other version for remapping
//
// This ensures:
// - Deterministic: same collision always produces same result
// - Symmetric: works regardless of which clone syncs first
// - Idempotent: converges to same state across all clones
func ScoreCollisions(ctx context.Context, s *SQLiteStorage, collisions []*CollisionDetail, allIssues []*types.Issue) error {
// Determine which version to keep for each collision
for _, collision := range collisions {
existingHash := hashIssueContent(collision.ExistingIssue)
incomingHash := hashIssueContent(collision.IncomingIssue)
// Keep the version with lower hash (deterministic winner)
// If incoming has lower hash, we need to remap existing and keep incoming
// If existing has lower hash, we need to remap incoming and keep existing
collision.RemapIncoming = existingHash < incomingHash
}
return nil
}
// deduplicateIncomingIssues removes content-duplicate issues within the incoming batch
// Returns deduplicated slice, keeping the first issue ID (lexicographically) for each unique content
func deduplicateIncomingIssues(issues []*types.Issue) []*types.Issue {
// Group issues by content hash (ignoring ID and timestamps)
type contentKey struct {
title string
description string
design string
acceptanceCriteria string
notes string
status string
priority int
issueType string
assignee string
}
seen := make(map[contentKey]*types.Issue)
result := make([]*types.Issue, 0, len(issues))
for _, issue := range issues {
key := contentKey{
title: issue.Title,
description: issue.Description,
design: issue.Design,
acceptanceCriteria: issue.AcceptanceCriteria,
notes: issue.Notes,
status: string(issue.Status),
priority: issue.Priority,
issueType: string(issue.IssueType),
assignee: issue.Assignee,
}
if existing, found := seen[key]; found {
// Duplicate found - keep the one with lexicographically smaller ID
if issue.ID < existing.ID {
// Replace existing with this one (smaller ID)
for i, r := range result {
if r.ID == existing.ID {
result[i] = issue
break
}
}
seen[key] = issue
}
// Otherwise skip this duplicate
} else {
// First time seeing this content
seen[key] = issue
result = append(result, issue)
}
}
return result
}
// RemapCollisions handles ID remapping for colliding issues based on content hash.
// For each collision, either the incoming or existing issue is remapped (determined by ScoreCollisions).
// Returns a map of old ID -> new ID for reporting.
//
// Process:
// 1. If RemapIncoming=true: remap incoming issue, keep existing
// 2. If RemapIncoming=false: remap existing issue, replace with incoming
//
// This ensures deterministic, symmetric collision resolution across all clones.
//
// The function automatically retries up to 3 times on UNIQUE constraint failures,
// syncing counters between retries to handle concurrent ID allocation.
func RemapCollisions(ctx context.Context, s *SQLiteStorage, collisions []*CollisionDetail, incomingIssues []*types.Issue) (map[string]string, error) {
const maxRetries = 3
var lastErr error
for attempt := 0; attempt < maxRetries; attempt++ {
idMapping, err := remapCollisionsOnce(ctx, s, collisions, incomingIssues)
if err == nil {
return idMapping, nil
}
lastErr = err
if !isUniqueConstraintError(err) {
return nil, err
}
// REMOVED (bd-c7af): Counter sync on retry - no longer needed with hash IDs
}
return nil, fmt.Errorf("failed after %d retries due to UNIQUE constraint violations: %w", maxRetries, lastErr)
}
// remapCollisionsOnce performs a single attempt at collision resolution.
// This is the actual implementation that RemapCollisions wraps with retry logic.
// REMOVED (bd-8e05): With hash-based IDs, collision remapping is no longer needed.
func remapCollisionsOnce(ctx context.Context, s *SQLiteStorage, collisions []*CollisionDetail, _ []*types.Issue) (map[string]string, error) {
// With hash-based IDs, collisions should not occur. If they do, it's a bug.
if len(collisions) > 0 {
return nil, fmt.Errorf("collision remapping no longer supported with hash IDs - %d collisions detected", len(collisions))
}
return nil, nil
}
// OLD IMPLEMENTATION REMOVED (bd-8e05) - retained for reference during migration
// The original 250+ line function implemented sequential ID-based collision remapping
// which is obsolete with hash-based IDs
// Stub out the old implementation to avoid compile errors
// The actual 250+ line implementation has been removed (bd-8e05)
func _OLD_remapCollisionsOnce_REMOVED(ctx context.Context, s *SQLiteStorage, collisions []*CollisionDetail, _ []*types.Issue) (map[string]string, error) {
// Original implementation removed - see git history before bd-8e05
return nil, nil
}
/* OLD CODE REMOVED (bd-8e05) - kept for git history reference
if collision.RemapIncoming {
// Incoming has higher hash -> remap incoming, keep existing
// Record mapping
idMapping[oldID] = newID
// Update incoming issue ID
collision.IncomingIssue.ID = newID
// Create incoming issue with new ID
if err := s.CreateIssue(ctx, collision.IncomingIssue, "import-remap"); err != nil {
return nil, fmt.Errorf("failed to create remapped incoming issue %s -> %s: %w", oldID, newID, err)
}
} else {
// Existing has higher hash -> remap existing, replace with incoming
// Record mapping FIRST before any operations
idMapping[oldID] = newID
// Create a copy of existing issue with new ID
existingCopy := *collision.ExistingIssue
existingCopy.ID = newID
if err := s.CreateIssue(ctx, &existingCopy, "import-remap"); err != nil {
return nil, fmt.Errorf("failed to create remapped existing issue %s -> %s: %w", oldID, newID, err)
}
// Create incoming issue with original ID (this will REPLACE when we delete old ID)
// We do this BEFORE deleting so both issues exist temporarily
// Note: This will fail if incoming ID already exists, which is expected in this flow
// So we skip this step and do it after deletion
// Note: We do NOT copy dependencies here - DeleteIssue will cascade delete them
// But we've already recorded the mapping, so updateReferences will fix everything
// after all collisions are processed
// Delete the existing issue with old ID (this will cascade delete old dependencies)
if err := s.DeleteIssue(ctx, oldID); err != nil {
return nil, fmt.Errorf("failed to delete old existing issue %s: %w", oldID, err)
}
// NOW create incoming issue with original ID (replaces the deleted one)
if err := s.CreateIssue(ctx, collision.IncomingIssue, "import-replace"); err != nil {
return nil, fmt.Errorf("failed to create incoming issue %s: %w", oldID, err)
}
}
}
// Step 3: Recreate dependencies with updated IDs
// For each dependency that involved a remapped issue, recreate it with new IDs
for issueID, deps := range allDepsBeforeRemap {
for _, dep := range deps {
// Determine new IDs (use mapping if available, otherwise keep original)
newIssueID := issueID
if mappedID, ok := idMapping[issueID]; ok {
newIssueID = mappedID
}
newDependsOnID := dep.DependsOnID
if mappedID, ok := idMapping[dep.DependsOnID]; ok {
newDependsOnID = mappedID
}
// Only recreate if at least one ID was remapped
if newIssueID != issueID || newDependsOnID != dep.DependsOnID {
// Check if both issues still exist (the source might have been replaced)
sourceExists, err := s.GetIssue(ctx, newIssueID)
if err != nil || sourceExists == nil {
continue // Skip if source was deleted/replaced
}
targetExists, err := s.GetIssue(ctx, newDependsOnID)
if err != nil || targetExists == nil {
continue // Skip if target doesn't exist
}
// Create the dependency with new IDs
newDep := &types.Dependency{
IssueID: newIssueID,
DependsOnID: newDependsOnID,
Type: dep.Type,
}
if err := s.addDependencyUnchecked(ctx, newDep, "import-remap"); err != nil {
// Ignore duplicate dependency errors
continue
}
}
}
}
// Step 4: Update all text field references
if err := updateReferences(ctx, s, idMapping); err != nil {
return nil, fmt.Errorf("failed to update references: %w", err)
}
return idMapping, nil
}
END OF REMOVED CODE */
// updateReferences updates all text field references and dependency records
// to point to new IDs based on the idMapping
func updateReferences(ctx context.Context, s *SQLiteStorage, idMapping map[string]string) error {
// Pre-compile all regexes once for the entire operation
// This avoids recompiling the same patterns for each text field
cache, err := BuildReplacementCache(idMapping)
if err != nil {
return fmt.Errorf("failed to build replacement cache: %w", err)
}
// Update text fields in all issues (both DB and incoming)
// We need to update issues in the database
dbIssues, err := s.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
return fmt.Errorf("failed to get all issues from DB: %w", err)
}
for _, issue := range dbIssues {
updates := make(map[string]interface{})
// Update description using cached regexes
newDesc := ReplaceIDReferencesWithCache(issue.Description, cache)
if newDesc != issue.Description {
updates["description"] = newDesc
}
// Update design using cached regexes
newDesign := ReplaceIDReferencesWithCache(issue.Design, cache)
if newDesign != issue.Design {
updates["design"] = newDesign
}
// Update notes using cached regexes
newNotes := ReplaceIDReferencesWithCache(issue.Notes, cache)
if newNotes != issue.Notes {
updates["notes"] = newNotes
}
// Update acceptance criteria using cached regexes
newAC := ReplaceIDReferencesWithCache(issue.AcceptanceCriteria, cache)
if newAC != issue.AcceptanceCriteria {
updates["acceptance_criteria"] = newAC
}
// If there are updates, apply them
if len(updates) > 0 {
if err := s.UpdateIssue(ctx, issue.ID, updates, "import-remap"); err != nil {
return fmt.Errorf("failed to update references in issue %s: %w", issue.ID, err)
}
}
}
// Update dependency records
if err := updateDependencyReferences(ctx, s, idMapping); err != nil {
return fmt.Errorf("failed to update dependency references: %w", err)
}
return nil
}
// idReplacementCache stores pre-compiled regexes for ID replacements
// This avoids recompiling the same regex patterns for each text field
type idReplacementCache struct {
oldID string
newID string
placeholder string
regex *regexp.Regexp
}
// BuildReplacementCache pre-compiles all regex patterns for an ID mapping
// This cache should be created once per ID mapping and reused for all text replacements
func BuildReplacementCache(idMapping map[string]string) ([]*idReplacementCache, error) {
cache := make([]*idReplacementCache, 0, len(idMapping))
i := 0
for oldID, newID := range idMapping {
// Use word boundary regex for exact matching
pattern := fmt.Sprintf(`\b%s\b`, regexp.QuoteMeta(oldID))
re, err := regexp.Compile(pattern)
if err != nil {
return nil, fmt.Errorf("failed to compile regex for %s: %w", oldID, err)
}
cache = append(cache, &idReplacementCache{
oldID: oldID,
newID: newID,
placeholder: fmt.Sprintf("\x00REMAP\x00_%d_\x00", i),
regex: re,
})
i++
}
return cache, nil
}
// ReplaceIDReferencesWithCache replaces all occurrences of old IDs with new IDs using a pre-compiled cache
// Uses a two-phase approach to avoid replacement conflicts: first replace with placeholders, then replace with new IDs
func ReplaceIDReferencesWithCache(text string, cache []*idReplacementCache) string {
if len(cache) == 0 || text == "" {
return text
}
// Phase 1: Replace all old IDs with unique placeholders
result := text
for _, entry := range cache {
result = entry.regex.ReplaceAllString(result, entry.placeholder)
}
// Phase 2: Replace all placeholders with new IDs
for _, entry := range cache {
result = strings.ReplaceAll(result, entry.placeholder, entry.newID)
}
return result
}
// replaceIDReferences replaces all occurrences of old IDs with new IDs in text
// Uses word-boundary regex to ensure exact matches (bd-10 but not bd-100)
// Uses a two-phase approach to avoid replacement conflicts: first replace with
// placeholders, then replace placeholders with new IDs
//
// Note: This function compiles regexes on every call. For better performance when
// processing multiple text fields with the same ID mapping, use BuildReplacementCache()
// and ReplaceIDReferencesWithCache() instead.
func replaceIDReferences(text string, idMapping map[string]string) string {
// Build cache (compiles regexes)
cache, err := BuildReplacementCache(idMapping)
if err != nil {
// Fallback to no replacement if regex compilation fails
return text
}
return ReplaceIDReferencesWithCache(text, cache)
}
// updateDependencyReferences updates dependency records to use new IDs
// This handles both IssueID and DependsOnID fields
// IMPORTANT: Only updates dependencies belonging to REMAPPED issues (with new IDs from idMapping).
// Dependencies belonging to existing issues are left untouched.
//
// NOTE: During normal import flow, this is effectively a no-op because imported dependencies
// haven't been added to the database yet when RemapCollisions runs. Dependencies are imported
// later in Phase 5 of import_shared.go. However, this function still serves as a safety guard
// and handles edge cases where dependencies might exist with the new remapped IDs.
func updateDependencyReferences(ctx context.Context, s *SQLiteStorage, idMapping map[string]string) error {
// Build set of NEW remapped IDs (idMapping values)
// Only dependencies with these IDs as IssueID should be updated
newRemappedIDs := make(map[string]bool)
for _, newID := range idMapping {
newRemappedIDs[newID] = true
}
// Get all dependency records
allDeps, err := s.GetAllDependencyRecords(ctx)
if err != nil {
return fmt.Errorf("failed to get all dependencies: %w", err)
}
// Phase 1: Collect all changes to avoid race conditions while iterating
type depUpdate struct {
oldIssueID string
oldDependsOnID string
newDep *types.Dependency
}
var updates []depUpdate
for _, deps := range allDeps {
for _, dep := range deps {
// CRITICAL FIX: Only update dependencies that belong to REMAPPED issues
// A dependency belongs to a remapped issue if its IssueID is a NEW remapped ID
// (one of the VALUES in idMapping, not the keys)
//
// We must NOT check against idMapping keys (old IDs) because those are the same
// as existing issue IDs in the database, and we'd incorrectly modify their dependencies.
if !newRemappedIDs[dep.IssueID] {
// This dependency does not belong to a remapped issue - skip it
continue
}
needsUpdate := false
newIssueID := dep.IssueID
newDependsOnID := dep.DependsOnID
// Check if either ID was remapped
if mappedID, ok := idMapping[dep.IssueID]; ok {
newIssueID = mappedID
needsUpdate = true
}
if mappedID, ok := idMapping[dep.DependsOnID]; ok {
newDependsOnID = mappedID
needsUpdate = true
}
if needsUpdate {
updates = append(updates, depUpdate{
oldIssueID: dep.IssueID,
oldDependsOnID: dep.DependsOnID,
newDep: &types.Dependency{
IssueID: newIssueID,
DependsOnID: newDependsOnID,
Type: dep.Type,
},
})
}
}
}
// Phase 2: Apply all collected changes
for _, update := range updates {
// Remove old dependency - use RemoveDependencyIfExists which doesn't error on missing deps
if err := s.removeDependencyIfExists(ctx, update.oldIssueID, update.oldDependsOnID, "import-remap"); err != nil {
return fmt.Errorf("failed to remove old dependency %s -> %s: %w",
update.oldIssueID, update.oldDependsOnID, err)
}
// Add new dependency with updated IDs
// Use addDependencyUnchecked to skip semantic validation (like parent-child direction)
// since we're just remapping existing dependencies that were already validated
if err := s.addDependencyUnchecked(ctx, update.newDep, "import-remap"); err != nil {
return fmt.Errorf("failed to add updated dependency %s -> %s: %w",
update.newDep.IssueID, update.newDep.DependsOnID, err)
}
}
return nil
}

88
internal/storage/sqlite/collision_dedup_test.go
View File

@@ -1,88 +0,0 @@
package sqlite
import (
"testing"
"github.com/steveyegge/beads/internal/types"
)
// TestDeduplicateIncomingIssues tests that duplicate issues within the incoming batch are consolidated
func TestDeduplicateIncomingIssues(t *testing.T) {
tests := []struct {
name string
incoming []*types.Issue
want int // expected number of issues after deduplication
wantIDs []string
}{
{
name: "no duplicates",
incoming: []*types.Issue{
{ID: "bd-1", Title: "Issue 1", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask},
{ID: "bd-2", Title: "Issue 2", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask},
},
want: 2,
wantIDs: []string{"bd-1", "bd-2"},
},
{
name: "exact content duplicates - keep smallest ID",
incoming: []*types.Issue{
{ID: "bd-226", Title: "Epic: Fix status/closed_at inconsistency", Description: "Implement hybrid solution", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeEpic},
{ID: "bd-367", Title: "Epic: Fix status/closed_at inconsistency", Description: "Implement hybrid solution", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeEpic},
{ID: "bd-396", Title: "Epic: Fix status/closed_at inconsistency", Description: "Implement hybrid solution", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeEpic},
},
want: 1,
wantIDs: []string{"bd-226"}, // Keep smallest ID
},
{
name: "partial duplicates - keep unique ones",
incoming: []*types.Issue{
{ID: "bd-1", Title: "Task A", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask},
{ID: "bd-2", Title: "Task A", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask}, // Dup of bd-1
{ID: "bd-3", Title: "Task B", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask}, // Unique
{ID: "bd-4", Title: "Task B", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask}, // Dup of bd-3
},
want: 2,
wantIDs: []string{"bd-1", "bd-3"},
},
{
name: "duplicates with different timestamps - timestamps ignored",
incoming: []*types.Issue{
{ID: "bd-100", Title: "Task", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask},
{ID: "bd-101", Title: "Task", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask},
},
want: 1,
wantIDs: []string{"bd-100"}, // Keep smallest ID
},
{
name: "different priority - not duplicates",
incoming: []*types.Issue{
{ID: "bd-1", Title: "Task", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask},
{ID: "bd-2", Title: "Task", Status: types.StatusOpen, Priority: 2, IssueType: types.TypeTask},
},
want: 2,
wantIDs: []string{"bd-1", "bd-2"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := deduplicateIncomingIssues(tt.incoming)
if len(result) != tt.want {
t.Errorf("deduplicateIncomingIssues() returned %d issues, want %d", len(result), tt.want)
}
// Check that the expected IDs are present
resultIDs := make(map[string]bool)
for _, issue := range result {
resultIDs[issue.ID] = true
}
for _, wantID := range tt.wantIDs {
if !resultIDs[wantID] {
t.Errorf("expected ID %s not found in result", wantID)
}
}
})
}
}

90
internal/storage/sqlite/collision_hash_test.go
View File

@@ -1,90 +0,0 @@
package sqlite
import (
"testing"
"github.com/steveyegge/beads/internal/types"
)
func TestHashIssueContent(t *testing.T) {
issue1 := &types.Issue{
Title: "Issue from clone A",
Description: "",
Priority: 1,
IssueType: "task",
Status: "open",
}
issue2 := &types.Issue{
Title: "Issue from clone B",
Description: "",
Priority: 1,
IssueType: "task",
Status: "open",
}
hash1 := hashIssueContent(issue1)
hash2 := hashIssueContent(issue2)
// Hashes should be different
if hash1 == hash2 {
t.Errorf("Expected different hashes, got same: %s", hash1)
}
// Hashes should be deterministic
hash1Again := hashIssueContent(issue1)
if hash1 != hash1Again {
t.Errorf("Hash not deterministic: %s != %s", hash1, hash1Again)
}
t.Logf("Hash A: %s", hash1)
t.Logf("Hash B: %s", hash2)
t.Logf("A < B: %v (B wins if true)", hash1 < hash2)
}
func TestScoreCollisions_Deterministic(t *testing.T) {
existingIssue := &types.Issue{
ID: "test-1",
Title: "Issue from clone B",
Description: "",
Priority: 1,
IssueType: "task",
Status: "open",
}
incomingIssue := &types.Issue{
ID: "test-1",
Title: "Issue from clone A",
Description: "",
Priority: 1,
IssueType: "task",
Status: "open",
}
collision := &CollisionDetail{
ID: "test-1",
ExistingIssue: existingIssue,
IncomingIssue: incomingIssue,
}
// Run scoring
err := ScoreCollisions(nil, nil, []*CollisionDetail{collision}, nil)
if err != nil {
t.Fatalf("ScoreCollisions failed: %v", err)
}
existingHash := hashIssueContent(existingIssue)
incomingHash := hashIssueContent(incomingIssue)
t.Logf("Existing hash (B): %s", existingHash)
t.Logf("Incoming hash (A): %s", incomingHash)
t.Logf("Existing < Incoming: %v", existingHash < incomingHash)
// Clone B has lower hash, so it should win
// This means: RemapIncoming should be TRUE (remap incoming A, keep existing B)
if !collision.RemapIncoming {
t.Errorf("Expected RemapIncoming=true (remap incoming A, keep existing B with lower hash), got false")
} else {
t.Logf("✓ Correct: RemapIncoming=true, will remap incoming 'clone A' and keep existing 'clone B'")
}
}

1146
internal/storage/sqlite/collision_test.go
View File

File diff suppressed because it is too large Load Diff

2
internal/storage/sqlite/compact_test.go
View File

@@ -9,6 +9,8 @@ import (
"github.com/steveyegge/beads/internal/types"
)
const testIssueBD1 = "bd-1"
func TestGetTier1Candidates(t *testing.T) {
store, cleanup := setupTestDB(t)
defer cleanup()

41
internal/storage/sqlite/sqlite.go
View File

@@ -1571,44 +1571,17 @@ func (s *SQLiteStorage) RenameDependencyPrefix(ctx context.Context, oldPrefix, n
return nil
}
// RenameCounterPrefix updates the prefix in the issue_counters table
// RenameCounterPrefix is a no-op with hash-based IDs (bd-8e05)
// Kept for backward compatibility with rename-prefix command
func (s *SQLiteStorage) RenameCounterPrefix(ctx context.Context, oldPrefix, newPrefix string) error {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return fmt.Errorf("failed to begin transaction: %w", err)
}
defer func() { _ = tx.Rollback() }()
var lastID int
err = tx.QueryRowContext(ctx, `SELECT last_id FROM issue_counters WHERE prefix = ?`, oldPrefix).Scan(&lastID)
if err != nil && err != sql.ErrNoRows {
return fmt.Errorf("failed to get old counter: %w", err)
}
_, err = tx.ExecContext(ctx, `DELETE FROM issue_counters WHERE prefix = ?`, oldPrefix)
if err != nil {
return fmt.Errorf("failed to delete old counter: %w", err)
}
_, err = tx.ExecContext(ctx, `
INSERT INTO issue_counters (prefix, last_id)
VALUES (?, ?)
ON CONFLICT(prefix) DO UPDATE SET last_id = MAX(last_id, excluded.last_id)
`, newPrefix, lastID)
if err != nil {
return fmt.Errorf("failed to create new counter: %w", err)
}
return tx.Commit()
// Hash-based IDs don't use counters, so nothing to update
return nil
}
// ResetCounter deletes the counter for a prefix, forcing it to be recalculated from max ID
// This is used by renumber to ensure the counter matches the actual max ID after renumbering
// ResetCounter is a no-op with hash-based IDs (bd-8e05)
// Kept for backward compatibility
func (s *SQLiteStorage) ResetCounter(ctx context.Context, prefix string) error {
_, err := s.db.ExecContext(ctx, `DELETE FROM issue_counters WHERE prefix = ?`, prefix)
if err != nil {
return fmt.Errorf("failed to delete counter: %w", err)
}
// Hash-based IDs don't use counters, so nothing to reset
return nil
}