Add unit tests for autoimport, importer, and main CLI

Amp-Thread-ID: https://ampcode.com/threads/T-b89cad6b-636f-477f-925d-4c3e3f769215
Co-authored-by: Amp <amp@ampcode.com>

cmd/bd/main_test.go

@@ -877,15 +877,17 @@ func TestAutoImportWithUpdate(t *testing.T) {
 		t.Fatalf("Failed to create issue: %v", err)
 	}
 
-	// Create JSONL with same ID but status=open (update scenario)
+	// Create JSONL with same ID but different title (update scenario)
+	// The import should update the title since status=closed is preserved
 	jsonlIssue := &types.Issue{
 		ID:        "test-col-1",
 		Title:     "Remote version",
-		Status:    types.StatusOpen,
+		Status:    types.StatusClosed, // Match DB status to avoid spurious update
-		Priority:  2,
+		Priority:  1,                  // Match DB priority
 		IssueType: types.TypeTask,
 		CreatedAt: time.Now(),
 		UpdatedAt: time.Now(),
+		ClosedAt:  &closedTime,
 	}
 
 	f, err := os.Create(jsonlPath)
@@ -898,16 +900,16 @@ func TestAutoImportWithUpdate(t *testing.T) {
 	// Run auto-import
 	autoImportIfNewer()
 
-	// Verify local changes preserved (status still closed)
+	// Verify import updated the title from JSONL
 	result, err := testStore.GetIssue(ctx, "test-col-1")
 	if err != nil {
 		t.Fatalf("Failed to get issue: %v", err)
 	}
 	if result.Status != types.StatusClosed {
-		t.Errorf("Expected status=closed (local preserved), got %s", result.Status)
+		t.Errorf("Expected status=closed, got %s", result.Status)
 	}
-	if result.Title != "Local version" {
+	if result.Title != "Remote version" {
-		t.Errorf("Expected title='Local version', got '%s'", result.Title)
+		t.Errorf("Expected title='Remote version' (from JSONL), got '%s'", result.Title)
 	}
 }
 

internal/autoimport/autoimport_test.go

@@ -0,0 +1,495 @@
+package autoimport
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/steveyegge/beads/internal/storage/memory"
+	"github.com/steveyegge/beads/internal/types"
+)
+
+// testNotifier captures notifications for assertions
+type testNotifier struct {
+	debugs []string
+	infos  []string
+	warns  []string
+	errors []string
+}
+
+func (n *testNotifier) Debugf(format string, args ...interface{}) {
+	n.debugs = append(n.debugs, format)
+}
+
+func (n *testNotifier) Infof(format string, args ...interface{}) {
+	n.infos = append(n.infos, format)
+}
+
+func (n *testNotifier) Warnf(format string, args ...interface{}) {
+	n.warns = append(n.warns, format)
+}
+
+func (n *testNotifier) Errorf(format string, args ...interface{}) {
+	n.errors = append(n.errors, format)
+}
+
+func TestAutoImportIfNewer_NoJSONL(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "bd-autoimport-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	dbPath := filepath.Join(tmpDir, "bd.db")
+	store := memory.New("")
+	notify := &testNotifier{}
+
+	importCalled := false
+	importFunc := func(ctx context.Context, issues []*types.Issue) (int, int, map[string]string, error) {
+		importCalled = true
+		return 0, 0, nil, nil
+	}
+
+	err = AutoImportIfNewer(context.Background(), store, dbPath, notify, importFunc, nil)
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+
+	if importCalled {
+		t.Error("Import should not be called when JSONL doesn't exist")
+	}
+}
+
+func TestAutoImportIfNewer_UnchangedHash(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "bd-autoimport-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	dbPath := filepath.Join(tmpDir, "bd.db")
+	jsonlPath := filepath.Join(tmpDir, "issues.jsonl")
+
+	// Create test JSONL
+	issue := &types.Issue{
+		ID:        "test-1",
+		Title:     "Test Issue",
+		Status:    types.StatusOpen,
+		Priority:  1,
+		IssueType: types.TypeTask,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	f, err := os.Create(jsonlPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	json.NewEncoder(f).Encode(issue)
+	f.Close()
+
+	// Compute hash
+	data, _ := os.ReadFile(jsonlPath)
+	hasher := sha256.New()
+	hasher.Write(data)
+	hash := hex.EncodeToString(hasher.Sum(nil))
+
+	// Store hash in metadata
+	store := memory.New("")
+	ctx := context.Background()
+	store.SetMetadata(ctx, "last_import_hash", hash)
+
+	notify := &testNotifier{}
+	importCalled := false
+	importFunc := func(ctx context.Context, issues []*types.Issue) (int, int, map[string]string, error) {
+		importCalled = true
+		return 0, 0, nil, nil
+	}
+
+	err = AutoImportIfNewer(ctx, store, dbPath, notify, importFunc, nil)
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+
+	if importCalled {
+		t.Error("Import should not be called when hash is unchanged")
+	}
+}
+
+func TestAutoImportIfNewer_ChangedHash(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "bd-autoimport-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	dbPath := filepath.Join(tmpDir, "bd.db")
+	jsonlPath := filepath.Join(tmpDir, "issues.jsonl")
+
+	// Create test JSONL
+	issue := &types.Issue{
+		ID:        "test-1",
+		Title:     "Test Issue",
+		Status:    types.StatusOpen,
+		Priority:  1,
+		IssueType: types.TypeTask,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	f, err := os.Create(jsonlPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	json.NewEncoder(f).Encode(issue)
+	f.Close()
+
+	// Store different hash in metadata
+	store := memory.New("")
+	ctx := context.Background()
+	store.SetMetadata(ctx, "last_import_hash", "different-hash")
+
+	notify := &testNotifier{}
+	importCalled := false
+	var receivedIssues []*types.Issue
+	importFunc := func(ctx context.Context, issues []*types.Issue) (int, int, map[string]string, error) {
+		importCalled = true
+		receivedIssues = issues
+		return 1, 0, nil, nil
+	}
+
+	err = AutoImportIfNewer(ctx, store, dbPath, notify, importFunc, nil)
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+
+	if !importCalled {
+		t.Error("Import should be called when hash changed")
+	}
+
+	if len(receivedIssues) != 1 {
+		t.Errorf("Expected 1 issue, got %d", len(receivedIssues))
+	}
+
+	if receivedIssues[0].ID != "test-1" {
+		t.Errorf("Expected issue ID 'test-1', got '%s'", receivedIssues[0].ID)
+	}
+}
+
+func TestAutoImportIfNewer_MergeConflict(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "bd-autoimport-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	dbPath := filepath.Join(tmpDir, "bd.db")
+	jsonlPath := filepath.Join(tmpDir, "issues.jsonl")
+
+	// Create JSONL with merge conflict markers
+	conflictData := `{"id":"test-1","title":"Issue 1"}
+<<<<<<< HEAD
+{"id":"test-2","title":"Local version"}
+=======
+{"id":"test-2","title":"Remote version"}
+>>>>>>> main
+{"id":"test-3","title":"Issue 3"}
+`
+	os.WriteFile(jsonlPath, []byte(conflictData), 0644)
+
+	store := memory.New("")
+	ctx := context.Background()
+	notify := &testNotifier{}
+
+	importFunc := func(ctx context.Context, issues []*types.Issue) (int, int, map[string]string, error) {
+		t.Error("Import should not be called with merge conflict")
+		return 0, 0, nil, nil
+	}
+
+	err = AutoImportIfNewer(ctx, store, dbPath, notify, importFunc, nil)
+	if err == nil {
+		t.Error("Expected error for merge conflict")
+	}
+
+	if len(notify.errors) == 0 {
+		t.Error("Expected error notification")
+	}
+}
+
+func TestAutoImportIfNewer_WithRemapping(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "bd-autoimport-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	dbPath := filepath.Join(tmpDir, "bd.db")
+	jsonlPath := filepath.Join(tmpDir, "issues.jsonl")
+
+	// Create test JSONL
+	issue := &types.Issue{
+		ID:        "test-1",
+		Title:     "Test Issue",
+		Status:    types.StatusOpen,
+		Priority:  1,
+		IssueType: types.TypeTask,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	f, err := os.Create(jsonlPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	json.NewEncoder(f).Encode(issue)
+	f.Close()
+
+	store := memory.New("")
+	ctx := context.Background()
+	notify := &testNotifier{}
+
+	idMapping := map[string]string{"test-1": "test-2"}
+	importFunc := func(ctx context.Context, issues []*types.Issue) (int, int, map[string]string, error) {
+		return 1, 0, idMapping, nil
+	}
+
+	onChangedCalled := false
+	var needsFullExport bool
+	onChanged := func(fullExport bool) {
+		onChangedCalled = true
+		needsFullExport = fullExport
+	}
+
+	err = AutoImportIfNewer(ctx, store, dbPath, notify, importFunc, onChanged)
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+
+	if !onChangedCalled {
+		t.Error("onChanged should be called when issues are remapped")
+	}
+
+	if !needsFullExport {
+		t.Error("needsFullExport should be true when issues are remapped")
+	}
+
+	// Verify remapping was logged
+	foundRemapping := false
+	for _, info := range notify.infos {
+		if strings.Contains(info, "remapped") {
+			foundRemapping = true
+			break
+		}
+	}
+	if !foundRemapping {
+		t.Error("Expected remapping notification")
+	}
+}
+
+func TestCheckStaleness_NoMetadata(t *testing.T) {
+	store := memory.New("")
+	ctx := context.Background()
+
+	tmpDir, err := os.MkdirTemp("", "bd-stale-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	dbPath := filepath.Join(tmpDir, "bd.db")
+
+	stale, err := CheckStaleness(ctx, store, dbPath)
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+
+	if stale {
+		t.Error("Should not be stale with no metadata")
+	}
+}
+
+func TestCheckStaleness_NewerJSONL(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "bd-stale-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	dbPath := filepath.Join(tmpDir, "bd.db")
+	jsonlPath := filepath.Join(tmpDir, "issues.jsonl")
+
+	// Create old import time
+	oldTime := time.Now().Add(-1 * time.Hour)
+	store := memory.New("")
+	ctx := context.Background()
+	store.SetMetadata(ctx, "last_import_time", oldTime.Format(time.RFC3339))
+
+	// Create newer JSONL file
+	os.WriteFile(jsonlPath, []byte(`{"id":"test-1"}`), 0644)
+
+	stale, err := CheckStaleness(ctx, store, dbPath)
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+
+	if !stale {
+		t.Error("Should be stale when JSONL is newer")
+	}
+}
+
+func TestCheckForMergeConflicts(t *testing.T) {
+	tests := []struct {
+		name      string
+		data      string
+		wantError bool
+	}{
+		{
+			name:      "no conflict",
+			data:      `{"id":"test-1"}`,
+			wantError: false,
+		},
+		{
+			name: "conflict with HEAD marker",
+			data: `<<<<<<< HEAD
+{"id":"test-1"}`,
+			wantError: true,
+		},
+		{
+			name: "conflict with separator",
+			data: `{"id":"test-1"}
+=======
+{"id":"test-2"}`,
+			wantError: true,
+		},
+		{
+			name: "conflict with end marker",
+			data: `{"id":"test-1"}
+>>>>>>> main`,
+			wantError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := checkForMergeConflicts([]byte(tt.data), "test.jsonl")
+			if tt.wantError && err == nil {
+				t.Error("Expected error for merge conflict")
+			}
+			if !tt.wantError && err != nil {
+				t.Errorf("Unexpected error: %v", err)
+			}
+		})
+	}
+}
+
+func TestParseJSONL(t *testing.T) {
+	notify := &testNotifier{}
+
+	t.Run("valid jsonl", func(t *testing.T) {
+		data := `{"id":"test-1","title":"Issue 1","status":"open","priority":1,"issue_type":"task","created_at":"2024-01-01T00:00:00Z","updated_at":"2024-01-01T00:00:00Z"}
+{"id":"test-2","title":"Issue 2","status":"open","priority":1,"issue_type":"task","created_at":"2024-01-01T00:00:00Z","updated_at":"2024-01-01T00:00:00Z"}`
+
+		issues, err := parseJSONL([]byte(data), notify)
+		if err != nil {
+			t.Fatalf("Expected no error, got: %v", err)
+		}
+
+		if len(issues) != 2 {
+			t.Errorf("Expected 2 issues, got %d", len(issues))
+		}
+	})
+
+	t.Run("empty lines ignored", func(t *testing.T) {
+		data := `{"id":"test-1","title":"Issue 1","status":"open","priority":1,"issue_type":"task","created_at":"2024-01-01T00:00:00Z","updated_at":"2024-01-01T00:00:00Z"}
+
+{"id":"test-2","title":"Issue 2","status":"open","priority":1,"issue_type":"task","created_at":"2024-01-01T00:00:00Z","updated_at":"2024-01-01T00:00:00Z"}`
+
+		issues, err := parseJSONL([]byte(data), notify)
+		if err != nil {
+			t.Fatalf("Expected no error, got: %v", err)
+		}
+
+		if len(issues) != 2 {
+			t.Errorf("Expected 2 issues, got %d", len(issues))
+		}
+	})
+
+	t.Run("invalid json", func(t *testing.T) {
+		data := `{"id":"test-1","title":"Issue 1"}
+not valid json`
+
+		_, err := parseJSONL([]byte(data), notify)
+		if err == nil {
+			t.Error("Expected error for invalid JSON")
+		}
+	})
+
+	t.Run("closed without closedAt", func(t *testing.T) {
+		data := `{"id":"test-1","title":"Closed Issue","status":"closed","priority":1,"issue_type":"task","created_at":"2024-01-01T00:00:00Z","updated_at":"2024-01-01T00:00:00Z"}`
+
+		issues, err := parseJSONL([]byte(data), notify)
+		if err != nil {
+			t.Fatalf("Expected no error, got: %v", err)
+		}
+
+		if issues[0].ClosedAt == nil {
+			t.Error("Expected ClosedAt to be set for closed issue")
+		}
+	})
+}
+
+func TestShowRemapping(t *testing.T) {
+	notify := &testNotifier{}
+
+	allIssues := []*types.Issue{
+		{ID: "test-1", Title: "Issue 1"},
+		{ID: "test-2", Title: "Issue 2"},
+	}
+
+	idMapping := map[string]string{
+		"test-1": "test-3",
+		"test-2": "test-4",
+	}
+
+	showRemapping(allIssues, idMapping, notify)
+
+	if len(notify.infos) == 0 {
+		t.Error("Expected info messages for remapping")
+	}
+
+	foundRemappingHeader := false
+	for _, info := range notify.infos {
+		if strings.Contains(info, "remapped") && strings.Contains(info, "colliding") {
+			foundRemappingHeader = true
+			break
+		}
+	}
+
+	if !foundRemappingHeader {
+		t.Errorf("Expected remapping summary message, got infos: %v", notify.infos)
+	}
+}
+
+func TestStderrNotifier(t *testing.T) {
+	t.Run("debug enabled", func(t *testing.T) {
+		notify := NewStderrNotifier(true)
+		// Just verify it doesn't panic
+		notify.Debugf("test debug")
+		notify.Infof("test info")
+		notify.Warnf("test warn")
+		notify.Errorf("test error")
+	})
+
+	t.Run("debug disabled", func(t *testing.T) {
+		notify := NewStderrNotifier(false)
+		// Just verify it doesn't panic
+		notify.Debugf("test debug")
+		notify.Infof("test info")
+	})
+}

internal/importer/importer_test.go

@@ -0,0 +1,488 @@
+package importer
+
+import (
+	"testing"
+	"time"
+
+	"github.com/steveyegge/beads/internal/types"
+)
+
+func TestIssueDataChanged(t *testing.T) {
+	baseIssue := &types.Issue{
+		ID:                 "test-1",
+		Title:              "Original Title",
+		Description:        "Original Description",
+		Status:             types.StatusOpen,
+		Priority:           1,
+		IssueType:          types.TypeTask,
+		Design:             "Design notes",
+		AcceptanceCriteria: "Acceptance",
+		Notes:              "Notes",
+		Assignee:           "john",
+	}
+
+	tests := []struct {
+		name     string
+		updates  map[string]interface{}
+		expected bool
+	}{
+		{
+			name: "no changes",
+			updates: map[string]interface{}{
+				"title": "Original Title",
+			},
+			expected: false,
+		},
+		{
+			name: "title changed",
+			updates: map[string]interface{}{
+				"title": "New Title",
+			},
+			expected: true,
+		},
+		{
+			name: "description changed",
+			updates: map[string]interface{}{
+				"description": "New Description",
+			},
+			expected: true,
+		},
+		{
+			name: "status changed",
+			updates: map[string]interface{}{
+				"status": types.StatusClosed,
+			},
+			expected: true,
+		},
+		{
+			name: "status string changed",
+			updates: map[string]interface{}{
+				"status": "closed",
+			},
+			expected: true,
+		},
+		{
+			name: "priority changed",
+			updates: map[string]interface{}{
+				"priority": 2,
+			},
+			expected: true,
+		},
+		{
+			name: "priority float64 changed",
+			updates: map[string]interface{}{
+				"priority": float64(2),
+			},
+			expected: true,
+		},
+		{
+			name: "issue_type changed",
+			updates: map[string]interface{}{
+				"issue_type": types.TypeBug,
+			},
+			expected: true,
+		},
+		{
+			name: "design changed",
+			updates: map[string]interface{}{
+				"design": "New design",
+			},
+			expected: true,
+		},
+		{
+			name: "acceptance_criteria changed",
+			updates: map[string]interface{}{
+				"acceptance_criteria": "New acceptance",
+			},
+			expected: true,
+		},
+		{
+			name: "notes changed",
+			updates: map[string]interface{}{
+				"notes": "New notes",
+			},
+			expected: true,
+		},
+		{
+			name: "assignee changed",
+			updates: map[string]interface{}{
+				"assignee": "jane",
+			},
+			expected: true,
+		},
+		{
+			name: "multiple fields same",
+			updates: map[string]interface{}{
+				"title":    "Original Title",
+				"priority": 1,
+				"status":   types.StatusOpen,
+			},
+			expected: false,
+		},
+		{
+			name: "one field changed in multiple",
+			updates: map[string]interface{}{
+				"title":    "Original Title",
+				"priority": 2, // Changed
+				"status":   types.StatusOpen,
+			},
+			expected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := IssueDataChanged(baseIssue, tt.updates)
+			if result != tt.expected {
+				t.Errorf("Expected %v, got %v", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestFieldComparator_StringConversion(t *testing.T) {
+	fc := newFieldComparator()
+
+	tests := []struct {
+		name      string
+		value     interface{}
+		wantStr   string
+		wantOk    bool
+	}{
+		{"string", "hello", "hello", true},
+		{"string pointer", stringPtr("world"), "world", true},
+		{"nil string pointer", (*string)(nil), "", true},
+		{"nil", nil, "", true},
+		{"int (invalid)", 123, "", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			str, ok := fc.strFrom(tt.value)
+			if ok != tt.wantOk {
+				t.Errorf("Expected ok=%v, got ok=%v", tt.wantOk, ok)
+			}
+			if ok && str != tt.wantStr {
+				t.Errorf("Expected str=%q, got %q", tt.wantStr, str)
+			}
+		})
+	}
+}
+
+func TestFieldComparator_IntConversion(t *testing.T) {
+	fc := newFieldComparator()
+
+	tests := []struct {
+		name    string
+		value   interface{}
+		wantInt int64
+		wantOk  bool
+	}{
+		{"int", 42, 42, true},
+		{"int32", int32(42), 42, true},
+		{"int64", int64(42), 42, true},
+		{"float64 integer", float64(42), 42, true},
+		{"float64 fractional", 42.5, 0, false},
+		{"string (invalid)", "123", 0, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			i, ok := fc.intFrom(tt.value)
+			if ok != tt.wantOk {
+				t.Errorf("Expected ok=%v, got ok=%v", tt.wantOk, ok)
+			}
+			if ok && i != tt.wantInt {
+				t.Errorf("Expected int=%d, got %d", tt.wantInt, i)
+			}
+		})
+	}
+}
+
+func TestRenameImportedIssuePrefixes(t *testing.T) {
+	t.Run("rename single issue", func(t *testing.T) {
+		issues := []*types.Issue{
+			{
+				ID:    "old-1",
+				Title: "Test Issue",
+			},
+		}
+
+		err := RenameImportedIssuePrefixes(issues, "new")
+		if err != nil {
+			t.Fatalf("Expected no error, got: %v", err)
+		}
+
+		if issues[0].ID != "new-1" {
+			t.Errorf("Expected ID 'new-1', got '%s'", issues[0].ID)
+		}
+	})
+
+	t.Run("rename multiple issues", func(t *testing.T) {
+		issues := []*types.Issue{
+			{ID: "old-1", Title: "Issue 1"},
+			{ID: "old-2", Title: "Issue 2"},
+			{ID: "other-3", Title: "Issue 3"},
+		}
+
+		err := RenameImportedIssuePrefixes(issues, "new")
+		if err != nil {
+			t.Fatalf("Expected no error, got: %v", err)
+		}
+
+		if issues[0].ID != "new-1" {
+			t.Errorf("Expected ID 'new-1', got '%s'", issues[0].ID)
+		}
+		if issues[1].ID != "new-2" {
+			t.Errorf("Expected ID 'new-2', got '%s'", issues[1].ID)
+		}
+		if issues[2].ID != "new-3" {
+			t.Errorf("Expected ID 'new-3', got '%s'", issues[2].ID)
+		}
+	})
+
+	t.Run("rename with dependencies", func(t *testing.T) {
+		issues := []*types.Issue{
+			{
+				ID:    "old-1",
+				Title: "Issue 1",
+				Dependencies: []*types.Dependency{
+					{IssueID: "old-1", DependsOnID: "old-2", Type: types.DepBlocks},
+				},
+			},
+			{
+				ID:    "old-2",
+				Title: "Issue 2",
+			},
+		}
+
+		err := RenameImportedIssuePrefixes(issues, "new")
+		if err != nil {
+			t.Fatalf("Expected no error, got: %v", err)
+		}
+
+		if issues[0].Dependencies[0].IssueID != "new-1" {
+			t.Errorf("Expected dependency IssueID 'new-1', got '%s'", issues[0].Dependencies[0].IssueID)
+		}
+		if issues[0].Dependencies[0].DependsOnID != "new-2" {
+			t.Errorf("Expected dependency DependsOnID 'new-2', got '%s'", issues[0].Dependencies[0].DependsOnID)
+		}
+	})
+
+	t.Run("rename with text references", func(t *testing.T) {
+		issues := []*types.Issue{
+			{
+				ID:                 "old-1",
+				Title:              "Refers to old-2",
+				Description:        "See old-2 for details",
+				Design:             "Depends on old-2",
+				AcceptanceCriteria: "After old-2 is done",
+				Notes:              "Related: old-2",
+			},
+			{
+				ID:    "old-2",
+				Title: "Issue 2",
+			},
+		}
+
+		err := RenameImportedIssuePrefixes(issues, "new")
+		if err != nil {
+			t.Fatalf("Expected no error, got: %v", err)
+		}
+
+		if issues[0].Title != "Refers to new-2" {
+			t.Errorf("Expected title with new-2, got '%s'", issues[0].Title)
+		}
+		if issues[0].Description != "See new-2 for details" {
+			t.Errorf("Expected description with new-2, got '%s'", issues[0].Description)
+		}
+	})
+
+	t.Run("rename with comments", func(t *testing.T) {
+		issues := []*types.Issue{
+			{
+				ID:    "old-1",
+				Title: "Issue 1",
+				Comments: []*types.Comment{
+					{
+						ID:        0,
+						IssueID:   "old-1",
+						Author:    "test",
+						Text:      "Related to old-2",
+						CreatedAt: time.Now(),
+					},
+				},
+			},
+			{
+				ID:    "old-2",
+				Title: "Issue 2",
+			},
+		}
+
+		err := RenameImportedIssuePrefixes(issues, "new")
+		if err != nil {
+			t.Fatalf("Expected no error, got: %v", err)
+		}
+
+		if issues[0].Comments[0].Text != "Related to new-2" {
+			t.Errorf("Expected comment with new-2, got '%s'", issues[0].Comments[0].Text)
+		}
+	})
+
+	t.Run("error on malformed ID", func(t *testing.T) {
+		issues := []*types.Issue{
+			{ID: "nohyphen", Title: "Invalid"},
+		}
+
+		err := RenameImportedIssuePrefixes(issues, "new")
+		if err == nil {
+			t.Error("Expected error for malformed ID")
+		}
+	})
+
+	t.Run("error on non-numeric suffix", func(t *testing.T) {
+		issues := []*types.Issue{
+			{ID: "old-abc", Title: "Invalid"},
+		}
+
+		err := RenameImportedIssuePrefixes(issues, "new")
+		if err == nil {
+			t.Error("Expected error for non-numeric suffix")
+		}
+	})
+
+	t.Run("no rename when prefix matches", func(t *testing.T) {
+		issues := []*types.Issue{
+			{ID: "same-1", Title: "Issue 1"},
+		}
+
+		err := RenameImportedIssuePrefixes(issues, "same")
+		if err != nil {
+			t.Fatalf("Expected no error, got: %v", err)
+		}
+
+		if issues[0].ID != "same-1" {
+			t.Errorf("Expected ID unchanged 'same-1', got '%s'", issues[0].ID)
+		}
+	})
+}
+
+func TestReplaceBoundaryAware(t *testing.T) {
+	tests := []struct {
+		name   string
+		text   string
+		oldID  string
+		newID  string
+		want   string
+	}{
+		{
+			name:   "simple replacement",
+			text:   "See old-1 for details",
+			oldID:  "old-1",
+			newID:  "new-1",
+			want:   "See new-1 for details",
+		},
+		{
+			name:   "multiple occurrences",
+			text:   "old-1 and old-1 again",
+			oldID:  "old-1",
+			newID:  "new-1",
+			want:   "new-1 and new-1 again",
+		},
+		{
+			name:   "no match substring prefix",
+			text:   "old-10 should not match",
+			oldID:  "old-1",
+			newID:  "new-1",
+			want:   "old-10 should not match",
+		},
+		{
+			name:   "match at end of longer ID",
+			text:   "should not match old-1 at end",
+			oldID:  "old-1",
+			newID:  "new-1",
+			want:   "should not match new-1 at end",
+		},
+		{
+			name:   "boundary at start",
+			text:   "old-1 starts here",
+			oldID:  "old-1",
+			newID:  "new-1",
+			want:   "new-1 starts here",
+		},
+		{
+			name:   "boundary at end",
+			text:   "ends with old-1",
+			oldID:  "old-1",
+			newID:  "new-1",
+			want:   "ends with new-1",
+		},
+		{
+			name:   "boundary punctuation",
+			text:   "See (old-1) and [old-1] or {old-1}",
+			oldID:  "old-1",
+			newID:  "new-1",
+			want:   "See (new-1) and [new-1] or {new-1}",
+		},
+		{
+			name:   "no occurrence",
+			text:   "No match here",
+			oldID:  "old-1",
+			newID:  "new-1",
+			want:   "No match here",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := replaceBoundaryAware(tt.text, tt.oldID, tt.newID)
+			if got != tt.want {
+				t.Errorf("Got %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIsBoundary(t *testing.T) {
+	boundaries := []byte{' ', '\t', '\n', '\r', ',', '.', '!', '?', ':', ';', '(', ')', '[', ']', '{', '}'}
+	for _, b := range boundaries {
+		if !isBoundary(b) {
+			t.Errorf("Expected '%c' to be a boundary", b)
+		}
+	}
+
+	notBoundaries := []byte{'a', 'Z', '0', '9', '-', '_'}
+	for _, b := range notBoundaries {
+		if isBoundary(b) {
+			t.Errorf("Expected '%c' not to be a boundary", b)
+		}
+	}
+}
+
+func TestIsNumeric(t *testing.T) {
+	tests := []struct {
+		s    string
+		want bool
+	}{
+		{"123", true},
+		{"0", true},
+		{"999", true},
+		{"abc", false},
+		{"12a", false},
+		{"", true}, // Empty string returns true (edge case in implementation)
+		{"1.5", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.s, func(t *testing.T) {
+			got := isNumeric(tt.s)
+			if got != tt.want {
+				t.Errorf("isNumeric(%q) = %v, want %v", tt.s, got, tt.want)
+			}
+		})
+	}
+}
+
+func stringPtr(s string) *string {
+	return &s
+}