Merge pull request #168 from githubnext/copilot/prettify-markdown-rendering

Author: pelikhan

internal/logger/rpc_logger.go

@@ -140,36 +140,46 @@ func formatRPCMessage(info *RPCMessageInfo) string {
 }
 
 // formatJSONWithoutFields formats JSON by removing specified fields and indenting with 2 spaces
-// Returns the formatted string and a boolean indicating if the JSON was valid
-func formatJSONWithoutFields(jsonStr string, fieldsToRemove []string) (string, bool) {
+// Returns the formatted string, a boolean indicating if the JSON was valid, and a boolean indicating if empty
+func formatJSONWithoutFields(jsonStr string, fieldsToRemove []string) (string, bool, bool) {
 	var data map[string]interface{}
 	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
 		// If not valid JSON, return as-is with false
-		return jsonStr, false
+		return jsonStr, false, false
 	}
 
 	// Remove specified fields
 	for _, field := range fieldsToRemove {
 		delete(data, field)
 	}
 
-	// Re-marshal with 2-space indentation
+	// Check if only "params": null remains (or equivalent empty state)
+	isEmpty := isEffectivelyEmpty(data)
+
+	// Re-marshal with 2-space indentation (pretty print)
 	formatted, err := json.MarshalIndent(data, "", "  ")
 	if err != nil {
-		return jsonStr, false
+		return jsonStr, false, false
+	}
+
+	return string(formatted), true, isEmpty
+}
+
+// isEffectivelyEmpty checks if the data is effectively empty (only contains params: null)
+func isEffectivelyEmpty(data map[string]interface{}) bool {
+	// If empty, it's empty
+	if len(data) == 0 {
+		return true
 	}
 
-	// Compress JSON: remove newline after opening brace and before closing brace
-	result := string(formatted)
-	// Remove newline after opening brace
-	result = strings.Replace(result, "{\n", "{ ", 1)
-	// Remove newline before closing brace
-	lastNewline := strings.LastIndex(result, "\n}")
-	if lastNewline != -1 {
-		result = result[:lastNewline] + " }"
+	// If only one field and it's "params" with null value, it's empty
+	if len(data) == 1 {
+		if params, ok := data["params"]; ok && params == nil {
+			return true
+		}
 	}
 
-	return result, true
+	return false
 }
 
 // formatRPCMessageMarkdown formats an RPC message for markdown logging
@@ -196,11 +206,14 @@ func formatRPCMessageMarkdown(info *RPCMessageInfo) string {
 	// Add formatted payload in code block
 	if info.Payload != "" {
 		// Remove jsonrpc and method fields, then format
-		formatted, isValidJSON := formatJSONWithoutFields(info.Payload, []string{"jsonrpc", "method"})
+		formatted, isValidJSON, isEmpty := formatJSONWithoutFields(info.Payload, []string{"jsonrpc", "method"})
 		if isValidJSON {
-			// Valid JSON: use code block for better readability (compact formatting)
-			// Empty line before ~~~ per markdown convention
-			message += fmt.Sprintf(" \n\n~~~\n%s\n~~~", formatted)
+			// Don't show JSON block if it's effectively empty (only params: null)
+			if !isEmpty {
+				// Valid JSON: use code block for better readability (pretty printed)
+				// Empty line before ~~~ per markdown convention
+				message += fmt.Sprintf(" \n\n~~~\n%s\n~~~", formatted)
+			}
 		} else {
 			// Invalid JSON: use inline backticks to avoid malformed markdown
 			message += fmt.Sprintf(" `%s`", formatted)

internal/logger/rpc_logger_test.go

@@ -234,6 +234,32 @@ func TestFormatRPCMessageMarkdown(t *testing.T) {
 			want:    []string{"**github**→`tools/call`", "`{invalid json syntax}`"},
 			notWant: []string{"~~~"}, // Should NOT use code blocks for invalid JSON
 		},
+		{
+			name: "request with only params null after field removal",
+			info: &RPCMessageInfo{
+				Direction:   RPCDirectionOutbound,
+				MessageType: RPCMessageRequest,
+				ServerID:    "github",
+				Method:      "tools/list",
+				PayloadSize: 50,
+				Payload:     `{"jsonrpc":"2.0","method":"tools/list","params":null}`,
+			},
+			want:    []string{"**github**→`tools/list`"},
+			notWant: []string{"~~~", `"params"`}, // Should NOT show JSON block when only params: null
+		},
+		{
+			name: "request with empty object after field removal",
+			info: &RPCMessageInfo{
+				Direction:   RPCDirectionOutbound,
+				MessageType: RPCMessageRequest,
+				ServerID:    "github",
+				Method:      "tools/list",
+				PayloadSize: 50,
+				Payload:     `{"jsonrpc":"2.0","method":"tools/list"}`,
+			},
+			want:    []string{"**github**→`tools/list`"},
+			notWant: []string{"~~~"}, // Should NOT show JSON block when empty
+		},
 	}
 
 	for _, tt := range tests {
@@ -263,6 +289,7 @@ func TestFormatJSONWithoutFields(t *testing.T) {
 		wantContains   []string
 		wantNotContain []string
 		wantValid      bool
+		wantEmpty      bool
 	}{
 		{
 			name:           "remove jsonrpc and method",
@@ -271,6 +298,7 @@ func TestFormatJSONWithoutFields(t *testing.T) {
 			wantContains:   []string{`"params"`, `"arg"`, `"value"`, `"id"`},
 			wantNotContain: []string{`"jsonrpc"`, `"method"`},
 			wantValid:      true,
+			wantEmpty:      false,
 		},
 		{
 			name:           "indent with 2 spaces",
@@ -279,6 +307,7 @@ func TestFormatJSONWithoutFields(t *testing.T) {
 			wantContains:   []string{"  \"a\"", "  \"c\"", "    \"d\""},
 			wantNotContain: []string{},
 			wantValid:      true,
+			wantEmpty:      false,
 		},
 		{
 			name:           "invalid JSON returns as-is with false",
@@ -287,6 +316,7 @@ func TestFormatJSONWithoutFields(t *testing.T) {
 			wantContains:   []string{`{invalid json}`},
 			wantNotContain: []string{},
 			wantValid:      false,
+			wantEmpty:      false,
 		},
 		{
 			name:           "empty object",
@@ -295,17 +325,40 @@ func TestFormatJSONWithoutFields(t *testing.T) {
 			wantContains:   []string{`{}`},
 			wantNotContain: []string{},
 			wantValid:      true,
+			wantEmpty:      true,
+		},
+		{
+			name:           "only params null after removal",
+			input:          `{"jsonrpc":"2.0","method":"tools/list","params":null}`,
+			fieldsToRemove: []string{"jsonrpc", "method"},
+			wantContains:   []string{`"params"`, `null`},
+			wantNotContain: []string{},
+			wantValid:      true,
+			wantEmpty:      true,
+		},
+		{
+			name:           "params with value is not empty",
+			input:          `{"jsonrpc":"2.0","method":"tools/list","params":{"key":"value"}}`,
+			fieldsToRemove: []string{"jsonrpc", "method"},
+			wantContains:   []string{`"params"`},
+			wantNotContain: []string{},
+			wantValid:      true,
+			wantEmpty:      false,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, isValid := formatJSONWithoutFields(tt.input, tt.fieldsToRemove)
+			result, isValid, isEmpty := formatJSONWithoutFields(tt.input, tt.fieldsToRemove)
 
 			if isValid != tt.wantValid {
 				t.Errorf("Expected isValid=%v, got %v", tt.wantValid, isValid)
 			}
 
+			if isEmpty != tt.wantEmpty {
+				t.Errorf("Expected isEmpty=%v, got %v", tt.wantEmpty, isEmpty)
+			}
+
 			for _, want := range tt.wantContains {
 				if !strings.Contains(result, want) {
 					t.Errorf("Expected result to contain %q, got:\n%s", want, result)