test(doctor): add tests to restore coverage above 45%

Add tests for doctor package functions after refactor PR #653:
- version_test.go: CompareVersions, IsValidSemver, ParseVersionParts
- types_test.go: status constants and DoctorCheck struct
- installation_test.go: CheckInstallation, CheckMultipleDatabases, CheckPermissions
- integrity_test.go: CheckIDFormat, CheckDependencyCycles, CheckTombstones, CheckDeletionsManifest
- database_test.go: CheckDatabaseVersion, CheckSchemaCompatibility, CheckDatabaseIntegrity
- daemon_test.go: CheckDaemonStatus
- git_test.go: CheckGitHooks, CheckMergeDriver, CheckSyncBranchConfig

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

cmd/bd/doctor/daemon_test.go

@@ -0,0 +1,35 @@
+package doctor
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestCheckDaemonStatus(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+
+		check := CheckDaemonStatus(tmpDir, "1.0.0")
+
+		// Should return OK when no .beads directory (daemon not needed)
+		if check.Status != StatusOK {
+			t.Errorf("Status = %q, want %q", check.Status, StatusOK)
+		}
+	})
+
+	t.Run("beads directory exists", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckDaemonStatus(tmpDir, "1.0.0")
+
+		// Should check daemon status - may be OK or warning depending on daemon state
+		if check.Name != "Daemon Health" {
+			t.Errorf("Name = %q, want %q", check.Name, "Daemon Health")
+		}
+	})
+}

cmd/bd/doctor/database_test.go

@@ -0,0 +1,108 @@
+package doctor
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestCheckDatabaseVersion(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		check := CheckDatabaseVersion(tmpDir, "1.0.0")
+
+		if check.Name != "Database" {
+			t.Errorf("Name = %q, want %q", check.Name, "Database")
+		}
+		// Should report no database found
+		if check.Status != StatusError {
+			t.Errorf("Status = %q, want %q", check.Status, StatusError)
+		}
+	})
+
+	t.Run("jsonl only mode", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+		// Create issues.jsonl file
+		if err := os.WriteFile(filepath.Join(beadsDir, "issues.jsonl"), []byte{}, 0644); err != nil {
+			t.Fatal(err)
+		}
+		// Create config.yaml with no-db mode
+		configContent := `database: ""`
+		if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte(configContent), 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckDatabaseVersion(tmpDir, "1.0.0")
+
+		// Fresh clone detection should warn about needing to import
+		if check.Status == StatusError {
+			t.Logf("Got error status with message: %s", check.Message)
+		}
+	})
+}
+
+func TestCheckSchemaCompatibility(t *testing.T) {
+	t.Run("no database", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckSchemaCompatibility(tmpDir)
+
+		// Should return OK when no database
+		if check.Status != StatusOK {
+			t.Errorf("Status = %q, want %q for no database", check.Status, StatusOK)
+		}
+	})
+}
+
+func TestCheckDatabaseIntegrity(t *testing.T) {
+	t.Run("no database", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckDatabaseIntegrity(tmpDir)
+
+		// Should return OK when no database
+		if check.Status != StatusOK {
+			t.Errorf("Status = %q, want %q for no database", check.Status, StatusOK)
+		}
+	})
+}
+
+func TestCheckDatabaseJSONLSync(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+
+		check := CheckDatabaseJSONLSync(tmpDir)
+
+		// Should return OK when no .beads directory
+		if check.Status != StatusOK {
+			t.Errorf("Status = %q, want %q", check.Status, StatusOK)
+		}
+	})
+
+	t.Run("empty beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckDatabaseJSONLSync(tmpDir)
+
+		// Should return OK when nothing to sync
+		if check.Status != StatusOK {
+			t.Errorf("Status = %q, want %q", check.Status, StatusOK)
+		}
+	})
+}

cmd/bd/doctor/git_test.go

