func TestParseOutputFormat(t *testing.T) {
	tests := []struct {
		in      string
		want    OutputFormat
		wantErr bool
	}{
		{"", OutputTable, false},
		{"wide", OutputWide, false},
		{"json", OutputJSON, false},
		{"yaml", OutputYAML, false},
		{"JSON", OutputJSON, false}, // case-insensitive
		{"name", "", true},
		{"xml", "", true},
	}
	for _, tt := range tests {
		got, err := ParseOutputFormat(tt.in)
		if (err != nil) != tt.wantErr {
			t.Errorf("ParseOutputFormat(%q) err=%v, wantErr=%v", tt.in, err, tt.wantErr)
		}
		if err == nil && got != tt.want {
			t.Errorf("ParseOutputFormat(%q)=%q, want %q", tt.in, got, tt.want)
		}
	}
}

func TestEncode(t *testing.T) {
	items := []map[string]string{{"name": "a"}, {"name": "b"}}

	j, err := encode(OutputJSON, items)
	if err != nil {
		t.Fatal(err)
	}
	var back []map[string]string
	if err := json.Unmarshal(j, &back); err != nil {
		t.Fatalf("json did not round-trip: %v\n%s", err, j)
	}
	if len(back) != 2 || back[0]["name"] != "a" {
		t.Fatalf("unexpected json: %s", j)
	}

	y, err := encode(OutputYAML, items)
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(string(y), "name: a") {
		t.Fatalf("unexpected yaml: %s", y)
	}
}

// OutputFormat is the validated value of the -o/--output flag.
type OutputFormat string

const (
	OutputTable OutputFormat = ""     // default human table
	OutputWide  OutputFormat = "wide" // table + extra columns
	OutputJSON  OutputFormat = "json"
	OutputYAML  OutputFormat = "yaml"
)

// ParseOutputFormat validates the -o value (empty is allowed and means table).
func ParseOutputFormat(s string) (OutputFormat, error) {
	switch f := OutputFormat(strings.ToLower(s)); f {
	case OutputTable, OutputWide, OutputJSON, OutputYAML:
		return f, nil
	default:
		return "", fmt.Errorf("invalid output format %q: valid values are wide, json, yaml", s)
	}
}

// encode marshals v as JSON or YAML. It is the structured half of the printer,
// kept pure (no stdout) so it is straightforward to unit test.
func encode(format OutputFormat, v any) ([]byte, error) {
	switch format {
	case OutputJSON:
		return json.MarshalIndent(v, "", "  ")
	case OutputYAML:
		return yaml.Marshal(v)
	default:
		return nil, fmt.Errorf("encode called with non-structured format %q", format)
	}
}

gofmt -w pkg/fission-cli/util/output.go pkg/fission-cli/util/output_test.go
git add pkg/fission-cli/util/output.go pkg/fission-cli/util/output_test.go
git commit -m "fission-cli/util: add OutputFormat parsing + structured encoder"

func TestPrintObjectsTableAndWide(t *testing.T) {
	type row struct{ name, ready, age string }
	items := []row{{"a", "True", "5m"}, {"b", "<none>", "1h"}}
	hdr := []string{"NAME", "READY"}
	rowFn := func(r row) []string { return []string{r.name, r.ready} }
	wideHdr := []string{"AGE"}
	wideFn := func(r row) []string { return []string{r.age} }

	// table: no AGE column
	out := captureStdout(t, func() error { return PrintObjects(OutputTable, items, hdr, rowFn, wideHdr, wideFn) })
	if strings.Contains(out, "AGE") {
		t.Errorf("table output must not include wide columns:\n%s", out)
	}
	if !strings.Contains(out, "NAME") || !strings.Contains(out, "a") {
		t.Errorf("table missing base columns:\n%s", out)
	}

	// wide: AGE present
	out = captureStdout(t, func() error { return PrintObjects(OutputWide, items, hdr, rowFn, wideHdr, wideFn) })
	if !strings.Contains(out, "AGE") || !strings.Contains(out, "5m") {
		t.Errorf("wide output missing AGE:\n%s", out)
	}

	// json: array round-trips
	out = captureStdout(t, func() error { return PrintObjects(OutputJSON, items, hdr, rowFn, wideHdr, wideFn) })
	var back []row // unexported fields won't unmarshal; just assert it's a JSON array
	_ = back
	if !strings.HasPrefix(strings.TrimSpace(out), "[") {
		t.Errorf("json output should be an array:\n%s", out)
	}
}

