fizzy-cli 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.3.0 - 2026-01-11
+
+### Features
+
+#### Notification Management
+
+- `fizzy notification list` - List all notifications with optional filtering
+- `fizzy notification read <notification_id>` - Mark a notification as read and display it
+- `fizzy notification unread <notification_id>` - Mark a notification as unread
+- `fizzy notification read-all` - Mark all unread notifications as read
+
+#### Card Management
+
+- `fizzy card assign <card_number> <user_id>` - Assign or unassign a user to/from a card
+- `fizzy card triage <card_number> <column_id>` - Move a card from triage into a column
+
 ## [0.2.1] - 2025-12-20
 
 ### Fixes

package/cmd/board.go

@@ -13,7 +13,7 @@ import (
 var boardCmd = &cobra.Command{
 	Use:   "board",
 	Short: "Show the currently selected board",
-	Long:  `Display the name and ID of the currently selected board.
+	Long: `Display the name and ID of the currently selected board.
 
 Use subcommands to list, create, or manage boards:
   fizzy board list      List all boards

package/cmd/card_assign.go

@@ -0,0 +1,55 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var cardAssignCmd = &cobra.Command{
+	Use:   "assign <card_number> <user_id>",
+	Short: "Assign a user to a card",
+	Long: `Assign or unassign a user to/from a card.
+
+Use "me" as the user_id to assign the card to yourself.`,
+	Args: cobra.ExactArgs(2),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleAssignCard(cmd, args[0], args[1]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleAssignCard(cmd *cobra.Command, cardNumber, userID 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")
+	}
+
+	if userID == "me" {
+		if a.Config.CurrentUserID == "" {
+			return fmt.Errorf("current user ID not available, please run 'fizzy login' first")
+		}
+		userID = a.Config.CurrentUserID
+	}
+
+	_, err = a.Client.PostCardAssignments(context.Background(), cardNum, userID)
+	if err != nil {
+		return fmt.Errorf("assigning card: %w", err)
+	}
+
+	fmt.Printf("✓ Card #%d assignment toggled for user %s\n", cardNum, userID)
+	return nil
+}
+
+func init() {
+	cardCmd.AddCommand(cardAssignCmd)
+}

package/cmd/card_assign_test.go

@@ -0,0 +1,130 @@
+package cmd
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/config"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestCardAssignCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/assignments" {
+			t.Errorf("expected /cards/123/assignments, 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)
+		}
+
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardAssignCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleAssignCard(cmd, "123", "user-id-123"); err != nil {
+		t.Fatalf("handleAssignCard failed: %v", err)
+	}
+}
+
+func TestCardAssignCommandWithMe(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/assignments" {
+			t.Errorf("expected /cards/123/assignments, got %s", r.URL.Path)
+		}
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	cfg := &config.Config{CurrentUserID: "my-user-id"}
+	testApp := &app.App{Client: client, Config: cfg}
+
+	cmd := cardAssignCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleAssignCard(cmd, "123", "me"); err != nil {
+		t.Fatalf("handleAssignCard with 'me' failed: %v", err)
+	}
+}
+
+func TestCardAssignCommandAPIError(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 := cardAssignCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleAssignCard(cmd, "999", "user-id-123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "assigning card: unexpected status code 404: Card not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestCardAssignCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardAssignCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleAssignCard(cmd, "not-a-number", "user-id-123")
+	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 TestCardAssignCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardAssignCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleAssignCard(cmd, "123", "user-id-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 TestCardAssignCommandMeWithoutUserID(t *testing.T) {
+	client := testutil.NewTestClient("http://localhost", "", "", "test-token")
+	testApp := &app.App{Client: client, Config: &config.Config{}}
+
+	cmd := cardAssignCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleAssignCard(cmd, "123", "me")
+	if err == nil {
+		t.Errorf("expected error when using 'me' without current user ID")
+	}
+	if err.Error() != "current user ID not available, please run 'fizzy login' first" {
+		t.Errorf("expected 'current user ID not available' error, got %v", err)
+	}
+}

package/cmd/card_triage.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var cardTriageCmd = &cobra.Command{
+	Use:   "triage <card_number> <column_id>",
+	Short: "Move a card from triage into a column",
+	Long:  `Move a card from triage into a specified column`,
+	Args:  cobra.ExactArgs(2),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleTriageCard(cmd, args[0], args[1]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleTriageCard(cmd *cobra.Command, cardNumber string, columnID 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.PostCardTriage(context.Background(), cardNum, columnID)
+	if err != nil {
+		return fmt.Errorf("triaging card: %w", err)
+	}
+
+	fmt.Printf("✓ Card #%d moved to column successfully\n", cardNum)
+	return nil
+}
+
+func init() {
+	cardCmd.AddCommand(cardTriageCmd)
+}

package/cmd/card_update.go

@@ -41,7 +41,6 @@ func handleUpdateCard(cmd *cobra.Command, cardNumber string) error {
 		return fmt.Errorf("API client not available")
 	}
 
-	// Validate that at least one field is provided for update
 	if updateTitle == "" && updateDescription == "" && updateStatus == "" && len(updateTagIDs) == 0 && updateLastActiveAt == "" {
 		return fmt.Errorf("must provide at least one flag to update (--title, --description, --status, --tag-id, or --last-active-at)")
 	}

package/cmd/card_update_test.go

@@ -49,7 +49,6 @@ func TestCardUpdateCommand(t *testing.T) {
 	cmd := cardUpdateCmd
 	cmd.SetContext(testApp.ToContext(context.Background()))
 
-	// Reset flags to defaults
 	updateTitle = "Updated card title"
 	updateDescription = "Updated description"
 	updateStatus = "published"
@@ -130,7 +129,6 @@ func TestCardUpdateCommandNoFlags(t *testing.T) {
 	cmd := cardUpdateCmd
 	cmd.SetContext(testApp.ToContext(context.Background()))
 
-	// Reset all flags
 	updateTitle = ""
 	updateDescription = ""
 	updateStatus = ""

package/cmd/login.go

@@ -47,8 +47,9 @@ func handleLogin(cmd *cobra.Command) error {
 
 	fmt.Printf("\nSelected account: %s (%s)\n", selected.Name, selected.Slug)
 
-	// Save the selected account to config
+	// Save the selected account and current user ID to config
 	a.Config.SelectedAccount = selected.Slug
+	a.Config.CurrentUserID = selected.User.ID
 	if err := a.Config.Save(); err != nil {
 		return fmt.Errorf("saving config: %w", err)
 	}

package/cmd/notification.go

@@ -0,0 +1,14 @@
+// Package cmd
+package cmd
+
+import "github.com/spf13/cobra"
+
+var notificationCmd = &cobra.Command{
+	Use:   "notification",
+	Short: "Manage notifications",
+	Long:  `Manage notifications in Fizzy`,
+}
+
+func init() {
+	rootCmd.AddCommand(notificationCmd)
+}

package/cmd/notification_list.go

@@ -0,0 +1,69 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
+	"github.com/spf13/cobra"
+)
+
+var notificationListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all notifications",
+	Long:  `Retrieve and display all notifications from Fizzy`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleListNotifications(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleListNotifications(cmd *cobra.Command) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	notifications, err := a.Client.GetNotifications(context.Background())
+	if err != nil {
+		return fmt.Errorf("fetching notifications: %w", err)
+	}
+
+	read, _ := cmd.Flags().GetBool("read")
+	unread, _ := cmd.Flags().GetBool("unread")
+
+	filtered := filterNotifications(notifications, read, unread)
+
+	if len(filtered) == 0 {
+		fmt.Println("No notifications found")
+		return nil
+	}
+
+	return ui.DisplayNotifications(filtered)
+}
+
+func filterNotifications(notifications []api.Notification, read bool, unread bool) []api.Notification {
+	if !read && !unread {
+		return notifications
+	}
+
+	var filtered []api.Notification
+	for _, notification := range notifications {
+		if read && notification.Read {
+			filtered = append(filtered, notification)
+		} else if unread && !notification.Read {
+			filtered = append(filtered, notification)
+		}
+	}
+
+	return filtered
+}
+
+func init() {
+	notificationCmd.AddCommand(notificationListCmd)
+	notificationListCmd.Flags().BoolP("read", "r", false, "Show only read notifications")
+	notificationListCmd.Flags().BoolP("unread", "u", false, "Show only unread notifications")
+}

package/cmd/notification_list_test.go

@@ -0,0 +1,288 @@
+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/config"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestNotificationListCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/notifications" {
+			t.Errorf("expected /notifications, 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.Notification{
+			{
+				ID:        "notif-123",
+				Read:      false,
+				ReadAt:    "",
+				CreatedAt: "2025-01-01T00:00:00Z",
+				Title:     "Plain text mentions",
+				Body:      "Assigned to self",
+				Creator: api.User{
+					ID:        "user-123",
+					Name:      "David Heinemeier Hansson",
+					Email:     "david@example.com",
+					Role:      "owner",
+					Active:    true,
+					CreatedAt: "2025-12-05T19:36:35.401Z",
+					URL:       "http://fizzy.localhost:3006/897362094/users/03f5v9zjw7pz8717a4no1h8a7",
+				},
+				Card: api.CardReference{
+					ID:     "card-123",
+					Title:  "Plain text mentions",
+					Status: "published",
+					URL:    "http://fizzy.localhost:3006/897362094/cards/3",
+				},
+				URL: "http://fizzy.localhost:3006/897362094/notifications/03f5va03bpuvkcjemcxl73ho2",
+			},
+			{
+				ID:        "notif-456",
+				Read:      true,
+				ReadAt:    "2025-01-02T00:00:00Z",
+				CreatedAt: "2025-01-01T12:00:00Z",
+				Title:     "Comment reply",
+				Body:      "Someone replied to your comment",
+				Creator: api.User{
+					ID:        "user-456",
+					Name:      "Jason Fried",
+					Email:     "jason@example.com",
+					Role:      "member",
+					Active:    true,
+					CreatedAt: "2025-12-05T19:36:35.419Z",
+					URL:       "http://fizzy.localhost:3006/897362094/users/03f5v9zjysoy0fqs9yg0ei3hq",
+				},
+				Card: api.CardReference{
+					ID:     "card-456",
+					Title:  "Fix bug",
+					Status: "in_progress",
+					URL:    "http://fizzy.localhost:3006/897362094/cards/4",
+				},
+				URL: "http://fizzy.localhost:3006/897362094/notifications/notif-456",
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := notificationListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListNotifications(cmd); err != nil {
+		t.Fatalf("handleListNotifications failed: %v", err)
+	}
+}
+
+func TestNotificationListCommandNoNotifications(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode([]api.Notification{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := notificationListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListNotifications(cmd); err != nil {
+		t.Fatalf("handleListNotifications failed: %v", err)
+	}
+}
+
+func TestNotificationListCommandAPIError(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, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := notificationListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListNotifications(cmd)
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching notifications: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestNotificationListCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := notificationListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListNotifications(cmd)
+	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 TestNotificationListCommandWithReadFilter(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		response := []api.Notification{
+			{
+				ID:        "notif-123",
+				Read:      false,
+				CreatedAt: "2025-01-01T00:00:00Z",
+				Title:     "Unread notification",
+				Body:      "This should be filtered out",
+				Creator: api.User{
+					ID:        "user-123",
+					Name:      "David Heinemeier Hansson",
+					Email:     "david@example.com",
+					Role:      "owner",
+					Active:    true,
+					CreatedAt: "2025-12-05T19:36:35.401Z",
+				},
+				Card: api.CardReference{
+					ID:     "card-123",
+					Title:  "Test card",
+					Status: "published",
+				},
+			},
+			{
+				ID:        "notif-456",
+				Read:      true,
+				ReadAt:    "2025-01-02T00:00:00Z",
+				CreatedAt: "2025-01-01T12:00:00Z",
+				Title:     "Read notification",
+				Body:      "This should be shown",
+				Creator: api.User{
+					ID:        "user-456",
+					Name:      "Jason Fried",
+					Email:     "jason@example.com",
+					Role:      "member",
+					Active:    true,
+					CreatedAt: "2025-12-05T19:36:35.419Z",
+				},
+				Card: api.CardReference{
+					ID:     "card-456",
+					Title:  "Another card",
+					Status: "in_progress",
+				},
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := notificationListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.Flags().Set("read", "true")
+
+	if err := handleListNotifications(cmd); err != nil {
+		t.Fatalf("handleListNotifications failed: %v", err)
+	}
+}
+
+func TestNotificationListCommandWithUnreadFilter(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		response := []api.Notification{
+			{
+				ID:        "notif-123",
+				Read:      false,
+				CreatedAt: "2025-01-01T00:00:00Z",
+				Title:     "Unread notification",
+				Body:      "This should be shown",
+				Creator: api.User{
+					ID:        "user-123",
+					Name:      "David Heinemeier Hansson",
+					Email:     "david@example.com",
+					Role:      "owner",
+					Active:    true,
+					CreatedAt: "2025-12-05T19:36:35.401Z",
+				},
+				Card: api.CardReference{
+					ID:     "card-123",
+					Title:  "Test card",
+					Status: "published",
+				},
+			},
+			{
+				ID:        "notif-456",
+				Read:      true,
+				ReadAt:    "2025-01-02T00:00:00Z",
+				CreatedAt: "2025-01-01T12:00:00Z",
+				Title:     "Read notification",
+				Body:      "This should be filtered out",
+				Creator: api.User{
+					ID:        "user-456",
+					Name:      "Jason Fried",
+					Email:     "jason@example.com",
+					Role:      "member",
+					Active:    true,
+					CreatedAt: "2025-12-05T19:36:35.419Z",
+				},
+				Card: api.CardReference{
+					ID:     "card-456",
+					Title:  "Another card",
+					Status: "in_progress",
+				},
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{
+		Client: client,
+		Config: &config.Config{SelectedBoard: "board-123"},
+	}
+
+	cmd := notificationListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.Flags().Set("unread", "true")
+
+	if err := handleListNotifications(cmd); err != nil {
+		t.Fatalf("handleListNotifications failed: %v", err)
+	}
+}