feat(manifest): add 'list' command to display all flags in the manifest

Signed-off-by: Georges Dugué <[email protected]>

Author: georgesdugue

internal/cmd/manifest.go

@@ -20,8 +20,9 @@ func GetManifestCmd() *cobra.Command {
 
 	// Add subcommands
 	manifestCmd.AddCommand(GetManifestAddCmd())
+	manifestCmd.AddCommand(GetManifestListCmd())
 
 	addStabilityInfo(manifestCmd)
 
 	return manifestCmd
-}
+}

internal/cmd/manifest_add.go

@@ -8,10 +8,12 @@ import (
 	"strings"
 
 	"github.com/open-feature/cli/internal/config"
+	"github.com/open-feature/cli/internal/filesystem"
 	"github.com/open-feature/cli/internal/flagset"
 	"github.com/open-feature/cli/internal/logger"
 	"github.com/open-feature/cli/internal/manifest"
 	"github.com/pterm/pterm"
+	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 )
 
@@ -67,16 +69,23 @@ Examples:
 			}
 
 			// Load existing manifest
-			fs, err := manifest.LoadFlagSet(manifestPath)
+			var fs *flagset.Flagset
+			exists, err := afero.Exists(filesystem.FileSystem(), manifestPath)
+
 			if err != nil {
-				// If manifest doesn't exist, create a new one
-				if strings.Contains(err.Error(), "error reading contents") {
-					fs = &flagset.Flagset{
-						Flags: []flagset.Flag{},
-					}
-				} else {
+				return fmt.Errorf("failed to check manifest existence: %w", err)
+			}
+
+			if exists {
+				fs, err = manifest.LoadFlagSet(manifestPath)
+				if err != nil {
 					return fmt.Errorf("failed to load manifest: %w", err)
 				}
+			} else {
+				// If manifest doesn't exist, create a new one
+				fs = &flagset.Flagset{
+					Flags: []flagset.Flag{},
+				}
 			}
 
 			// Check if flag already exists
@@ -105,6 +114,11 @@ Examples:
 			logger.Default.Debug(fmt.Sprintf("Added flag: name=%s, type=%s, defaultValue=%v, description=%s",
 				flagName, flagType, defaultValue, description))
 
+			// Display all current flags
+			displayFlagList(fs, manifestPath)
+			pterm.Println("Use the 'generate' command to update type-safe clients with the new flag.")
+			pterm.Println()
+
 			return nil
 		},
 	}
@@ -169,4 +183,4 @@ func parseDefaultValue(value string, flagType flagset.FlagType) (interface{}, er
 	default:
 		return nil, fmt.Errorf("unsupported flag type: %v", flagType)
 	}
-}
+}

internal/cmd/manifest_add_test.go

@@ -1,11 +1,13 @@
 package cmd
 
 import (
+	"bytes"
 	"encoding/json"
 	"testing"
 
 	"github.com/open-feature/cli/internal/config"
 	"github.com/open-feature/cli/internal/filesystem"
+	"github.com/pterm/pterm"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -360,4 +362,68 @@ func TestManifestAddCmd_CreateNewManifest(t *testing.T) {
 	assert.Equal(t, "boolean", flag["flagType"])
 	assert.Equal(t, true, flag["defaultValue"])
 	assert.Equal(t, "The first flag in a new manifest", flag["description"])
-}
+}
+
+func TestManifestAddCmd_DisplaysListAfterAdd(t *testing.T) {
+	// Setup
+	fs := afero.NewMemMapFs()
+	filesystem.SetFileSystem(fs)
+
+	// Create existing manifest with one flag
+	existingManifest := `{
+		"$schema": "https://raw.githubusercontent.com/open-feature/cli/refs/heads/main/schema/v0/flag-manifest.json",
+		"flags": {
+			"existing-flag": {
+				"flagType": "string",
+				"defaultValue": "test",
+				"description": "An existing flag"
+			}
+		}
+	}`
+	err := afero.WriteFile(fs, "flags.json", []byte(existingManifest), 0644)
+	require.NoError(t, err)
+
+	// Enable pterm output and capture it
+	pterm.EnableOutput()
+	defer pterm.DisableOutput()
+
+	buf := &bytes.Buffer{}
+	oldStdout := pterm.DefaultTable.Writer
+	oldSection := pterm.DefaultSection.Writer
+	oldInfo := pterm.Info.Writer
+	oldSuccess := pterm.Success.Writer
+	pterm.DefaultTable.Writer = buf
+	pterm.DefaultSection.Writer = buf
+	pterm.Info.Writer = buf
+	pterm.Success.Writer = buf
+	defer func() {
+		pterm.DefaultTable.Writer = oldStdout
+		pterm.DefaultSection.Writer = oldSection
+		pterm.Info.Writer = oldInfo
+		pterm.Success.Writer = oldSuccess
+	}()
+
+	// Create command and execute
+	cmd := GetManifestCmd()
+	config.AddRootFlags(cmd)
+
+	cmd.SetArgs([]string{
+		"add", "new-flag",
+		"--default-value", "true",
+		"--description", "A new flag",
+		"-m", "flags.json",
+	})
+
+	// Execute command
+	err = cmd.Execute()
+	require.NoError(t, err)
+
+	// Validate output contains list of all flags
+	output := buf.String()
+	assert.Contains(t, output, "existing-flag", "Output should contain existing flag")
+	assert.Contains(t, output, "new-flag", "Output should contain newly added flag")
+	assert.Contains(t, output, "(2)", "Output should show total count of 2 flags")
+	assert.Contains(t, output, "string", "Output should show flag types")
+	assert.Contains(t, output, "boolean", "Output should show flag types")
+}
+

