fizzy-cli 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.7.0 - 2026-01-26
+
+### Features
+
+#### Board Management
+
+- `fizzy board show <board_id>` - Display details for a specific board
+- `fizzy board update <board_id>` - Update board properties (name, access, auto-postpone period)
+- `fizzy board delete <board_id>` - Delete a board
+
+#### Column Management
+
+- `fizzy column show <column_id>` - Display details for a specific column
+- `fizzy column update <column_id>` - Update column properties (name, color)
+- `fizzy column delete <column_id>` - Delete a column
+
+### Improvements
+
+- Improved command output testability by using consistent output writers
+
 ## 0.6.1 - 2026-01-26
 
 ### Fixes

package/cmd/board.go

@@ -40,7 +40,7 @@ func handleShowBoard(cmd *cobra.Command) error {
 		return fmt.Errorf("fetching board: %w", err)
 	}
 
-	fmt.Printf("%s (%s)\n", board.Name, ui.DisplayID(board.ID))
+	fmt.Fprintf(cmd.OutOrStdout(), "%s (%s)\n", board.Name, ui.DisplayID(board.ID))
 	return nil
 }
 

package/cmd/board_create.go

@@ -44,7 +44,7 @@ func handleCreateBoard(cmd *cobra.Command) error {
 		return fmt.Errorf("creating board: %w", err)
 	}
 
-	fmt.Printf("✓ Board '%s' created successfully\n", name)
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Board '%s' created successfully\n", name)
 	return nil
 }
 

package/cmd/board_delete.go

@@ -0,0 +1,40 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var boardDeleteCmd = &cobra.Command{
+	Use:   "delete <board_id>",
+	Short: "Delete a board",
+	Long:  `Delete a board. Only board administrators can delete boards.`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleDeleteBoard(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleDeleteBoard(cmd *cobra.Command, boardID string) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	err := a.Client.DeleteBoard(context.Background(), boardID)
+	if err != nil {
+		return fmt.Errorf("deleting board: %w", err)
+	}
+
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Board '%s' deleted successfully\n", boardID)
+	return nil
+}
+
+func init() {
+	boardCmd.AddCommand(boardDeleteCmd)
+}

package/cmd/board_delete_test.go

@@ -0,0 +1,121 @@
+package cmd
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestBoardDeleteCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards/board-123" {
+			t.Errorf("expected /boards/board-123, got %s", r.URL.Path)
+		}
+		if r.Method != http.MethodDelete {
+			t.Errorf("expected DELETE, got %s", r.Method)
+		}
+
+		auth := r.Header.Get("Authorization")
+		if auth != "Bearer test-token" {
+			t.Errorf("expected Bearer test-token, got %s", auth)
+		}
+
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleDeleteBoard(cmd, "board-123"); err != nil {
+		t.Fatalf("handleDeleteBoard failed: %v", err)
+	}
+}
+
+func TestBoardDeleteCommandNotFound(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Board not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteBoard(cmd, "nonexistent-board")
+	if err == nil {
+		t.Errorf("expected error for board not found")
+	}
+	if err.Error() != "deleting board: unexpected status code 404: Board not found" {
+		t.Errorf("expected board not found error, got %v", err)
+	}
+}
+
+func TestBoardDeleteCommandForbidden(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusForbidden)
+		w.Write([]byte("You don't have permission to delete this board"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteBoard(cmd, "board-123")
+	if err == nil {
+		t.Errorf("expected error for forbidden access")
+	}
+	if err.Error() != "deleting board: unexpected status code 403: You don't have permission to delete this board" {
+		t.Errorf("expected permission error, got %v", err)
+	}
+}
+
+func TestBoardDeleteCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Internal Server Error"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteBoard(cmd, "board-123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "deleting board: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestBoardDeleteCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := boardDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteBoard(cmd, "board-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)
+	}
+}

package/cmd/board_show.go

