fizzy-cli 0.1.0 → 0.2.1

package/cmd/card_show.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
+	"github.com/spf13/cobra"
+)
+
+var cardShowCmd = &cobra.Command{
+	Use:   "show <card_id>",
+	Short: "Show card details",
+	Long:  `Retrieve and display details for a specific card`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleShowCard(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleShowCard(cmd *cobra.Command, cardID string) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	cardNumber, err := strconv.Atoi(cardID)
+	if err != nil {
+		return fmt.Errorf("card ID must be a number: %w", err)
+	}
+
+	card, err := a.Client.GetCard(context.Background(), cardNumber)
+	if err != nil {
+		return fmt.Errorf("fetching card: %w", err)
+	}
+
+	return ui.DisplayCard(card)
+}
+
+func init() {
+	cardCmd.AddCommand(cardShowCmd)
+}

package/cmd/card_show_test.go

@@ -0,0 +1,92 @@
+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 TestCardShowCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/1" {
+			t.Errorf("expected /cards/1, 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.Card{
+			ID:           "card-123",
+			Number:       1,
+			Title:        "Implement feature",
+			Status:       "in_progress",
+			Description:  "This is a test card",
+			Tags:         []string{"feature", "backend"},
+			Golden:       false,
+			CreatedAt:    "2025-01-01T00:00:00Z",
+			LastActiveAt: "2025-01-15T10:30:00Z",
+			URL:          "https://example.com/card/1",
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleShowCard(cmd, "1"); err != nil {
+		t.Fatalf("handleShowCard failed: %v", err)
+	}
+}
+
+func TestCardShowCommandAPIError(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 := cardShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowCard(cmd, "999")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching card: unexpected status code 404: Card not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestCardShowCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowCard(cmd, "1")
+	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_update.go

@@ -0,0 +1,74 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var (
+	updateTitle        string
+	updateDescription  string
+	updateStatus       string
+	updateTagIDs       []string
+	updateLastActiveAt string
+)
+
+var cardUpdateCmd = &cobra.Command{
+	Use:   "update <card_number>",
+	Short: "Update a card",
+	Long:  `Update an existing card's details`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleUpdateCard(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleUpdateCard(cmd *cobra.Command, cardNumber 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")
+	}
+
+	// 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)")
+	}
+
+	payload := api.UpdateCardPayload{
+		Title:        updateTitle,
+		Description:  updateDescription,
+		Status:       updateStatus,
+		TagIDS:       updateTagIDs,
+		LastActiveAt: updateLastActiveAt,
+	}
+
+	card, err := a.Client.PutCard(context.Background(), cardNum, payload)
+	if err != nil {
+		return fmt.Errorf("updating card: %w", err)
+	}
+
+	fmt.Printf("✓ Card #%d updated successfully\n", card.Number)
+	return nil
+}
+
+func init() {
+	cardUpdateCmd.Flags().StringVarP(&updateTitle, "title", "t", "", "Card title")
+	cardUpdateCmd.Flags().StringVarP(&updateDescription, "description", "d", "", "Card description")
+	cardUpdateCmd.Flags().StringVar(&updateStatus, "status", "", "Card status")
+	cardUpdateCmd.Flags().StringSliceVar(&updateTagIDs, "tag-id", []string{}, "Tag ID (can be used multiple times)")
+	cardUpdateCmd.Flags().StringVar(&updateLastActiveAt, "last-active-at", "", "Last active timestamp")
+
+	cardCmd.AddCommand(cardUpdateCmd)
+}

package/cmd/card_update_test.go

@@ -0,0 +1,147 @@
+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 TestCardUpdateCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/1" {
+			t.Errorf("expected /cards/1, 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)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := api.Card{
+			ID:           "card-123",
+			Number:       1,
+			Title:        "Updated card title",
+			Status:       "published",
+			Description:  "Updated description",
+			Tags:         []string{"updated-tag"},
+			Golden:       false,
+			CreatedAt:    "2025-01-01T00:00:00Z",
+			LastActiveAt: "2025-01-15T10:30:00Z",
+			URL:          "https://example.com/card/1",
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	// Reset flags to defaults
+	updateTitle = "Updated card title"
+	updateDescription = "Updated description"
+	updateStatus = "published"
+	updateTagIDs = []string{"updated-tag"}
+
+	if err := handleUpdateCard(cmd, "1"); err != nil {
+		t.Fatalf("handleUpdateCard failed: %v", err)
+	}
+}
+
+func TestCardUpdateCommandAPIError(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 := cardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	updateTitle = "Updated card"
+
+	err := handleUpdateCard(cmd, "999")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "updating card: unexpected status code 404: Card not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestCardUpdateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	updateTitle = "Updated card"
+
+	err := handleUpdateCard(cmd, "1")
+	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 TestCardUpdateCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	updateTitle = "Updated card"
+
+	err := handleUpdateCard(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 TestCardUpdateCommandNoFlags(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	// Reset all flags
+	updateTitle = ""
+	updateDescription = ""
+	updateStatus = ""
+	updateTagIDs = []string{}
+	updateLastActiveAt = ""
+
+	err := handleUpdateCard(cmd, "1")
+	if err == nil {
+		t.Errorf("expected error when no flags are provided")
+	}
+	if err.Error() != "must provide at least one flag to update (--title, --description, --status, --tag-id, or --last-active-at)" {
+		t.Errorf("expected 'no flags' error, got %v", err)
+	}
+}

package/cmd/column.go

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

package/cmd/column_create.go

@@ -0,0 +1,80 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/colors"
+	"github.com/spf13/cobra"
+)
+
+var (
+	columnName  string
+	columnColor string
+)
+
+func buildColorAliases() map[string]api.Color {
+	aliases := make(map[string]api.Color)
+	for _, colorDef := range colors.All {
+		aliases[strings.ToLower(colorDef.Name)] = api.Color(colorDef.CSSValue)
+	}
+	return aliases
+}
+
+func getAvailableColors() string {
+	var names []string
+	for _, colorDef := range colors.All {
+		names = append(names, strings.ToLower(colorDef.Name))
+	}
+	return strings.Join(names, ", ")
+}
+
+var columnCreateCmd = &cobra.Command{
+	Use:   "create",
+	Short: "Create a new column",
+	Long:  `Create a new column in the selected board. Color is optional.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleCreateColumn(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleCreateColumn(cmd *cobra.Command) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	payload := api.CreateColumnPayload{
+		Name: columnName,
+	}
+
+	if columnColor != "" {
+		colorAliases := buildColorAliases()
+		color, ok := colorAliases[columnColor]
+		if !ok {
+			return fmt.Errorf("invalid color '%s'. Available colors: %s", columnColor, getAvailableColors())
+		}
+		payload.Color = &color
+	}
+
+	_, err := a.Client.PostColumns(context.Background(), payload)
+	if err != nil {
+		return fmt.Errorf("creating column: %w", err)
+	}
+
+	fmt.Printf("✓ Column '%s' created successfully\n", columnName)
+	return nil
+}
+
+func init() {
+	columnCreateCmd.Flags().StringVarP(&columnName, "name", "n", "", "Column name (required)")
+	columnCreateCmd.MarkFlagRequired("name")
+	columnCreateCmd.Flags().StringVar(&columnColor, "color", "", fmt.Sprintf("Column color (optional). Available: %s", getAvailableColors()))
+
+	columnCmd.AddCommand(columnCreateCmd)
+}

package/cmd/column_create_test.go

@@ -0,0 +1,196 @@
+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 TestColumnCreateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards/board-123/columns" {
+			t.Errorf("expected /boards/board-123/columns, 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)
+		}
+
+		if r.Header.Get("Content-Type") != "application/json" {
+			t.Errorf("expected Content-Type: application/json, got %s", r.Header.Get("Content-Type"))
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]api.CreateColumnPayload
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		columnPayload := payload["column"]
+		if columnPayload.Name != "Todo" {
+			t.Errorf("expected name 'Todo', got %s", columnPayload.Name)
+		}
+		if columnPayload.Color != nil {
+			t.Errorf("expected no color, got %v", columnPayload.Color)
+		}
+
+		w.WriteHeader(http.StatusCreated)
+		w.Header().Set("Location", "/columns/col-123")
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := columnCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Todo"})
+
+	columnName = "Todo"
+	columnColor = ""
+
+	if err := handleCreateColumn(cmd); err != nil {
+		t.Fatalf("handleCreateColumn failed: %v", err)
+	}
+}
+
+func TestColumnCreateCommandWithColor(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			t.Errorf("expected POST, got %s", r.Method)
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]api.CreateColumnPayload
+		json.Unmarshal(body, &payload)
+
+		columnPayload := payload["column"]
+		if columnPayload.Name != "In Progress" {
+			t.Errorf("expected name 'In Progress', got %s", columnPayload.Name)
+		}
+		if columnPayload.Color == nil {
+			t.Error("expected color to be set")
+		}
+		if *columnPayload.Color != "var(--color-card-4)" {
+			t.Errorf("expected color 'var(--color-card-4)', got %s", *columnPayload.Color)
+		}
+
+		w.WriteHeader(http.StatusCreated)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := columnCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "In Progress", "--color", "lime"})
+
+	columnName = "In Progress"
+	columnColor = "lime"
+
+	if err := handleCreateColumn(cmd); err != nil {
+		t.Fatalf("handleCreateColumn failed: %v", err)
+	}
+}
+
+func TestColumnCreateCommandInvalidColor(t *testing.T) {
+	client := testutil.NewTestClient("http://localhost", "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := columnCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Todo", "--color", "invalid"})
+
+	columnName = "Todo"
+	columnColor = "invalid"
+
+	err := handleCreateColumn(cmd)
+	if err == nil {
+		t.Errorf("expected error for invalid color")
+	}
+	if err.Error() != "invalid color 'invalid'. Available colors: blue, gray, tan, yellow, lime, aqua, violet, purple, pink" {
+		t.Errorf("expected invalid color error, got %v", err)
+	}
+}
+
+func TestColumnCreateCommandNoBoard(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := columnCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Todo"})
+
+	columnName = "Todo"
+	columnColor = ""
+
+	err := handleCreateColumn(cmd)
+	if err == nil {
+		t.Errorf("expected error when board not selected")
+	}
+	if err.Error() != "creating column: please select a board first with 'fizzy use --board <board_name>'" {
+		t.Errorf("expected 'board not selected' error, got %v", err)
+	}
+}
+
+func TestColumnCreateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := columnCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Todo"})
+
+	columnName = "Todo"
+	columnColor = ""
+
+	err := handleCreateColumn(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 TestColumnCreateCommandAPIError(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}
+
+	cmd := columnCreateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Todo"})
+
+	columnName = "Todo"
+	columnColor = ""
+
+	err := handleCreateColumn(cmd)
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "creating column: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/column_list.go

@@ -0,0 +1,44 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
+	"github.com/spf13/cobra"
+)
+
+var columnListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all columns",
+	Long:  `Retrieve and display all columns in the selected board`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleListColumns(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleListColumns(cmd *cobra.Command) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	columns, err := a.Client.GetColumns(context.Background())
+	if err != nil {
+		return fmt.Errorf("fetching columns: %w", err)
+	}
+
+	if len(columns) == 0 {
+		fmt.Println("No columns found")
+		return nil
+	}
+
+	return ui.DisplayColumns(columns)
+}
+
+func init() {
+	columnCmd.AddCommand(columnListCmd)
+}