internal/cmd/manifest_list.go

@@ -0,0 +1,106 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/open-feature/cli/internal/config"
+	"github.com/open-feature/cli/internal/flagset"
+	"github.com/open-feature/cli/internal/manifest"
+	"github.com/pterm/pterm"
+	"github.com/spf13/cobra"
+)
+
+func GetManifestListCmd() *cobra.Command {
+	manifestListCmd := &cobra.Command{
+		Use:   "list",
+		Short: "List all flags in the manifest",
+		Long:  `Display all flags defined in the manifest file with their configuration.`,
+		Args:  cobra.NoArgs,
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			return initializeConfig(cmd, "manifest.list")
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			manifestPath := config.GetManifestPath(cmd)
+
+			// Load existing manifest
+			fs, err := manifest.LoadFlagSet(manifestPath)
+			if err != nil {
+				return fmt.Errorf("failed to load manifest: %w", err)
+			}
+
+			displayFlagList(fs, manifestPath)
+			return nil
+		},
+	}
+
+	// Add command-specific flags
+	config.AddManifestListFlags(manifestListCmd)
+	addStabilityInfo(manifestListCmd)
+
+	return manifestListCmd
+}
+
+// displayFlagList prints a formatted table of all flags in the flagset
+func displayFlagList(fs *flagset.Flagset, manifestPath string) {
+	if len(fs.Flags) == 0 {
+		pterm.Info.Println("No flags found in manifest")
+		return
+	}
+
+	// Print header
+	pterm.DefaultSection.Println(fmt.Sprintf("Flags in %s (%d)", manifestPath, len(fs.Flags)))
+
+	// Create table data
+	tableData := pterm.TableData{
+		{"Key", "Type", "Default Value", "Description"},
+	}
+
+	for _, flag := range fs.Flags {
+		// Format default value for display
+		defaultValueStr := formatValue(flag.DefaultValue)
+
+		// Truncate description if too long
+		description := flag.Description
+		const maxDescriptionLength = 50
+
+		if len(description) > maxDescriptionLength {
+			description = description[:maxDescriptionLength-3] + "..."
+		}
+
+		tableData = append(tableData, []string{
+			flag.Key,
+			flag.Type.String(),
+			defaultValueStr,
+			description,
+		})
+	}
+
+	// Render table
+	pterm.DefaultTable.WithHasHeader().WithData(tableData).Render()
+}
+
+// formatValue converts a value to a string representation suitable for display
+func formatValue(value interface{}) string {
+	switch v := value.(type) {
+	case string:
+		if len(v) > 30 {
+			return fmt.Sprintf("\"%s...\"", v[:27])
+		}
+		return fmt.Sprintf("\"%s\"", v)
+	case bool, int, float64:
+		return fmt.Sprintf("%v", v)
+	case map[string]interface{}, []interface{}:
+		jsonBytes, err := json.Marshal(v)
+		if err != nil {
+			return fmt.Sprintf("%v", v)
+		}
+		jsonStr := string(jsonBytes)
+		if len(jsonStr) > 30 {
+			return jsonStr[:27] + "..."
+		}
+		return jsonStr
+	default:
+		return fmt.Sprintf("%v", v)
+	}
+}