fix: correcting build

Author: benjivesterby

Makefile

@@ -147,7 +147,7 @@ upgrade:
 	upgrade
 
 tidy: fmt
-	tidy
+	go mod tidy
 
 release: 
 	if [ -z "$(tag)" ]; then echo "tag is required"; exit 1; fi

cmd/canary/bug.go

@@ -72,15 +72,29 @@ Examples:
 			filters["status"] = status
 		}
 
-		// Query database for BUG-* tokens
-		tokens, err := db.ListTokens(filters, "BUG-[A-Za-z]+-[0-9]{3}", "priority ASC, updated_at DESC", limit)
+		// Query database for all tokens (ListTokens is hardcoded for CBIN patterns)
+		allTokens, err := db.ListTokens(filters, "", "priority ASC, updated_at DESC", 0)
 		if err != nil {
 			return fmt.Errorf("query bugs: %w", err)
 		}
 
+		// Filter for BUG tokens only
+		var tokens []*storage.Token
+		bugPattern := regexp.MustCompile(`^BUG-[A-Za-z]+-[0-9]{3}$`)
+		for _, tok := range allTokens {
+			if bugPattern.MatchString(tok.ReqID) {
+				tokens = append(tokens, tok)
+			}
+		}
+
 		// Additional filtering for severity and priority (stored in token comments or metadata)
 		filteredTokens := filterBugTokens(tokens, severity, priority)
 
