fizzy-cli 0.1.0 → 0.2.0

package/.github/workflows/release.yml

@@ -0,0 +1,29 @@
+name: Release
+
+on:
+  release:
+    types: [created]
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: "1.25"
+
+      - name: Build binaries
+        run: make build-all
+
+      - name: Upload Release Assets
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release upload ${{ github.event.release.tag_name }} bin/fizzy-* --clobber

package/.github/workflows/tests.yml

@@ -0,0 +1,24 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-go@v4
+        with:
+          go-version: "1.25"
+
+      - name: Install gotestsum
+        run: go install gotest.tools/gotestsum@latest
+
+      - name: Run tests
+        run: make test

package/AGENTS.md

@@ -0,0 +1,33 @@
+# AGENTS.md
+
+## About
+
+fizzy-cli is a CLI application built in Go that provides an interface to the
+[Fizzy](https://fizzy.do) API. Fizzy is a kanban-style project management SaaS.
+
+## Dev instructions
+
+All the commands for development are available through Makefile, just read that
+file whenever you need to run something because chances are that you will find
+you answer there.
+
+You can find the Fizzy API specification at @docs/API.md
+
+## Testing
+
+Automated testing is done via `make test`.
+
+For manual testing/debugging, you should run `make install` first to install the
+binary and then run the `fizzy` command normally.
+
+## Code quality, standards and style
+
+This project is being built in Go because it's supposed to have a strong focus
+on performance. Always prefer performant code and solutions and low memory
+footprint.
+
+Don't write obvious code comments. Only use code comments when the code itself
+requires some clarification to be understood.
+
+When in doubt, always check similar files or features and reuse the patterns and
+style applied.

package/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+## [0.2.0] - 2025-12-20
+
+### Features
+
+#### Card Management
+
+- `fizzy card update <card_number>` - Update card properties (title, description, status, tags)
+- `fizzy card delete <card_number>` - Delete a card permanently
+- `fizzy card close <card_number>` - Close an existing card (already existed, now documented)
+- `fizzy card reopen <card_number>` - Reopen a closed card (already existed, now documented)
+
+#### Account Management
+
+- `fizzy account list` - List all accounts you have access to
+
+#### Improvements
+
+- `fizzy board` without arguments now displays the currently selected board
+- Added `--version` flag to display CLI version
+- Fixed HTTP client leak in API requests
+- Updated API specification to latest version
+
+## [0.1.0] - 2025-12-16
+
+### Initial Release
+
+The first stable release of Fizzy CLI with core functionality for managing
+boards, cards, and columns.
+
+### Features
+
+#### Authentication
+
+- `fizzy login` - Authenticate with Fizzy API using access tokens
+
+#### Board Management
+
+- `fizzy board list` - List all boards
+- `fizzy board create` - Create a new board
+
+#### Card Management
+
+- `fizzy card list` - List all cards in the selected board
+- `fizzy card create` - Create a new card
+- `fizzy card show <card_id>` - Display details for a specific card
+
+#### Column Management
+
+- `fizzy column list` - List all columns in the selected board
+- `fizzy column create` - Create a new column
+
+#### Configuration
+
+- `fizzy use --board <name>` - Set the active board for subsequent commands
+- `fizzy use --account <slug>` - Set the active account for subsequent commands
+
+### Distribution
+
+- Multi-platform support (macOS, Linux, Windows)
+- Multi-architecture binaries (x64, arm64)
+- Distributed via NPM with automatic binary download on install

package/Makefile

@@ -1,4 +1,7 @@
-.PHONY: help dev-tools run build build-all clean test
+.PHONY: help dev-tools run build build-all clean test install sync-api-spec
+
+VERSION := $(shell grep '"version"' package.json | sed 's/.*"version": "\([^"]*\)".*/\1/')
+LDFLAGS := -ldflags="-X 'github.com/rogeriopvl/fizzy/cmd.Version=$(VERSION)'"
 
 help:
 	@echo 'Usage: make [target]'
@@ -8,25 +11,33 @@ help:
 
 dev-tools:
 	@echo "Installing development tools..."
-	go install github.com/spf13/cobra@latest
+	go install gotest.tools/gotestsum@latest
 
 run:
 	go run .
 
+install:
+	go install $(LDFLAGS) .
+
 build:
-	go build -o bin/fizzy .
+	go build $(LDFLAGS) -o bin/fizzy .
 
 build-all: clean
 	mkdir -p bin
-	GOOS=darwin GOARCH=amd64 go build -o bin/fizzy-darwin-amd64 .
-	GOOS=darwin GOARCH=arm64 go build -o bin/fizzy-darwin-arm64 .
-	GOOS=linux GOARCH=amd64 go build -o bin/fizzy-linux-amd64 .
-	GOOS=linux GOARCH=arm64 go build -o bin/fizzy-linux-arm64 .
-	GOOS=windows GOARCH=amd64 go build -o bin/fizzy-windows-amd64.exe .
+	GOOS=darwin GOARCH=amd64 go build $(LDFLAGS) -o bin/fizzy-darwin-amd64 .
+	GOOS=darwin GOARCH=arm64 go build $(LDFLAGS) -o bin/fizzy-darwin-arm64 .
+	GOOS=linux GOARCH=amd64 go build $(LDFLAGS) -o bin/fizzy-linux-amd64 .
+	GOOS=linux GOARCH=arm64 go build $(LDFLAGS) -o bin/fizzy-linux-arm64 .
+	GOOS=windows GOARCH=amd64 go build $(LDFLAGS) -o bin/fizzy-windows-amd64.exe .
 	@echo "Binaries built successfully in bin/"
 
 clean:
 	rm -rf bin/
 
 test:
-	go test -v ./...
+	gotestsum -- -v ./...
+
+sync-api-spec:
+	@mkdir -p docs
+	@curl -s https://raw.githubusercontent.com/basecamp/fizzy/main/docs/API.md -o docs/API.md
+	@echo "API spec synced to docs/API.md"

package/README.md

@@ -1,7 +1,94 @@
 # Fizzy CLI
 
+[![Tests](https://github.com/rogeriopvl/fizzy-cli/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/rogeriopvl/fizzy-cli/actions/workflows/tests.yml)
+[![Commits per month](https://img.shields.io/github/commit-activity/m/rogeriopvl/fizzy-cli)](https://github.com/rogeriopvl/fizzy-cli/commits)
+[![Last commit](https://img.shields.io/github/last-commit/rogeriopvl/fizzy-cli)](https://github.com/rogeriopvl/fizzy-cli/commits)
+
 This is a command-line interface for https://fizzy.do
 
 ## Install
 
-Soon...
+You have multiple options to install:
+
+### Homebrew (Mac/Linux)
+
+```bash
+brew tap rogeriopvl/tap
+
+brew install fizzy-cli
+```
+
+### NPM (Mac/Linux/Windows)
+
+```bash
+npm i -g fizzy-cli
+```
+
+Or...
+
+```bash
+npx -y fizzy-cli@latest
+```
+
+## Setup
+
+Before you start using `fizzy-cli`, you need to authenticate it with your Fizzy
+account:
+
+```bash
+fizzy login
+```
+
+The first time you run this command it will print out the instructions for you
+to follow. These instructions will guide you through creating an access token on
+the Fizzy web app.
+
+After you get the token, setup your shell to export the `FIZZY_ACCESS_TOKEN`
+environment variable. Edit your `~/.bashrc` or `~/.zshrc` and add the following
+line:
+
+```bash
+export FIZZY_ACCESS_TOKEN=your_access_token
+```
+
+Reload the shell, and run the `fizzy login` command again to confirm that you're
+authenticated. If you have only one Fizzy account, `fizzy-cli` will select it
+automatically. Otherwise you will be able to select which one you want to use.
+
+### Board selection
+
+You can choose which board you want to pre-select for all your commands with:
+
+```bash
+fizzy use --board <board_name>
+```
+
+To get the board name just type:
+
+```bash
+fizzy board list
+```
+
+The `use` command also supports selecting a different account:
+
+```bash
+fizzy use --account <account_slug>
+```
+
+## Development
+
+### Tests
+
+```bash
+make test
+```
+
+### Run
+
+```bash
+make install
+```
+
+```bash
+fizzy --help
+```

package/cmd/account.go

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

package/cmd/account_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 accountListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all accounts",
+	Long:  `Retrieve and display all accounts from Fizzy`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleListAccounts(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleListAccounts(cmd *cobra.Command) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	identity, err := a.Client.GetMyIdentity(context.Background())
+	if err != nil {
+		return fmt.Errorf("fetching accounts: %w", err)
+	}
+
+	if len(identity.Accounts) == 0 {
+		fmt.Println("No accounts found")
+		return nil
+	}
+
+	return ui.DisplayAccounts(identity.Accounts)
+}
+
+func init() {
+	accountCmd.AddCommand(accountListCmd)
+}

package/cmd/account_list_test.go

@@ -0,0 +1,118 @@
+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 TestAccountListCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/my/identity" {
+			t.Errorf("expected /my/identity, 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 == "" {
+			t.Error("missing Authorization header")
+		}
+		if auth != "Bearer test-token" {
+			t.Errorf("expected Bearer test-token, got %s", auth)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := api.GetMyIdentityResponse{
+			Accounts: []api.Account{
+				{
+					ID:        "account-123",
+					Name:      "Personal",
+					Slug:      "personal",
+					CreatedAt: "2025-01-01T00:00:00Z",
+				},
+				{
+					ID:        "account-456",
+					Name:      "Work",
+					Slug:      "work",
+					CreatedAt: "2025-01-02T00:00:00Z",
+				},
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := accountListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListAccounts(cmd); err != nil {
+		t.Fatalf("handleListAccounts failed: %v", err)
+	}
+}
+
+func TestAccountListCommandNoAccounts(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		response := api.GetMyIdentityResponse{Accounts: []api.Account{}}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := accountListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListAccounts(cmd); err != nil {
+		t.Fatalf("handleListAccounts failed: %v", err)
+	}
+}
+
+func TestAccountListCommandAPIError(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 := accountListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListAccounts(cmd)
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching accounts: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestAccountListCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := accountListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListAccounts(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)
+	}
+}

package/cmd/board.go

@@ -1,23 +1,49 @@
+// Package cmd
 package cmd
 
-import "github.com/spf13/cobra"
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
+	"github.com/spf13/cobra"
+)
 
 var boardCmd = &cobra.Command{
 	Use:   "board",
-	Short: "Manage boards",
-	Long:  `Manage boards in Fizzy`,
+	Short: "Show 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
+  fizzy board create    Create a new board`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleShowBoard(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
 }
 
-func init() {
-	rootCmd.AddCommand(boardCmd)
+func handleShowBoard(cmd *cobra.Command) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
 
-	// Here you will define your flags and configuration settings.
+	if a.Config.SelectedBoard == "" {
+		return fmt.Errorf("no board selected")
+	}
 
-	// Cobra supports Persistent Flags which will work for this command
-	// and all subcommands, e.g.:
-	// boardCmd.PersistentFlags().String("foo", "", "A help for foo")
+	board, err := a.Client.GetBoard(context.Background(), a.Config.SelectedBoard)
+	if err != nil {
+		return fmt.Errorf("fetching board: %w", err)
+	}
 
-	// Cobra supports local flags which will only run when this command
-	// is called directly, e.g.:
-	// boardCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+	fmt.Printf("%s (%s)\n", board.Name, ui.DisplayID(board.ID))
+	return nil
+}
+
+func init() {
+	rootCmd.AddCommand(boardCmd)
 }

package/cmd/board_create.go

@@ -0,0 +1,60 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var (
+	boardName               string
+	boardAllAccess          bool
+	boardAutoPostponePeriod int
+	boardPublicDescription  string
+)
+
+var boardCreateCmd = &cobra.Command{
+	Use:   "create",
+	Short: "Create a new board",
+	Long:  `Create a new board in Fizzy`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleCreateBoard(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleCreateBoard(cmd *cobra.Command) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	payload := api.CreateBoardPayload{
+		Name:               boardName,
+		AllAccess:          boardAllAccess,
+		AutoPostponePeriod: boardAutoPostponePeriod,
+		PublicDescription:  boardPublicDescription,
+	}
+
+	_, err := a.Client.PostBoards(context.Background(), payload)
+	if err != nil {
+		return fmt.Errorf("creating board: %w", err)
+	}
+
+	fmt.Printf("✓ Board '%s' created successfully\n", boardName)
+	return nil
+}
+
+func init() {
+	boardCreateCmd.Flags().StringVarP(&boardName, "name", "n", "", "Board name (required)")
+	boardCreateCmd.MarkFlagRequired("name")
+	boardCreateCmd.Flags().BoolVar(&boardAllAccess, "all-access", false, "Allow all access to the board")
+	boardCreateCmd.Flags().IntVar(&boardAutoPostponePeriod, "auto-postpone-period", 0, "Auto postpone period in days")
+	boardCreateCmd.Flags().StringVar(&boardPublicDescription, "description", "", "Public description of the board")
+
+	boardCmd.AddCommand(boardCreateCmd)
+}