Improve test coverage for bd-136

Added tests for internal/rpc and internal/storage/sqlite:

RPC tests (+5.8% coverage: 58.0% → 63.8%):
- TestCloseIssue: Cover handleClose (was 0%)
- TestReposStats: Cover handleReposStats (was 0%)
- TestReposClearCache: Cover handleReposClearCache (was 0%)
- TestEpicStatus: Cover handleEpicStatus (was 0%)

Storage tests (+2.6% coverage: 62.2% → 64.8%):
- Created epics_test.go with TestGetEpicsEligibleForClosure
- TestUpdateIssueValidation: validateIssueType, validateEstimatedMinutes
- TestGetAllConfig, TestDeleteConfig, TestIsClosed

Overall coverage: 48.7% → 50.7% (+2.0%)

Progress on bd-136: Achieve 75% test coverage across codebase

Amp-Thread-ID: https://ampcode.com/threads/T-16b56923-6fbc-45db-b68b-315567849ec6
Co-authored-by: Amp <amp@ampcode.com>

internal/rpc/coverage_test.go

@@ -247,3 +247,161 @@ func TestReposReady(t *testing.T) {
 		t.Errorf("ReposReady failed: %s", resp.Error)
 	}
 }
+
+func TestReposStats(t *testing.T) {
+	_, client, cleanup := setupTestServer(t)
+	defer cleanup()
+	defer client.Close()
+
+	// Create a test issue to populate stats
+	createArgs := &CreateArgs{
+		Title:     "Test Issue for Stats",
+		IssueType: "task",
+		Priority:  2,
+	}
+	_, err := client.Create(createArgs)
+	if err != nil {
+		t.Fatalf("Create failed: %v", err)
+	}
+
+	resp, err := client.ReposStats()
+	if err != nil {
+		t.Fatalf("ReposStats failed: %v", err)
+	}
+
+	if !resp.Success {
+		t.Errorf("ReposStats failed: %s", resp.Error)
+	}
+
+	// Verify response structure
+	var statsResp ReposStatsResponse
+	if err := json.Unmarshal(resp.Data, &statsResp); err != nil {
+		t.Fatalf("Failed to unmarshal stats response: %v", err)
+	}
+
+	if statsResp.Total.TotalIssues == 0 {
+		t.Error("Expected TotalIssues > 0 in aggregated stats")
+	}
+}
+
+func TestReposClearCache(t *testing.T) {
+	_, client, cleanup := setupTestServer(t)
+	defer cleanup()
+	defer client.Close()
+
+	// Create an issue to populate cache
+	createArgs := &CreateArgs{
+		Title:     "Test Issue",
+		IssueType: "task",
+		Priority:  2,
+	}
+	_, err := client.Create(createArgs)
+	if err != nil {
+		t.Fatalf("Create failed: %v", err)
+	}
+
+	// Clear the cache
+	resp, err := client.ReposClearCache()
+	if err != nil {
+		t.Fatalf("ReposClearCache failed: %v", err)
+	}
+
+	if !resp.Success {
+		t.Errorf("ReposClearCache failed: %s", resp.Error)
+	}
+
+	// Verify we can still operate after cache clear (cache should rebuild)
+	createArgs2 := &CreateArgs{
+		Title:     "Post-Clear Issue",
+		IssueType: "task",
+		Priority:  2,
+	}
+	createResp, err := client.Create(createArgs2)
+	if err != nil {
+		t.Fatalf("Create after cache clear failed: %v", err)
+	}
+
+	if !createResp.Success {
+		t.Errorf("Expected create to succeed after cache clear")
+	}
+}
+
+func TestEpicStatus(t *testing.T) {
+	_, client, cleanup := setupTestServer(t)
+	defer cleanup()
+	defer client.Close()
+
+	// Create an epic with subtasks
+	epicArgs := &CreateArgs{
+		Title:       "Test Epic",
+		Description: "Epic for testing status",
+		IssueType:   "epic",
+		Priority:    2,
+	}
+	epicResp, err := client.Create(epicArgs)
+	if err != nil {
+		t.Fatalf("Create epic failed: %v", err)
+	}
+
+	var epic types.Issue
+	json.Unmarshal(epicResp.Data, &epic)
+
+	// Create a subtask
+	taskArgs := &CreateArgs{
+		Title:     "Subtask",
+		IssueType: "task",
+		Priority:  2,
+	}
+	taskResp, err := client.Create(taskArgs)
+	if err != nil {
+		t.Fatalf("Create task failed: %v", err)
+	}
+
+	var task types.Issue
+	json.Unmarshal(taskResp.Data, &task)
+
+	// Link task to epic
+	depArgs := &DepAddArgs{
+		FromID:  task.ID,
+		ToID:    epic.ID,
+		DepType: "parent-child",
+	}
+	_, err = client.AddDependency(depArgs)
+	if err != nil {
+		t.Fatalf("AddDependency failed: %v", err)
+	}
+
+	// Test EpicStatus with eligibleOnly=false
+	epicStatusArgs := &EpicStatusArgs{
+		EligibleOnly: false,
+	}
+	resp, err := client.EpicStatus(epicStatusArgs)
+	if err != nil {
+		t.Fatalf("EpicStatus failed: %v", err)
+	}
+
+	if !resp.Success {
+		t.Errorf("EpicStatus failed: %s", resp.Error)
+	}
+
+	var epicStatuses []*types.EpicStatus
+	if err := json.Unmarshal(resp.Data, &epicStatuses); err != nil {
+		t.Fatalf("Failed to unmarshal epic statuses: %v", err)
+	}
+
+	// Should find at least one epic
+	if len(epicStatuses) == 0 {
+		t.Error("Expected at least one epic in status")
+	}
+
+	// Test with eligibleOnly=true
+	epicStatusArgs.EligibleOnly = true
+	resp2, err := client.EpicStatus(epicStatusArgs)
+	if err != nil {
+		t.Fatalf("EpicStatus (eligible only) failed: %v", err)
+	}
+
+	if !resp2.Success {
+		t.Errorf("EpicStatus (eligible only) failed: %s", resp2.Error)
+	}
+}