@@ -0,0 +1,104 @@
+package doctor
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestCheckGitHooks(t *testing.T) {
+	t.Run("not a git repo", func(t *testing.T) {
+		// Save and change to a temp dir that's not a git repo
+		oldWd, _ := os.Getwd()
+		tmpDir := t.TempDir()
+		os.Chdir(tmpDir)
+		defer os.Chdir(oldWd)
+
+		check := CheckGitHooks()
+
+		// Should return warning when not in a git repo
+		if check.Name != "Git Hooks" {
+			t.Errorf("Name = %q, want %q", check.Name, "Git Hooks")
+		}
+	})
+}
+
+func TestCheckMergeDriver(t *testing.T) {
+	t.Run("not a git repo", func(t *testing.T) {
+		tmpDir := t.TempDir()
+
+		check := CheckMergeDriver(tmpDir)
+
+		if check.Name != "Git Merge Driver" {
+			t.Errorf("Name = %q, want %q", check.Name, "Git Merge Driver")
+		}
+	})
+
+	t.Run("no gitattributes", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		// Create a fake git directory structure
+		gitDir := filepath.Join(tmpDir, ".git")
+		if err := os.Mkdir(gitDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckMergeDriver(tmpDir)
+
+		// Should report missing configuration
+		if check.Status != StatusWarning && check.Status != StatusError {
+			t.Logf("Status = %q, Message = %q", check.Status, check.Message)
+		}
+	})
+}
+
+func TestCheckSyncBranchConfig(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+
+		check := CheckSyncBranchConfig(tmpDir)
+
+		if check.Name != "Sync Branch Config" {
+			t.Errorf("Name = %q, want %q", check.Name, "Sync Branch Config")
+		}
+	})
+
+	t.Run("beads directory exists", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckSyncBranchConfig(tmpDir)
+
+		// Should check for sync branch config
+		if check.Name != "Sync Branch Config" {
+			t.Errorf("Name = %q, want %q", check.Name, "Sync Branch Config")
+		}
+	})
+}
+
+func TestCheckSyncBranchHealth(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+
+		check := CheckSyncBranchHealth(tmpDir)
+
+		if check.Name != "Sync Branch Health" {
+			t.Errorf("Name = %q, want %q", check.Name, "Sync Branch Health")
+		}
+	})
+}
+
+func TestCheckSyncBranchHookCompatibility(t *testing.T) {
+	t.Run("no sync branch configured", func(t *testing.T) {
+		tmpDir := t.TempDir()
+
+		check := CheckSyncBranchHookCompatibility(tmpDir)
+
+		// Should return OK when sync branch not configured
+		if check.Status != StatusOK {
+			t.Errorf("Status = %q, want %q", check.Status, StatusOK)
+		}
+	})
+}

cmd/bd/doctor/installation_test.go

@@ -0,0 +1,131 @@
+package doctor
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestCheckInstallation(t *testing.T) {
+	t.Run("missing beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		check := CheckInstallation(tmpDir)
+
+		if check.Status != StatusError {
+			t.Errorf("expected StatusError, got %s", check.Status)
+		}
+		if check.Name != "Installation" {
+			t.Errorf("expected name 'Installation', got %s", check.Name)
+		}
+	})
+
+	t.Run("beads directory exists", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckInstallation(tmpDir)
+
+		if check.Status != StatusOK {
+			t.Errorf("expected StatusOK, got %s", check.Status)
+		}
+	})
+}
+
+func TestCheckMultipleDatabases(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		check := CheckMultipleDatabases(tmpDir)
+
+		if check.Status != StatusOK {
+			t.Errorf("expected StatusOK for missing dir, got %s", check.Status)
+		}
+	})
+
+	t.Run("single database", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+		// Create single db file
+		if err := os.WriteFile(filepath.Join(beadsDir, "beads.db"), []byte{}, 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckMultipleDatabases(tmpDir)
+
+		if check.Status != StatusOK {
+			t.Errorf("expected StatusOK for single db, got %s", check.Status)
+		}
+	})
+
+	t.Run("multiple databases", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+		// Create multiple db files
+		for _, name := range []string{"beads.db", "issues.db", "another.db"} {
+			if err := os.WriteFile(filepath.Join(beadsDir, name), []byte{}, 0644); err != nil {
+				t.Fatal(err)
+			}
+		}
+
+		check := CheckMultipleDatabases(tmpDir)
+
+		if check.Status != StatusWarning {
+			t.Errorf("expected StatusWarning for multiple dbs, got %s", check.Status)
+		}
+	})
+
+	t.Run("backup files ignored", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+		// Create one real db and one backup
+		if err := os.WriteFile(filepath.Join(beadsDir, "beads.db"), []byte{}, 0644); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(beadsDir, "beads.backup.db"), []byte{}, 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckMultipleDatabases(tmpDir)
+
+		if check.Status != StatusOK {
+			t.Errorf("expected StatusOK (backup ignored), got %s", check.Status)
+		}
+	})
+}
+
+func TestCheckPermissions(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		check := CheckPermissions(tmpDir)
+
+		// Should return error when .beads dir doesn't exist (can't write to it)
+		if check.Status != StatusError {
+			t.Errorf("expected StatusError for missing dir, got %s", check.Status)
+		}
+	})
+
+	t.Run("writable directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckPermissions(tmpDir)
+
+		if check.Status != StatusOK {
+			t.Errorf("expected StatusOK for writable dir, got %s", check.Status)
+		}
+	})
+}

