fizzy-cli 0.6.1 → 0.8.0

package/cmd/card_assign.go

@@ -46,7 +46,7 @@ func handleAssignCard(cmd *cobra.Command, cardNumber, userID string) error {
 		return fmt.Errorf("assigning card: %w", err)
 	}
 
-	fmt.Printf("✓ Card #%d assignment toggled for user %s\n", cardNum, userID)
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Card #%d assignment toggled for user %s\n", cardNum, userID)
 	return nil
 }
 

package/cmd/card_close.go

@@ -37,7 +37,7 @@ func handleCloseCard(cmd *cobra.Command, cardNumber string) error {
 		return fmt.Errorf("closing card: %w", err)
 	}
 
-	fmt.Printf("✓ Card #%d closed successfully\n", cardNum)
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Card #%d closed successfully\n", cardNum)
 	return nil
 }
 

package/cmd/card_create.go

@@ -54,7 +54,7 @@ func handleCreateCard(cmd *cobra.Command) error {
 		return fmt.Errorf("creating card: %w", err)
 	}
 
-	fmt.Printf("✓ Card '%s' created successfully\n", title)
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Card '%s' created successfully\n", title)
 	return nil
 }
 

package/cmd/card_delete.go

@@ -37,7 +37,7 @@ func handleDeleteCard(cmd *cobra.Command, cardNumber string) error {
 		return fmt.Errorf("deleting card: %w", err)
 	}
 
-	fmt.Printf("✓ Card #%d deleted successfully\n", cardNum)
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Card #%d deleted successfully\n", cardNum)
 	return nil
 }
 

package/cmd/card_golden.go

@@ -37,7 +37,7 @@ func handleGoldenCard(cmd *cobra.Command, cardNumber string) error {
 		return fmt.Errorf("marking card as golden: %w", err)
 	}
 
-	fmt.Printf("✓ Card #%d marked as golden\n", cardNum)
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Card #%d marked as golden\n", cardNum)
 	return nil
 }
 

package/cmd/card_list.go