func TestPrintStructured(t *testing.T) {
	obj := map[string]string{"name": "hello"}

	// table/wide: not handled, no output
	out := captureStdout(t, func() error {
		handled, err := PrintStructured(OutputTable, obj)
		if handled {
			t.Error("table must not be handled by PrintStructured")
		}
		return err
	})
	if out != "" {
		t.Errorf("expected no output for table, got %q", out)
	}

	// yaml: handled, prints
	out = captureStdout(t, func() error {
		handled, err := PrintStructured(OutputYAML, obj)
		if !handled {
			t.Error("yaml must be handled")
		}
		return err
	})
	if !strings.Contains(out, "name: hello") {
		t.Errorf("yaml not printed:\n%s", out)
	}
}

// captureStdout runs fn with os.Stdout redirected to a pipe and returns what it wrote.
func captureStdout(t *testing.T, fn func() error) string {
	t.Helper()
	r, w, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	defer r.Close()
	orig := os.Stdout
	t.Cleanup(func() { os.Stdout = orig })
	os.Stdout = w
	if err := fn(); err != nil {
		t.Fatalf("fn returned error: %v", err)
	}
	w.Close()
	var buf bytes.Buffer
	if _, err := buf.ReadFrom(r); err != nil {
		t.Fatal(err)
	}
	return buf.String()
}

// PrintObjects renders a slice of items in the requested format. For json/yaml
// it marshals items (a JSON array / YAML sequence). For table it uses
// headers+row; for wide it appends wideExtra columns (e.g. AGE) after the base
// columns. It is the single entry point for the list commands.
func PrintObjects[T any](format OutputFormat, items []T, headers []string, row func(T) []string, wideExtra []string, wideRow func(T) []string) error {
	switch format {
	case OutputJSON, OutputYAML:
		b, err := encode(format, items)
		if err != nil {
			return err
		}
		fmt.Println(string(b))
		return nil
	case OutputWide:
		hdr := append(append([]string{}, headers...), wideExtra...)
		PrintItems(hdr, items, func(t T) []string {
			return append(row(t), wideRow(t)...)
		})
		return nil
	default: // OutputTable
		PrintItems(headers, items, row)
		return nil
	}
}

// PrintStructured prints v as json/yaml and returns true when the format is
// structured; for table/wide it prints nothing and returns false so describe
// commands fall back to their own human rendering.
func PrintStructured(format OutputFormat, v any) (bool, error) {
	switch format {
	case OutputJSON, OutputYAML:
		b, err := encode(format, v)
		if err != nil {
			return true, err
		}
		fmt.Println(string(b))
		return true, nil
	default:
		return false, nil
	}
}

gofmt -w pkg/fission-cli/util/output.go pkg/fission-cli/util/output_test.go
git add pkg/fission-cli/util/output.go pkg/fission-cli/util/output_test.go
git commit -m "fission-cli/util: add PrintObjects + PrintStructured format-aware printers"

Output = Flag{Type: String, Name: flagkey.Output, Short: "o", Usage: "Output format: wide, json or yaml (default: table)"}

git add pkg/fission-cli/flag/key/key.go pkg/fission-cli/flag/flag.go
git commit -m "fission-cli/flag: add --output/-o format flag for read commands"

}, List, flag.FlagSet{
	Optional: []flag.Flag{flag.NamespaceFunction, flag.AllNamespaces, flag.Output},
})