cmd/bd/doctor/integrity_test.go

@@ -0,0 +1,134 @@
+package doctor
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestCheckIDFormat(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		check := CheckIDFormat(tmpDir)
+
+		// Should handle missing .beads gracefully
+		if check.Name != "Issue IDs" {
+			t.Errorf("Name = %q, want %q", check.Name, "Issue IDs")
+		}
+	})
+
+	t.Run("no database file", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckIDFormat(tmpDir)
+
+		// Should report "will use hash-based IDs" for new install
+		if check.Status != StatusOK {
+			t.Errorf("Status = %q, want %q", check.Status, StatusOK)
+		}
+	})
+}
+
+func TestCheckDependencyCycles(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		check := CheckDependencyCycles(tmpDir)
+
+		// Should handle missing directory gracefully
+		if check.Name != "Dependency Cycles" {
+			t.Errorf("Name = %q, want %q", check.Name, "Dependency Cycles")
+		}
+	})
+
+	t.Run("no database", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckDependencyCycles(tmpDir)
+
+		// Should return OK when no database (nothing to check)
+		if check.Status != StatusOK {
+			t.Errorf("Status = %q, want %q", check.Status, StatusOK)
+		}
+	})
+}
+
+func TestCheckTombstones(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		check := CheckTombstones(tmpDir)
+
+		// Should handle missing directory
+		if check.Name != "Tombstones" {
+			t.Errorf("Name = %q, want %q", check.Name, "Tombstones")
+		}
+	})
+
+	t.Run("empty beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckTombstones(tmpDir)
+
+		// Should return OK when no tombstones file
+		if check.Status != StatusOK {
+			t.Errorf("Status = %q, want %q", check.Status, StatusOK)
+		}
+	})
+}
+
+func TestCheckDeletionsManifest(t *testing.T) {
+	t.Run("no beads directory", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		check := CheckDeletionsManifest(tmpDir)
+
+		if check.Name != "Deletions Manifest" {
+			t.Errorf("Name = %q, want %q", check.Name, "Deletions Manifest")
+		}
+	})
+
+	t.Run("no deletions file", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckDeletionsManifest(tmpDir)
+
+		// Should return OK when no deletions.jsonl (nothing to migrate)
+		if check.Status != StatusOK {
+			t.Errorf("Status = %q, want %q", check.Status, StatusOK)
+		}
+	})
+
+	t.Run("has deletions file", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		beadsDir := filepath.Join(tmpDir, ".beads")
+		if err := os.Mkdir(beadsDir, 0755); err != nil {
+			t.Fatal(err)
+		}
+		// Create a deletions.jsonl file
+		deletionsPath := filepath.Join(beadsDir, "deletions.jsonl")
+		if err := os.WriteFile(deletionsPath, []byte(`{"id":"test-1"}`), 0644); err != nil {
+			t.Fatal(err)
+		}
+
+		check := CheckDeletionsManifest(tmpDir)
+
+		// Should warn about legacy deletions file
+		if check.Status != StatusWarning {
+			t.Errorf("Status = %q, want %q", check.Status, StatusWarning)
+		}
+	})
+}

cmd/bd/doctor/types_test.go