+		// Apply limit if specified
+		if limit > 0 && len(filteredTokens) > limit {
+			filteredTokens = filteredTokens[:limit]
+		}
+
 		if jsonOutput {
 			enc := json.NewEncoder(os.Stdout)
 			enc.SetIndent("", "  ")
@@ -389,21 +403,31 @@ func generateBugID(aspect string, dbPath string) (string, error) {
 	}
 	defer db.Close()
 
-	// Query existing BUG tokens for this aspect
-	pattern := fmt.Sprintf("BUG-%s-[0-9]{3}", aspect)
-	tokens, err := db.ListTokens(nil, pattern, "req_id DESC", 1)
+	return generateBugIDWithDB(aspect, db)
+}
+
+func generateBugIDWithDB(aspect string, db *storage.DB) (string, error) {
+	// Normalize aspect to uppercase
+	aspect = strings.ToUpper(aspect)
+
+	// Query ALL tokens (no pattern filter since ListTokens is hardcoded for CBIN)
+	tokens, err := db.ListTokens(nil, "", "req_id DESC", 0) // Get all tokens
 	if err != nil {
 		// If database doesn't have tokens table yet, start from 001
 		return fmt.Sprintf("BUG-%s-001", aspect), nil
 	}
 
-	// Find highest number
+	// Find highest number for this aspect
 	maxNum := 0
-	if len(tokens) > 0 {
-		// Extract number from last token
-		re := regexp.MustCompile(`BUG-[A-Za-z]+-([0-9]{3})`)
-		if matches := re.FindStringSubmatch(tokens[0].ReqID); len(matches) > 1 {
-			maxNum, _ = strconv.Atoi(matches[1])
+	pattern := fmt.Sprintf(`BUG-%s-([0-9]{3})`, aspect)
+	re := regexp.MustCompile(pattern)
+	for _, token := range tokens {
+		// Extract number from matching tokens
+		if matches := re.FindStringSubmatch(token.ReqID); len(matches) > 1 {
+			num, _ := strconv.Atoi(matches[1])
+			if num > maxNum {
+				maxNum = num
+			}
 		}
 	}
 

cmd/canary/bug_test.go

@@ -41,19 +41,30 @@ func TestGenerateBugID(t *testing.T) {
 
 	// Add some existing bug tokens
 	tokens := []*storage.Token{
-		{ReqID: "BUG-API-001", Feature: "Bug 1", Aspect: "API", Status: "OPEN", FilePath: "test.go", LineNumber: 1, UpdatedAt: "2025-10-18"},
-		{ReqID: "BUG-API-002", Feature: "Bug 2", Aspect: "API", Status: "OPEN", FilePath: "test.go", LineNumber: 2, UpdatedAt: "2025-10-18"},
-		{ReqID: "BUG-API-005", Feature: "Bug 5", Aspect: "API", Status: "OPEN", FilePath: "test.go", LineNumber: 5, UpdatedAt: "2025-10-18"},
+		{ReqID: "BUG-API-001", Feature: "Bug 1", Aspect: "API", Status: "OPEN", FilePath: "main.go", LineNumber: 1, UpdatedAt: "2025-10-18"},
+		{ReqID: "BUG-API-002", Feature: "Bug 2", Aspect: "API", Status: "OPEN", FilePath: "main.go", LineNumber: 2, UpdatedAt: "2025-10-18"},
+		{ReqID: "BUG-API-005", Feature: "Bug 5", Aspect: "API", Status: "OPEN", FilePath: "main.go", LineNumber: 5, UpdatedAt: "2025-10-18"},
 	}
 
 	for _, token := range tokens {
 		if err := db.UpsertToken(token); err != nil {
 			t.Fatalf("Failed to insert token: %v", err)
 		}
+		t.Logf("Inserted token: %s", token.ReqID)
+	}
+
+	// Check what tokens are in the database
+	allTokens, err := db.ListTokens(nil, "", "req_id ASC", 0)
+	if err != nil {
+		t.Logf("Error listing tokens: %v", err)
+	}
+	t.Logf("Tokens found before generating new ID: %d", len(allTokens))
+	for _, tok := range allTokens {
+		t.Logf("  - %s", tok.ReqID)
 	}
 
 	// Generate next ID (should be 006)
-	bugID, err = generateBugID("API", dbPath)
+	bugID, err = generateBugIDWithDB("API", db)
 	if err != nil {
 		t.Fatalf("Failed to generate bug ID: %v", err)
 	}
@@ -63,7 +74,7 @@ func TestGenerateBugID(t *testing.T) {
 	}
 
 	// Test with different aspect
-	bugID, err = generateBugID("CLI", dbPath)
+	bugID, err = generateBugIDWithDB("CLI", db)
 	if err != nil {
 		t.Fatalf("Failed to generate bug ID: %v", err)
 	}
@@ -138,7 +149,7 @@ func TestParsePriorityValue(t *testing.T) {
 		{"P1", 1},
 		{"P2", 2},
 		{"P3", 3},
-		{"", 2},      // default
+		{"", 2},        // default
 		{"invalid", 2}, // default
 	}
 
@@ -160,51 +171,51 @@ func TestFilterBugTokens(t *testing.T) {
 	}
 
 	tests := []struct {
-		name         string
-		severity     string
-		priority     string
+		name          string
+		severity      string
+		priority      string
 		expectedCount int
 	}{
 		{
-			name:         "filter by severity S1",
-			severity:     "S1",
-			priority:     "",
+			name:          "filter by severity S1",
+			severity:      "S1",
+			priority:      "",
 			expectedCount: 1,
 		},
 		{
-			name:         "filter by priority P0",
-			severity:     "",
-			priority:     "P0",
+			name:          "filter by priority P0",
+			severity:      "",
+			priority:      "P0",
 			expectedCount: 1,
 		},
 		{
-			name:         "filter by multiple severities",
-			severity:     "S1,S2",
-			priority:     "",
+			name:          "filter by multiple severities",
+			severity:      "S1,S2",
+			priority:      "",
 			expectedCount: 2,
 		},
 		{
-			name:         "filter by multiple priorities",
-			severity:     "",
-			priority:     "P0,P1",
+			name:          "filter by multiple priorities",
+			severity:      "",
+			priority:      "P0,P1",
 			expectedCount: 2,
 		},
 		{
-			name:         "filter by both",
-			severity:     "S1",
-			priority:     "P0",
+			name:          "filter by both",
+			severity:      "S1",
+			priority:      "P0",
 			expectedCount: 1,
 		},
 		{
-			name:         "no filters",
-			severity:     "",
-			priority:     "",
+			name:          "no filters",
+			severity:      "",
+			priority:      "",
 			expectedCount: 4,
 		},
 		{
-			name:         "non-matching filter",
-			severity:     "S5",
-			priority:     "",
+			name:          "non-matching filter",
+			severity:      "S5",
+			priority:      "",
 			expectedCount: 0,
 		},
 	}
@@ -231,9 +242,9 @@ func TestBugIDValidation(t *testing.T) {
 		{"BUG-API-001", true},
 		{"BUG-CLI-123", true},
 		{"BUG-Storage-999", true},
-		{"BUG-api-001", true}, // lowercase aspect
-		{"CBIN-001", false},   // wrong prefix
-		{"BUG-API-1", false},  // not 3 digits
+		{"BUG-api-001", true},   // lowercase aspect
+		{"CBIN-001", false},     // wrong prefix
+		{"BUG-API-1", false},    // not 3 digits
 		{"BUG-API-1234", false}, // too many digits
 		{"BUG-API", false},      // no number
 		{"BUG--001", false},     // empty aspect
@@ -285,7 +296,7 @@ func TestBugCommandIntegration(t *testing.T) {
 				Feature:    bug.title,
 				Aspect:     bug.aspect,
 				Status:     bug.status,
-				FilePath:   "test.go",
+				FilePath:   "main.go",
 				LineNumber: i + 1,
 				UpdatedAt:  "2025-10-18",
 				Priority:   parsePriorityValue(bug.priority),
@@ -299,12 +310,21 @@ func TestBugCommandIntegration(t *testing.T) {
 	})
 
 	t.Run("list bug tokens", func(t *testing.T) {
-		// List all BUG tokens
-		tokens, err := db.ListTokens(nil, "BUG-[A-Za-z]+-[0-9]{3}", "priority ASC", 0)
+		// List all tokens (empty pattern) and filter BUG tokens manually
+		allTokens, err := db.ListTokens(nil, "", "priority ASC", 0)
 		if err != nil {
 			t.Fatalf("Failed to list bugs: %v", err)
 		}
 
+		// Filter for BUG tokens
+		var tokens []*storage.Token
+		bugPattern := regexp.MustCompile(`^BUG-[A-Za-z]+-[0-9]{3}$`)
+		for _, tok := range allTokens {
+			if bugPattern.MatchString(tok.ReqID) {
+				tokens = append(tokens, tok)
+			}
+		}
+
 		if len(tokens) != 4 {
 			t.Errorf("Expected 4 bugs, got %d", len(tokens))
 		}
@@ -317,11 +337,20 @@ func TestBugCommandIntegration(t *testing.T) {
 
 	t.Run("filter by status", func(t *testing.T) {
 		filters := map[string]string{"status": "OPEN"}
-		tokens, err := db.ListTokens(filters, "BUG-[A-Za-z]+-[0-9]{3}", "priority ASC", 0)
+		allTokens, err := db.ListTokens(filters, "", "priority ASC", 0)
 		if err != nil {
 			t.Fatalf("Failed to filter bugs: %v", err)
 		}
 
+		// Filter for BUG tokens
+		var tokens []*storage.Token
+		bugPattern := regexp.MustCompile(`^BUG-[A-Za-z]+-[0-9]{3}$`)
+		for _, tok := range allTokens {
+			if bugPattern.MatchString(tok.ReqID) {
+				tokens = append(tokens, tok)
+			}
+		}
+
 		if len(tokens) != 2 {
 			t.Errorf("Expected 2 OPEN bugs, got %d", len(tokens))
 		}