@@ -13,7 +13,20 @@ import (
 var cardListCmd = &cobra.Command{
 	Use:   "list",
 	Short: "List all cards",
-	Long:  `Retrieve and display all cards from Fizzy`,
+	Long: `Retrieve and display cards from Fizzy with optional filters.
+
+Filter options:
+  --tag <id>          Filter by tag ID (can be used multiple times)
+  --assignee <id>     Filter by assignee user ID (can be used multiple times)
+  --creator <id>      Filter by creator user ID (can be used multiple times)
+  --closer <id>       Filter by user who closed the card (can be used multiple times)
+  --card <id>         Filter to specific card ID (can be used multiple times)
+  --indexed-by        Filter by status: all, closed, not_now, stalled, postponing_soon, golden
+  --sorted-by         Sort order: latest, newest, oldest
+  --unassigned        Show only unassigned cards
+  --created-in        Filter by creation date: today, yesterday, thisweek, lastweek, thismonth, lastmonth, thisyear, lastyear
+  --closed-in         Filter by closure date: today, yesterday, thisweek, lastweek, thismonth, lastmonth, thisyear, lastyear
+  --search            Search terms (can be used multiple times)`,
 	Run: func(cmd *cobra.Command, args []string) {
 		if err := handleListCards(cmd); err != nil {
 			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
@@ -35,6 +48,42 @@ func handleListCards(cmd *cobra.Command) error {
 		BoardIDs: []string{a.Config.SelectedBoard},
 	}
 
+	if tags, _ := cmd.Flags().GetStringSlice("tag"); len(tags) > 0 {
+		filters.TagIDs = tags
+	}
+	if assignees, _ := cmd.Flags().GetStringSlice("assignee"); len(assignees) > 0 {
+		filters.AssigneeIDs = assignees
+	}
+	if creators, _ := cmd.Flags().GetStringSlice("creator"); len(creators) > 0 {
+		filters.CreatorIDs = creators
+	}
+	if closers, _ := cmd.Flags().GetStringSlice("closer"); len(closers) > 0 {
+		filters.CloserIDs = closers
+	}
+	if cardIDs, _ := cmd.Flags().GetStringSlice("card"); len(cardIDs) > 0 {
+		filters.CardIDs = cardIDs
+	}
+	if searches, _ := cmd.Flags().GetStringSlice("search"); len(searches) > 0 {
+		filters.Terms = searches
+	}
+
+	if indexedBy, _ := cmd.Flags().GetString("indexed-by"); indexedBy != "" {
+		filters.IndexedBy = indexedBy
+	}
+	if sortedBy, _ := cmd.Flags().GetString("sorted-by"); sortedBy != "" {
+		filters.SortedBy = sortedBy
+	}
+	if createdIn, _ := cmd.Flags().GetString("created-in"); createdIn != "" {
+		filters.CreationStatus = createdIn
+	}
+	if closedIn, _ := cmd.Flags().GetString("closed-in"); closedIn != "" {
+		filters.ClosureStatus = closedIn
+	}
+
+	if unassigned, _ := cmd.Flags().GetBool("unassigned"); unassigned {
+		filters.AssignmentStatus = "unassigned"
+	}
+
 	cards, err := a.Client.GetCards(context.Background(), filters)
 	if err != nil {
 		return fmt.Errorf("fetching cards: %w", err)
@@ -49,5 +98,17 @@ func handleListCards(cmd *cobra.Command) error {
 }
 
 func init() {
+	cardListCmd.Flags().StringSliceP("tag", "t", []string{}, "Filter by tag ID (can be used multiple times)")
+	cardListCmd.Flags().StringSliceP("assignee", "a", []string{}, "Filter by assignee user ID (can be used multiple times)")
+	cardListCmd.Flags().StringSlice("creator", []string{}, "Filter by creator user ID (can be used multiple times)")
+	cardListCmd.Flags().StringSlice("closer", []string{}, "Filter by closer user ID (can be used multiple times)")
+	cardListCmd.Flags().StringSlice("card", []string{}, "Filter to specific card ID (can be used multiple times)")
+	cardListCmd.Flags().String("indexed-by", "", "Filter by status: all, closed, not_now, stalled, postponing_soon, golden")
+	cardListCmd.Flags().String("sorted-by", "", "Sort order: latest, newest, oldest")
+	cardListCmd.Flags().BoolP("unassigned", "u", false, "Show only unassigned cards")
+	cardListCmd.Flags().String("created-in", "", "Filter by creation date")
+	cardListCmd.Flags().String("closed-in", "", "Filter by closure date")
+	cardListCmd.Flags().StringSliceP("search", "s", []string{}, "Search terms (can be used multiple times)")
+
 	cardCmd.AddCommand(cardListCmd)
 }

package/cmd/card_list_test.go

@@ -11,8 +11,25 @@ import (
 	"github.com/rogeriopvl/fizzy/internal/app"
 	"github.com/rogeriopvl/fizzy/internal/config"
 	"github.com/rogeriopvl/fizzy/internal/testutil"
+	"github.com/spf13/cobra"
 )
 
+func newCardListCmd() *cobra.Command {
+	cmd := &cobra.Command{}
+	cmd.Flags().StringSliceP("tag", "t", []string{}, "Filter by tag ID (can be used multiple times)")
+	cmd.Flags().StringSliceP("assignee", "a", []string{}, "Filter by assignee user ID (can be used multiple times)")
+	cmd.Flags().StringSlice("creator", []string{}, "Filter by creator user ID (can be used multiple times)")
+	cmd.Flags().StringSlice("closer", []string{}, "Filter by closer user ID (can be used multiple times)")
+	cmd.Flags().StringSlice("card", []string{}, "Filter to specific card ID (can be used multiple times)")
+	cmd.Flags().String("indexed-by", "", "Filter by status: all, closed, not_now, stalled, postponing_soon, golden")
+	cmd.Flags().String("sorted-by", "", "Sort order: latest, newest, oldest")
+	cmd.Flags().BoolP("unassigned", "u", false, "Show only unassigned cards")
+	cmd.Flags().String("created-in", "", "Filter by creation date")
+	cmd.Flags().String("closed-in", "", "Filter by closure date")
+	cmd.Flags().StringSliceP("search", "s", []string{}, "Search terms (can be used multiple times)")
+	return cmd
+}
+
 func TestCardListCommand(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.URL.Path != "/cards" {
@@ -146,3 +163,211 @@ func TestCardListCommandNoClient(t *testing.T) {
 		t.Errorf("expected 'client not available' error, got %v", err)
 	}
 }
+
+func TestCardListCommandWithTagFilter(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		tagIDs := r.URL.Query()["tag_ids[]"]
+		if len(tagIDs) != 2 || tagIDs[0] != "tag-123" || tagIDs[1] != "tag-456" {
+			t.Errorf("expected tag_ids[]=tag-123&tag_ids[]=tag-456, got %v", tagIDs)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode([]api.Card{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := newCardListCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--tag", "tag-123", "--tag", "tag-456"})
+
+	if err := handleListCards(cmd); err != nil {
+		t.Fatalf("handleListCards failed: %v", err)
+	}
+}
+
+func TestCardListCommandWithAssigneeFilter(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		assigneeIDs := r.URL.Query()["assignee_ids[]"]
+		if len(assigneeIDs) != 1 || assigneeIDs[0] != "user-123" {
+			t.Errorf("expected assignee_ids[]=user-123, got %v", assigneeIDs)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode([]api.Card{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := newCardListCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--assignee", "user-123"})
+
+	if err := handleListCards(cmd); err != nil {
+		t.Fatalf("handleListCards failed: %v", err)
+	}
+}
+
+func TestCardListCommandWithIndexedByFilter(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		indexedBy := r.URL.Query().Get("indexed_by")
+		if indexedBy != "closed" {
+			t.Errorf("expected indexed_by=closed, got %s", indexedBy)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode([]api.Card{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := newCardListCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--indexed-by", "closed"})
+
+	if err := handleListCards(cmd); err != nil {
+		t.Fatalf("handleListCards failed: %v", err)
+	}
+}
+
+func TestCardListCommandWithSortedByFilter(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		sortedBy := r.URL.Query().Get("sorted_by")
+		if sortedBy != "newest" {
+			t.Errorf("expected sorted_by=newest, got %s", sortedBy)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode([]api.Card{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := newCardListCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--sorted-by", "newest"})
+
+	if err := handleListCards(cmd); err != nil {
+		t.Fatalf("handleListCards failed: %v", err)
+	}
+}
+
+func TestCardListCommandWithUnassignedFilter(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		assignmentStatus := r.URL.Query().Get("assignment_status")
+		if assignmentStatus != "unassigned" {
+			t.Errorf("expected assignment_status=unassigned, got %s", assignmentStatus)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode([]api.Card{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := newCardListCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--unassigned"})
+
+	if err := handleListCards(cmd); err != nil {
+		t.Fatalf("handleListCards failed: %v", err)
+	}
+}
+
+func TestCardListCommandWithSearchFilter(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		terms := r.URL.Query()["terms[]"]
+		if len(terms) != 2 || terms[0] != "bug" || terms[1] != "critical" {
+			t.Errorf("expected terms[]=bug&terms[]=critical, got %v", terms)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode([]api.Card{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := newCardListCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--search", "bug", "--search", "critical"})
+
+	if err := handleListCards(cmd); err != nil {
+		t.Fatalf("handleListCards failed: %v", err)
+	}
+}
+
+func TestCardListCommandWithMultipleFilters(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		boardIDs := r.URL.Query()["board_ids[]"]
+		if len(boardIDs) == 0 || boardIDs[0] != "board-123" {
+			t.Errorf("expected board_ids[]=board-123, got %v", boardIDs)
+		}
+
+		tagIDs := r.URL.Query()["tag_ids[]"]
+		if len(tagIDs) != 1 || tagIDs[0] != "tag-123" {
+			t.Errorf("expected tag_ids[]=tag-123, got %v", tagIDs)
+		}
+
+		assigneeIDs := r.URL.Query()["assignee_ids[]"]
+		if len(assigneeIDs) != 1 || assigneeIDs[0] != "user-456" {
+			t.Errorf("expected assignee_ids[]=user-456, got %v", assigneeIDs)
+		}
+
+		sortedBy := r.URL.Query().Get("sorted_by")
+		if sortedBy != "latest" {
+			t.Errorf("expected sorted_by=latest, got %s", sortedBy)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode([]api.Card{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := newCardListCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--tag", "tag-123",
+		"--assignee", "user-456",
+		"--sorted-by", "latest",
+	})
+
+	if err := handleListCards(cmd); err != nil {
+		t.Fatalf("handleListCards failed: %v", err)
+	}
+}

package/cmd/card_not_now.go

@@ -37,7 +37,7 @@ func handleNotNowCard(cmd *cobra.Command, cardNumber string) error {
 		return fmt.Errorf("moving card to not now: %w", err)
 	}
 
-	fmt.Printf("✓ Card #%d moved to Not Now successfully\n", cardNum)
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Card #%d moved to Not Now successfully\n", cardNum)
 	return nil
 }
 

package/cmd/card_reaction.go

@@ -0,0 +1,13 @@
+package cmd
+
+import "github.com/spf13/cobra"
+
+var cardReactionCmd = &cobra.Command{
+	Use:   "reaction",
+	Short: "Manage card reactions",
+	Long:  `Manage reactions (boosts) on cards in Fizzy`,
+}
+
+func init() {
+	cardCmd.AddCommand(cardReactionCmd)
+}

package/cmd/card_reaction_create.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var cardReactionCreateCmd = &cobra.Command{
+	Use:   "create <card_number> <emoji>",
+	Short: "Create a reaction on a card",
+	Long:  `Create an emoji reaction (boost) on a card`,
+	Args:  cobra.ExactArgs(2),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleCreateCardReaction(cmd, args[0], args[1]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleCreateCardReaction(cmd *cobra.Command, cardNumber, emoji string) error {
+	cardNum, err := strconv.Atoi(cardNumber)
+	if err != nil {
+		return fmt.Errorf("invalid card number: %w", err)
+	}
+
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	_, err = a.Client.PostCardReaction(context.Background(), cardNum, emoji)
+	if err != nil {
+		return fmt.Errorf("creating reaction: %w", err)
+	}
+
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Reaction %s created successfully\n", emoji)
+	return nil
+}
+
+func init() {
+	cardReactionCmd.AddCommand(cardReactionCreateCmd)
+}

package/cmd/card_reaction_create_test.go

@@ -0,0 +1,148 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestCardReactionCreateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/reactions" {
+			t.Errorf("expected /cards/123/reactions, got %s", r.URL.Path)
+		}
+		if r.Method != http.MethodPost {
+			t.Errorf("expected POST, got %s", r.Method)
+		}
+
+		auth := r.Header.Get("Authorization")
+		if auth != "Bearer test-token" {
+			t.Errorf("expected Bearer test-token, got %s", auth)
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]map[string]string
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		reactionPayload := payload["reaction"]
+		if reactionPayload["content"] != "👍" {
+			t.Errorf("expected content '👍', got %s", reactionPayload["content"])
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusCreated)
+		response := api.Reaction{
+			ID:      "reaction-123",
+			Content: "👍",
+			Reacter: api.User{ID: "user-1", Name: "John Doe"},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardReactionCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleCreateCardReaction(cmd, "123", "👍"); err != nil {
+		t.Fatalf("handleCreateCardReaction failed: %v", err)
+	}
+}
+
+func TestCardReactionCreateCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardReactionCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleCreateCardReaction(cmd, "not-a-number", "👍")
+	if err == nil {
+		t.Errorf("expected error for invalid card number")
+	}
+	if err.Error() != "invalid card number: strconv.Atoi: parsing \"not-a-number\": invalid syntax" {
+		t.Errorf("expected invalid card number error, got %v", err)
+	}
+}
+
+func TestCardReactionCreateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardReactionCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleCreateCardReaction(cmd, "123", "👍")
+	if err == nil {
+		t.Errorf("expected error when client not available")
+	}
+	if err.Error() != "API client not available" {
+		t.Errorf("expected 'client not available' error, got %v", err)
+	}
+}
+
+func TestCardReactionCreateCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Card not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardReactionCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleCreateCardReaction(cmd, "123", "👍")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "creating reaction: unexpected status code 404: Card not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestCardReactionCreateCommandDifferentEmoji(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]map[string]string
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		reactionPayload := payload["reaction"]
+		if reactionPayload["content"] != "🎉" {
+			t.Errorf("expected content '🎉', got %s", reactionPayload["content"])
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusCreated)
+		response := api.Reaction{
+			ID:      "reaction-456",
+			Content: "🎉",
+			Reacter: api.User{ID: "user-2", Name: "Jane Doe"},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardReactionCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleCreateCardReaction(cmd, "123", "🎉"); err != nil {
+		t.Fatalf("handleCreateCardReaction failed: %v", err)
+	}
+}

package/cmd/card_reaction_delete.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var cardReactionDeleteCmd = &cobra.Command{
+	Use:   "delete <card_number> <reaction_id>",
+	Short: "Delete a reaction from a card",
+	Long:  `Remove your reaction (boost) from a card`,
+	Args:  cobra.ExactArgs(2),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleDeleteCardReaction(cmd, args[0], args[1]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleDeleteCardReaction(cmd *cobra.Command, cardNumber, reactionID string) error {
+	cardNum, err := strconv.Atoi(cardNumber)
+	if err != nil {
+		return fmt.Errorf("invalid card number: %w", err)
+	}
+
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	_, err = a.Client.DeleteCardReaction(context.Background(), cardNum, reactionID)
+	if err != nil {
+		return fmt.Errorf("deleting reaction: %w", err)
+	}
+
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Reaction deleted successfully\n")
+	return nil
+}
+
+func init() {
+	cardReactionCmd.AddCommand(cardReactionDeleteCmd)
+}