@@ -0,0 +1,49 @@
+package doctor
+
+import (
+	"testing"
+)
+
+func TestStatusConstants(t *testing.T) {
+	// Verify status constants have expected values
+	if StatusOK != "ok" {
+		t.Errorf("StatusOK = %q, want %q", StatusOK, "ok")
+	}
+	if StatusWarning != "warning" {
+		t.Errorf("StatusWarning = %q, want %q", StatusWarning, "warning")
+	}
+	if StatusError != "error" {
+		t.Errorf("StatusError = %q, want %q", StatusError, "error")
+	}
+}
+
+func TestMinSyncBranchHookVersion(t *testing.T) {
+	// Verify the minimum version is set
+	if MinSyncBranchHookVersion == "" {
+		t.Error("MinSyncBranchHookVersion should not be empty")
+	}
+	// Should be a valid semver
+	if !IsValidSemver(MinSyncBranchHookVersion) {
+		t.Errorf("MinSyncBranchHookVersion %q is not valid semver", MinSyncBranchHookVersion)
+	}
+}
+
+func TestDoctorCheckStruct(t *testing.T) {
+	check := DoctorCheck{
+		Name:    "Test",
+		Status:  StatusOK,
+		Message: "All good",
+		Detail:  "Details here",
+		Fix:     "Fix suggestion",
+	}
+
+	if check.Name != "Test" {
+		t.Errorf("Name = %q, want %q", check.Name, "Test")
+	}
+	if check.Status != StatusOK {
+		t.Errorf("Status = %q, want %q", check.Status, StatusOK)
+	}
+	if check.Message != "All good" {
+		t.Errorf("Message = %q, want %q", check.Message, "All good")
+	}
+}

cmd/bd/doctor/version_test.go

@@ -0,0 +1,97 @@
+package doctor
+
+import (
+	"testing"
+)
+
+func TestCompareVersions(t *testing.T) {
+	tests := []struct {
+		name     string
+		v1       string
+		v2       string
+		expected int
+	}{
+		{"equal versions", "1.0.0", "1.0.0", 0},
+		{"v1 less than v2 major", "1.0.0", "2.0.0", -1},
+		{"v1 greater than v2 major", "2.0.0", "1.0.0", 1},
+		{"v1 less than v2 minor", "1.1.0", "1.2.0", -1},
+		{"v1 greater than v2 minor", "1.2.0", "1.1.0", 1},
+		{"v1 less than v2 patch", "1.0.1", "1.0.2", -1},
+		{"v1 greater than v2 patch", "1.0.2", "1.0.1", 1},
+		{"different length v1 shorter", "1.0", "1.0.0", 0},
+		{"different length v1 longer", "1.0.0", "1.0", 0},
+		{"v1 shorter but greater", "1.1", "1.0.5", 1},
+		{"v1 shorter but less", "1.0", "1.0.5", -1},
+		{"real version comparison", "0.29.0", "0.30.0", -1},
+		{"real version comparison 2", "0.30.1", "0.30.0", 1},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := CompareVersions(tt.v1, tt.v2)
+			if result != tt.expected {
+				t.Errorf("CompareVersions(%q, %q) = %d, want %d", tt.v1, tt.v2, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestIsValidSemver(t *testing.T) {
+	tests := []struct {
+		name     string
+		version  string
+		expected bool
+	}{
+		{"valid 3 part", "1.2.3", true},
+		{"valid 2 part", "1.2", true},
+		{"valid 1 part", "1", true},
+		{"valid with zeros", "0.0.0", true},
+		{"valid large numbers", "100.200.300", true},
+		{"empty string", "", false},
+		{"invalid letters", "1.2.a", false},
+		{"invalid format", "v1.2.3", false},
+		{"trailing dot", "1.2.", false},
+		{"leading dot", ".1.2", false},
+		{"double dots", "1..2", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := IsValidSemver(tt.version)
+			if result != tt.expected {
+				t.Errorf("IsValidSemver(%q) = %v, want %v", tt.version, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestParseVersionParts(t *testing.T) {
+	tests := []struct {
+		name     string
+		version  string
+		expected []int
+	}{
+		{"3 parts", "1.2.3", []int{1, 2, 3}},
+		{"2 parts", "1.2", []int{1, 2}},
+		{"1 part", "5", []int{5}},
+		{"large numbers", "100.200.300", []int{100, 200, 300}},
+		{"zeros", "0.0.0", []int{0, 0, 0}},
+		{"invalid stops at letter", "1.2.a", []int{1, 2}},
+		{"empty returns empty", "", []int{}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ParseVersionParts(tt.version)
+			if len(result) != len(tt.expected) {
+				t.Errorf("ParseVersionParts(%q) length = %d, want %d", tt.version, len(result), len(tt.expected))
+				return
+			}
+			for i := range result {
+				if result[i] != tt.expected[i] {
+					t.Errorf("ParseVersionParts(%q)[%d] = %d, want %d", tt.version, i, result[i], tt.expected[i])
+				}
+			}
+		})
+	}
+}