internal/rpc/rpc_test.go

@@ -223,6 +223,54 @@ func TestUpdateIssue(t *testing.T) {
 	}
 }
 
+func TestCloseIssue(t *testing.T) {
+	_, client, cleanup := setupTestServer(t)
+	defer cleanup()
+
+	createArgs := &CreateArgs{
+		Title:     "Issue to Close",
+		IssueType: "task",
+		Priority:  2,
+	}
+
+	createResp, err := client.Create(createArgs)
+	if err != nil {
+		t.Fatalf("Create failed: %v", err)
+	}
+
+	var issue types.Issue
+	json.Unmarshal(createResp.Data, &issue)
+
+	if issue.Status != "open" {
+		t.Errorf("Expected status 'open', got %s", issue.Status)
+	}
+
+	closeArgs := &CloseArgs{
+		ID:     issue.ID,
+		Reason: "Test completion",
+	}
+
+	closeResp, err := client.CloseIssue(closeArgs)
+	if err != nil {
+		t.Fatalf("CloseIssue failed: %v", err)
+	}
+
+	if !closeResp.Success {
+		t.Fatalf("Expected success, got error: %s", closeResp.Error)
+	}
+
+	var closedIssue types.Issue
+	json.Unmarshal(closeResp.Data, &closedIssue)
+
+	if closedIssue.Status != "closed" {
+		t.Errorf("Expected status 'closed', got %s", closedIssue.Status)
+	}
+
+	if closedIssue.ClosedAt == nil {
+		t.Error("Expected ClosedAt to be set, got nil")
+	}
+}
+
 func TestListIssues(t *testing.T) {
 	_, client, cleanup := setupTestServer(t)
 	defer cleanup()