@@ -0,0 +1,40 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
+	"github.com/spf13/cobra"
+)
+
+var boardShowCmd = &cobra.Command{
+	Use:   "show <board_id>",
+	Short: "Show board details",
+	Long:  `Retrieve and display detailed information about a specific board`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleShowBoardDetails(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleShowBoardDetails(cmd *cobra.Command, boardID string) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	board, err := a.Client.GetBoard(context.Background(), boardID)
+	if err != nil {
+		return fmt.Errorf("fetching board: %w", err)
+	}
+
+	return ui.DisplayBoard(cmd.OutOrStdout(), board)
+}
+
+func init() {
+	boardCmd.AddCommand(boardShowCmd)
+}

package/cmd/board_show_test.go

@@ -0,0 +1,113 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"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 TestBoardShowCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards/board-123" {
+			t.Errorf("expected /boards/board-123, got %s", r.URL.Path)
+		}
+		if r.Method != http.MethodGet {
+			t.Errorf("expected GET, got %s", r.Method)
+		}
+
+		auth := r.Header.Get("Authorization")
+		if auth != "Bearer test-token" {
+			t.Errorf("expected Bearer test-token, got %s", auth)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := api.Board{
+			ID:        "board-123",
+			Name:      "Project Alpha",
+			AllAccess: true,
+			CreatedAt: "2025-01-01T00:00:00Z",
+			Creator: api.User{
+				ID:   "user-123",
+				Name: "John Doe",
+				Role: "owner",
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleShowBoardDetails(cmd, "board-123"); err != nil {
+		t.Fatalf("handleShowBoardDetails failed: %v", err)
+	}
+}
+
+func TestBoardShowCommandNotFound(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Board not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowBoardDetails(cmd, "nonexistent-board")
+	if err == nil {
+		t.Errorf("expected error for board not found")
+	}
+	if err.Error() != "fetching board: unexpected status code 404: Board not found" {
+		t.Errorf("expected board not found error, got %v", err)
+	}
+}
+
+func TestBoardShowCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Internal Server Error"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowBoardDetails(cmd, "board-123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching board: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestBoardShowCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := boardShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowBoardDetails(cmd, "board-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)
+	}
+}

package/cmd/board_update.go

@@ -0,0 +1,72 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var boardUpdateCmd = &cobra.Command{
+	Use:   "update <board_id>",
+	Short: "Update a board",
+	Long:  `Update board settings such as name, access permissions, and auto-postpone period`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleUpdateBoard(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleUpdateBoard(cmd *cobra.Command, boardID string) error {
+	// Check that at least one flag was explicitly set
+	if !cmd.Flags().Changed("name") && !cmd.Flags().Changed("all-access") &&
+		!cmd.Flags().Changed("auto-postpone-period") && !cmd.Flags().Changed("description") {
+		return fmt.Errorf("at least one flag must be provided (--name, --all-access, --auto-postpone-period, or --description)")
+	}
+
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	// Build payload only with flags that were explicitly set
+	payload := api.UpdateBoardPayload{}
+
+	if cmd.Flags().Changed("name") {
+		name, _ := cmd.Flags().GetString("name")
+		payload.Name = name
+	}
+	if cmd.Flags().Changed("all-access") {
+		allAccess, _ := cmd.Flags().GetBool("all-access")
+		payload.AllAccess = &allAccess
+	}
+	if cmd.Flags().Changed("auto-postpone-period") {
+		autoPostponePeriod, _ := cmd.Flags().GetInt("auto-postpone-period")
+		payload.AutoPostponePeriod = &autoPostponePeriod
+	}
+	if cmd.Flags().Changed("description") {
+		publicDescription, _ := cmd.Flags().GetString("description")
+		payload.PublicDescription = publicDescription
+	}
+
+	err := a.Client.PutBoard(context.Background(), boardID, payload)
+	if err != nil {
+		return fmt.Errorf("updating board: %w", err)
+	}
+
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Board '%s' updated successfully\n", boardID)
+	return nil
+}
+
+func init() {
+	boardUpdateCmd.Flags().StringP("name", "n", "", "Board name")
+	boardUpdateCmd.Flags().Bool("all-access", false, "Allow all access to the board")
+	boardUpdateCmd.Flags().Int("auto-postpone-period", 0, "Auto postpone period in days")
+	boardUpdateCmd.Flags().String("description", "", "Public description of the board")
+
+	boardCmd.AddCommand(boardUpdateCmd)
+}

package/cmd/board_update_test.go

@@ -0,0 +1,233 @@
+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"
+	"github.com/spf13/cobra"
+)
+
+func TestBoardUpdateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards/board-123" {
+			t.Errorf("expected /boards/board-123, got %s", r.URL.Path)
+		}
+		if r.Method != http.MethodPut {
+			t.Errorf("expected PUT, 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]api.UpdateBoardPayload
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		boardPayload := payload["board"]
+		if boardPayload.Name != "Updated Board" {
+			t.Errorf("expected name 'Updated Board', got %s", boardPayload.Name)
+		}
+
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Board"})
+
+	if err := handleUpdateBoard(cmd, "board-123"); err != nil {
+		t.Fatalf("handleUpdateBoard failed: %v", err)
+	}
+}
+
+func TestBoardUpdateCommandWithAllFlags(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPut {
+			t.Errorf("expected PUT, got %s", r.Method)
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]api.UpdateBoardPayload
+		json.Unmarshal(body, &payload)
+
+		boardPayload := payload["board"]
+		if boardPayload.Name != "Updated Board" {
+			t.Errorf("expected name 'Updated Board', got %s", boardPayload.Name)
+		}
+		if boardPayload.AllAccess == nil || !*boardPayload.AllAccess {
+			t.Error("expected AllAccess to be pointer to true")
+		}
+		if boardPayload.AutoPostponePeriod == nil || *boardPayload.AutoPostponePeriod != 14 {
+			t.Errorf("expected AutoPostponePeriod pointer to 14, got %v", boardPayload.AutoPostponePeriod)
+		}
+		if boardPayload.PublicDescription != "Updated description" {
+			t.Errorf("expected description 'Updated description', got %s", boardPayload.PublicDescription)
+		}
+
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--name", "Updated Board",
+		"--all-access",
+		"--auto-postpone-period", "14",
+		"--description", "Updated description",
+	})
+
+	if err := handleUpdateBoard(cmd, "board-123"); err != nil {
+		t.Fatalf("handleUpdateBoard failed: %v", err)
+	}
+}
+
+func TestBoardUpdateCommandZeroValues(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPut {
+			t.Errorf("expected PUT, got %s", r.Method)
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]api.UpdateBoardPayload
+		json.Unmarshal(body, &payload)
+
+		boardPayload := payload["board"]
+		// Verify that false value is sent (not omitted)
+		if boardPayload.AllAccess == nil {
+			t.Error("expected AllAccess to be set (pointer), but got nil")
+		}
+		if *boardPayload.AllAccess != false {
+			t.Error("expected AllAccess to be false")
+		}
+		// Verify that 0 value is sent (not omitted)
+		if boardPayload.AutoPostponePeriod == nil {
+			t.Error("expected AutoPostponePeriod to be set (pointer), but got nil")
+		}
+		if *boardPayload.AutoPostponePeriod != 0 {
+			t.Errorf("expected AutoPostponePeriod to be 0, got %d", *boardPayload.AutoPostponePeriod)
+		}
+
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--all-access=false",
+		"--auto-postpone-period", "0",
+	})
+
+	if err := handleUpdateBoard(cmd, "board-123"); err != nil {
+		t.Fatalf("handleUpdateBoard failed: %v", err)
+	}
+}
+
+func TestBoardUpdateCommandNoFlags(t *testing.T) {
+	client := testutil.NewTestClient("http://localhost", "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	// Create a fresh command to avoid flag pollution from other tests
+	cmd := &cobra.Command{
+		Use:  "update <board_id>",
+		Args: cobra.ExactArgs(1),
+	}
+	cmd.Flags().String("name", "", "Board name")
+	cmd.Flags().Bool("all-access", false, "Allow all access to the board")
+	cmd.Flags().Int("auto-postpone-period", 0, "Auto postpone period in days")
+	cmd.Flags().String("description", "", "Public description of the board")
+
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUpdateBoard(cmd, "board-123")
+	if err == nil {
+		t.Errorf("expected error when no flags provided")
+	}
+	if err.Error() != "at least one flag must be provided (--name, --all-access, --auto-postpone-period, or --description)" {
+		t.Errorf("expected flag requirement error, got %v", err)
+	}
+}
+
+func TestBoardUpdateCommandNotFound(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Board not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Board"})
+
+	err := handleUpdateBoard(cmd, "nonexistent-board")
+	if err == nil {
+		t.Errorf("expected error for board not found")
+	}
+	if err.Error() != "updating board: unexpected status code 404: Board not found" {
+		t.Errorf("expected board not found error, got %v", err)
+	}
+}
+
+func TestBoardUpdateCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Internal Server Error"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := boardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Board"})
+
+	err := handleUpdateBoard(cmd, "board-123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "updating board: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestBoardUpdateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := boardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Board"})
+
+	err := handleUpdateBoard(cmd, "board-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)
+	}
+}

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
 }