feat(REL-15756): updating agent friendly and improved rich text output

cmd/flags/archive.go

@@ -51,7 +51,9 @@ func makeArchiveRequest(client resources.Client) func(*cobra.Command, []string)
 			return output.NewCmdOutputError(err, cliflags.GetOutputKind(cmd))
 		}
 
-		output, err := output.CmdOutput("update", cliflags.GetOutputKind(cmd), res, cliflags.GetFields(cmd))
+		output, err := output.CmdOutput("update", cliflags.GetOutputKind(cmd), res, cliflags.GetFields(cmd), output.CmdOutputOpts{
+			ResourceName: "flags",
+		})
 		if err != nil {
 			return errors.NewError(err.Error())
 		}

cmd/flags/archive_test.go

@@ -39,7 +39,11 @@ func TestArchive(t *testing.T) {
 
 		require.NoError(t, err)
 		assert.Equal(t, `[{"op": "replace", "path": "/archived", "value": true}]`, string(mockClient.Input))
-		assert.Equal(t, "Successfully updated test flag (test-flag)\n", string(output))
+		assert.Contains(t, string(output), "Successfully updated\n\nKey:")
+		assert.Contains(t, string(output), "test-flag")
+		assert.Contains(t, string(output), "Name:")
+		assert.Contains(t, string(output), "test flag")
+		assert.NotContains(t, string(output), "* ")
 	})
 
 	t.Run("succeeds with JSON output", func(t *testing.T) {
@@ -146,7 +150,9 @@ func TestArchive(t *testing.T) {
 		)
 
 		require.NoError(t, err)
-		assert.Equal(t, "Successfully updated test flag (test-flag)\n", string(output))
+		assert.Contains(t, string(output), "Successfully updated")
+		assert.Contains(t, string(output), "Key:")
+		assert.Contains(t, string(output), "test-flag")
 	})
 
 	t.Run("returns error with missing flags", func(t *testing.T) {

cmd/flags/toggle.go

@@ -73,7 +73,9 @@ func runE(client resources.Client) func(*cobra.Command, []string) error {
 			return output.NewCmdOutputError(err, cliflags.GetOutputKind(cmd))
 		}
 
-		output, err := output.CmdOutput("update", cliflags.GetOutputKind(cmd), res, cliflags.GetFields(cmd))
+		output, err := output.CmdOutput("update", cliflags.GetOutputKind(cmd), res, cliflags.GetFields(cmd), output.CmdOutputOpts{
+			ResourceName: "flags",
+		})
 		if err != nil {
 			return errors.NewError(err.Error())
 		}

cmd/flags/toggle_test.go

@@ -40,7 +40,11 @@ func TestToggleOn(t *testing.T) {
 
 		require.NoError(t, err)
 		assert.Equal(t, `[{"op": "replace", "path": "/environments/test-env/on", "value": true}]`, string(mockClient.Input))
-		assert.Equal(t, "Successfully updated test flag (test-flag)\n", string(output))
+		assert.Contains(t, string(output), "Successfully updated\n\nKey:")
+		assert.Contains(t, string(output), "test-flag")
+		assert.Contains(t, string(output), "Name:")
+		assert.Contains(t, string(output), "test flag")
+		assert.NotContains(t, string(output), "* ")
 	})
 
 	t.Run("succeeds with JSON output", func(t *testing.T) {
@@ -152,7 +156,9 @@ func TestToggleOn(t *testing.T) {
 		)
 
 		require.NoError(t, err)
-		assert.Equal(t, "Successfully updated test flag (test-flag)\n", string(output))
+		assert.Contains(t, string(output), "Successfully updated")
+		assert.Contains(t, string(output), "Key:")
+		assert.Contains(t, string(output), "test-flag")
 	})
 
 	t.Run("returns error with missing required flags", func(t *testing.T) {
@@ -205,7 +211,11 @@ func TestToggleOff(t *testing.T) {
 
 		require.NoError(t, err)
 		assert.Equal(t, `[{"op": "replace", "path": "/environments/test-env/on", "value": false}]`, string(mockClient.Input))
-		assert.Equal(t, "Successfully updated test flag (test-flag)\n", string(output))
+		assert.Contains(t, string(output), "Successfully updated\n\nKey:")
+		assert.Contains(t, string(output), "test-flag")
+		assert.Contains(t, string(output), "Name:")
+		assert.Contains(t, string(output), "test flag")
+		assert.NotContains(t, string(output), "* ")
 	})
 
 	t.Run("succeeds with JSON output", func(t *testing.T) {
@@ -317,7 +327,9 @@ func TestToggleOff(t *testing.T) {
 		)
 
 		require.NoError(t, err)
-		assert.Equal(t, "Successfully updated test flag (test-flag)\n", string(output))
+		assert.Contains(t, string(output), "Successfully updated")
+		assert.Contains(t, string(output), "Key:")
+		assert.Contains(t, string(output), "test-flag")
 	})
 
 	t.Run("returns error with missing required flags", func(t *testing.T) {

cmd/members/invite.go

@@ -63,7 +63,9 @@ func runE(client resources.Client) func(*cobra.Command, []string) error {
 			return output.NewCmdOutputError(err, cliflags.GetOutputKind(cmd))
 		}
 
-		output, err := output.CmdOutput("update", cliflags.GetOutputKind(cmd), res, cliflags.GetFields(cmd))
+		output, err := output.CmdOutput("update", cliflags.GetOutputKind(cmd), res, cliflags.GetFields(cmd), output.CmdOutputOpts{
+			ResourceName: "members",
+		})
 		if err != nil {
 			return errors.NewError(err.Error())
 		}

cmd/members/invite_test.go

@@ -45,5 +45,11 @@ func TestInvite(t *testing.T) {
 
 	require.NoError(t, err)
 	assert.Equal(t, `[{"email":"test1@test.com","role":"writer"},{"email":"test2@test.com","role":"writer"}]`, string(mockClient.Input))
-	assert.Equal(t, "Successfully updated\n* test1@test.com (000000000000000000000001)\n* test2@test.com (000000000000000000000002)\n", string(output))
+	assert.Contains(t, string(output), "Successfully updated")
+	assert.Contains(t, string(output), "EMAIL")
+	assert.Contains(t, string(output), "ROLE")
+	assert.Contains(t, string(output), "test1@test.com")
+	assert.Contains(t, string(output), "test2@test.com")
+	assert.Contains(t, string(output), "writer")
+	assert.NotContains(t, string(output), "* ")
 }

cmd/resources/resources.go

@@ -349,7 +349,9 @@ func (op *OperationCmd) makeRequest(cmd *cobra.Command, args []string) error {
 		res = []byte(fmt.Sprintf(`{"key": %q}`, urlParms[len(urlParms)-1]))
 	}
 
-	output, err := output.CmdOutput(cmd.Use, cliflags.GetOutputKind(cmd), res, cliflags.GetFields(cmd))
+	output, err := output.CmdOutput(cmd.Use, cliflags.GetOutputKind(cmd), res, cliflags.GetFields(cmd), output.CmdOutputOpts{
+		ResourceName: cmd.Parent().Name(),
+	})
 	if err != nil {
 		return errors.NewError(err.Error())
 	}

cmd/root_test.go

@@ -101,8 +101,8 @@ func TestOutputFlags(t *testing.T) {
 		)
 
 		require.NoError(t, err)
-		assert.Contains(t, string(output), "Successfully updated")
-		assert.Contains(t, string(output), "test-name (test-key)")
+		assert.Contains(t, string(output), "Successfully updated\n\nKey:")
+		assert.Contains(t, string(output), "test-key")
 	})
 }
 
@@ -205,7 +205,8 @@ func TestTTYDefaultOutput(t *testing.T) {
 
 		out := execNonTTYCmd(t, mockClient)
 		assert.Contains(t, string(out), "Successfully updated")
-		assert.Contains(t, string(out), "test-name (test-key)")
+		assert.Contains(t, string(out), "Key:")
+		assert.Contains(t, string(out), "test-key")
 	})
 
 	t.Run("FORCE_TTY overrides non-TTY detection", func(t *testing.T) {

internal/output/plaintext_fns.go

@@ -62,19 +62,19 @@ var SingularPlaintextOutputFn = func(r resource) string {
 
 	switch {
 	case name != nil && key != nil:
-		return fmt.Sprintf("%s (%s)", name.(string), key.(string))
+		return fmt.Sprintf("%s (%s)", fmt.Sprint(name), fmt.Sprint(key))
 	case email != nil && id != nil:
-		return fmt.Sprintf("%s (%s)", email.(string), id.(string))
+		return fmt.Sprintf("%s (%s)", fmt.Sprint(email), fmt.Sprint(id))
 	case name != nil && id != nil:
-		return fmt.Sprintf("%s (%s)", name.(string), id.(string))
+		return fmt.Sprintf("%s (%s)", fmt.Sprint(name), fmt.Sprint(id))
 	case key != nil:
-		return key.(string)
+		return fmt.Sprint(key)
 	case email != nil:
-		return email.(string)
+		return fmt.Sprint(email)
 	case id != nil:
-		return id.(string)
+		return fmt.Sprint(id)
 	case name != nil:
-		return name.(string)
+		return fmt.Sprint(name)
 	default:
 		return "cannot read resource"
 	}

internal/output/plaintext_fns_internal_test.go

@@ -7,6 +7,54 @@ import (
 )
 
 func TestErrorPlaintextOutputFn(t *testing.T) {
+	t.Run("with code and message", func(t *testing.T) {
+		r := resource{"code": "conflict", "message": "resource already exists"}
+
+		result := ErrorPlaintextOutputFn(r)
+
+		assert.Equal(t, "resource already exists (code: conflict)", result)
+	})
+
+	t.Run("with only a message", func(t *testing.T) {
+		r := resource{"message": "something went wrong"}
+
+		result := ErrorPlaintextOutputFn(r)
+
+		assert.Equal(t, "something went wrong", result)
+	})
+
+	t.Run("with only a code", func(t *testing.T) {
+		r := resource{"code": "not_found", "message": ""}
+
+		result := ErrorPlaintextOutputFn(r)
+
+		assert.Equal(t, "an error occurred (code: not_found)", result)
+	})
+
+	t.Run("with neither code nor message", func(t *testing.T) {
+		r := resource{}
+
+		result := ErrorPlaintextOutputFn(r)
+
+		assert.Equal(t, "unknown error occurred", result)
+	})
+
+	t.Run("with empty message and nil code", func(t *testing.T) {
+		r := resource{"message": ""}
+
+		result := ErrorPlaintextOutputFn(r)
+
+		assert.Equal(t, "unknown error occurred", result)
+	})
+
+	t.Run("with suggestion appends suggestion line", func(t *testing.T) {
+		r := resource{"code": "not_found", "message": "Not Found", "suggestion": "Try ldcli flags list."}
+
+		result := ErrorPlaintextOutputFn(r)
+
+		assert.Equal(t, "Not Found (code: not_found)\nSuggestion: Try ldcli flags list.", result)
+	})
+
 	t.Run("with a non-string message does not panic", func(t *testing.T) {
 		r := resource{"message": float64(404)}
 
@@ -32,6 +80,91 @@ func TestErrorPlaintextOutputFn(t *testing.T) {
 	})
 }
 
+func TestMultiplePlaintextOutputFn(t *testing.T) {
+	tests := map[string]struct {
+		resource resource
+		expected string
+	}{
+		"with a name and key": {
+			resource: resource{
+				"key":  "test-key",
+				"name": "test-name",
+			},
+			expected: "* test-name (test-key)",
+		},
+		"with only a key": {
+			resource: resource{
+				"key": "test-key",
+			},
+			expected: "* test-key",
+		},
+		"with an email and ID": {
+			resource: resource{
+				"_id":   "test-id",
+				"email": "test-email",
+			},
+			expected: "* test-email (test-id)",
+		},
+		"without any valid field": {
+			resource: resource{
+				"other": "other-value",
+			},
+			expected: "* cannot read resource",
+		},
+	}
+
+	for name, tt := range tests {
+		tt := tt
+		t.Run(name, func(t *testing.T) {
+			out := MultiplePlaintextOutputFn(tt.resource)
+
+			assert.Equal(t, tt.expected, out)
+		})
+	}
+}
+
+func TestConfigPlaintextOutputFn(t *testing.T) {
+	tests := map[string]struct {
+		resource resource
+		expected string
+	}{
+		"with multiple keys sorts alphabetically": {
+			resource: resource{
+				"zeta":  "last",
+				"alpha": "first",
+				"mid":   "middle",
+			},
+			expected: "alpha: first\nmid: middle\nzeta: last",
+		},
+		"with single key": {
+			resource: resource{
+				"key": "value",
+			},
+			expected: "key: value",
+		},
+		"with empty resource": {
+			resource: resource{},
+			expected: "",
+		},
+		"with non-string values": {
+			resource: resource{
+				"count":   float64(42),
+				"enabled": true,
+			},
+			expected: "count: 42\nenabled: true",
+		},
+	}
+
+	for name, tt := range tests {
+		tt := tt
+		t.Run(name, func(t *testing.T) {
+			out := ConfigPlaintextOutputFn(tt.resource)
+
+			assert.Equal(t, tt.expected, out)
+		})
+	}
+}
+
 func TestSingularPlaintextOutputFn(t *testing.T) {
 	tests := map[string]struct {
 		resource resource
@@ -77,6 +210,32 @@ func TestSingularPlaintextOutputFn(t *testing.T) {
 			},
 			expected: "cannot read resource",
 		},
+		"with non-string name and key does not panic": {
+			resource: resource{
+				"key":  float64(123),
+				"name": true,
+			},
+			expected: "true (123)",
+		},
+		"with non-string email and id does not panic": {
+			resource: resource{
+				"_id":   float64(999),
+				"email": float64(42),
+			},
+			expected: "42 (999)",
+		},
+		"with non-string key only does not panic": {
+			resource: resource{
+				"key": float64(456),
+			},
+			expected: "456",
+		},
+		"with non-string name only does not panic": {
+			resource: resource{
+				"name": float64(789),
+			},
+			expected: "789",
+		},
 	}
 
 	for name, tt := range tests {