func TestFunctionListJSON(t *testing.T) {
	// arrange: a fake clientset with one function, wired via cmd.SetClientset,
	// and a dummy CLI input with output=json (see create_test.go for the helper).
	input := dummy.TestFlagSet()
	input.Set(flagkey.Output, "json")
	out := captureStdout(t, func() error { return List(input) })
	if !strings.HasPrefix(strings.TrimSpace(out), "[") {
		t.Errorf("expected JSON array, got:\n%s", out)
	}
}

format, err := util.ParseOutputFormat(input.String(flagkey.Output))
if err != nil {
	return err
}

headers := []string{"NAME", "ENV", "EXECUTORTYPE", "MINSCALE", "MAXSCALE", "MINCPU", "MAXCPU", "MINMEMORY", "MAXMEMORY", "SECRETS", "CONFIGMAPS", "READY", "NAMESPACE"}
wideExtra := []string{"AGE"}
row := func(f fv1.Function) []string {
	var secretsList, configMapList []string
	for _, secret := range f.Spec.Secrets {
		secretsList = append(secretsList, secret.Name)
	}
	for _, configMap := range f.Spec.ConfigMaps {
		configMapList = append(configMapList, configMap.Name)
	}
	return []string{
		f.Name, f.Spec.Environment.Name,
		string(f.Spec.InvokeStrategy.ExecutionStrategy.ExecutorType),
		fmt.Sprintf("%v", f.Spec.InvokeStrategy.ExecutionStrategy.MinScale),
		fmt.Sprintf("%v", f.Spec.InvokeStrategy.ExecutionStrategy.MaxScale),
		f.Spec.Resources.Requests.Cpu().String(),
		f.Spec.Resources.Limits.Cpu().String(),
		f.Spec.Resources.Requests.Memory().String(),
		f.Spec.Resources.Limits.Memory().String(),
		strings.Join(secretsList, ","),
		strings.Join(configMapList, ","),
		util.ConditionStatus(f.Status.Conditions, fv1.FunctionConditionReady),
		f.Namespace,
	}
}
wideRow := func(f fv1.Function) []string {
	return []string{util.AgeOf(f.CreationTimestamp)}
}
return util.PrintObjects(format, fns.Items, headers, row, wideExtra, wideRow)

// AgeOf renders an object's age from its creation timestamp, kubectl-style.
func AgeOf(t metav1.Time) string {
	if t.IsZero() {
		return NoneValue
	}
	return duration.HumanDuration(time.Since(t.Time))
}

gofmt -w pkg/fission-cli/cmd/function/list.go pkg/fission-cli/util/output.go
git add pkg/fission-cli/cmd/function/ pkg/fission-cli/util/output.go
git commit -m "fission-cli: -o json|yaml|wide for function list"

format, err := util.ParseOutputFormat(input.String(flagkey.Output))
if err != nil {
	return err
}
if handled, err := util.PrintStructured(format, obj); err != nil || handled {
	return err
}
// ... existing human rendering ...

gofmt -l pkg/fission-cli/    # expect no output
golangci-lint run ./pkg/fission-cli/...   # 0 issues
go test ./pkg/fission-cli/... ./cmd/fission-cli/...   # all pass (incl. app command-tree test, which now sees flag.Output)
go build ./...

go build -o /tmp/fission ./cmd/fission-cli
/tmp/fission fn list                  # unchanged table (READY column present)
/tmp/fission fn list -o wide          # adds AGE column
/tmp/fission fn list -o json | jq '.[].metadata.name'
/tmp/fission fn list -o yaml | head
/tmp/fission fn list -o bogus         # errors: invalid output format "bogus": valid values are wide, json, yaml
/tmp/fission env list -o json | jq length
/tmp/fission pkg info --name <pkg> -o yaml
/tmp/fission fn getmeta --name <fn> -o json