Fix SonarQube high-severity issues: string duplication and cognitive complexity

- Fixed string literal duplication in pkg/github/search.go
  * Added constants for 'failed to read response body: %w' and 'failed to marshal response: %w'
  * Replaced 4 duplicate occurrences with constant references

- Reduced cognitive complexity in cmd/mcpcurl/main.go
  * Refactored main() function from complexity 18 to under 15
  * Extracted schema loading logic into loadSchemaAndGenerateCommands() function

- Reduced cognitive complexity in pkg/github/pullrequests.go
  * Refactored GetPullRequestFiles handler from complexity 19 to under 15
  * Extracted parameter handling into getPullRequestFilesHandler() function
  * Extracted API call logic into fetchAndMarshalPullRequestFiles() function

All tests pass and linting is clean.

Co-Authored-By: Eashan Sinha <eashan.sinha@codeium.com>

Author: devin-ai-integration[bot]

cmd/mcpcurl/main.go

@@ -168,37 +168,59 @@ func main() {
 	// Execute the root command once to parse flags
 	_ = rootCmd.ParseFlags(os.Args[1:])
 
+	// Load schema and generate tool commands
+	if err := loadSchemaAndGenerateCommands(); err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "Warning: failed to load schema: %v\n", err)
+	}
+
+	// Execute
+	if err := rootCmd.Execute(); err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "Error executing command: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+// loadSchemaAndGenerateCommands fetches the schema from the server and generates tool commands
+func loadSchemaAndGenerateCommands() error {
 	// Get pretty flag
 	prettyPrint, err := rootCmd.Flags().GetBool("pretty")
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "Error getting pretty flag: %v\n", err)
-		os.Exit(1)
+		return fmt.Errorf("failed to get pretty flag: %w", err)
 	}
+
 	// Get server command
 	serverCmd, err := rootCmd.Flags().GetString("stdio-server-cmd")
-	if err == nil && serverCmd != "" {
-		// Fetch schema from server
-		jsonRequest, err := buildJSONRPCRequest("tools/list", "", nil)
-		if err == nil {
-			response, err := executeServerCommand(serverCmd, jsonRequest)
-			if err == nil {
-				// Parse the schema response
-				var schemaResp SchemaResponse
-				if err := json.Unmarshal([]byte(response), &schemaResp); err == nil {
-					// Add all the generated commands as subcommands of tools
-					for _, tool := range schemaResp.Result.Tools {
-						addCommandFromTool(toolsCmd, &tool, prettyPrint)
-					}
-				}
-			}
-		}
+	if err != nil {
+		return fmt.Errorf("failed to get stdio-server-cmd: %w", err)
 	}
 
-	// Execute
-	if err := rootCmd.Execute(); err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "Error executing command: %v\n", err)
-		os.Exit(1)
+	if serverCmd == "" {
+		return nil // No server command provided
 	}
+
+	// Fetch schema from server
+	jsonRequest, err := buildJSONRPCRequest("tools/list", "", nil)
+	if err != nil {
+		return fmt.Errorf("failed to build JSON-RPC request: %w", err)
+	}
+
+	response, err := executeServerCommand(serverCmd, jsonRequest)
+	if err != nil {
+		return fmt.Errorf("failed to execute server command: %w", err)
+	}
+
+	// Parse the schema response
+	var schemaResp SchemaResponse
+	if err := json.Unmarshal([]byte(response), &schemaResp); err != nil {
+		return fmt.Errorf("failed to unmarshal schema response: %w", err)
+	}
+
+	// Add all the generated commands as subcommands of tools
+	for _, tool := range schemaResp.Result.Tools {
+		addCommandFromTool(toolsCmd, &tool, prettyPrint)
+	}
+
+	return nil
 }
 
 // addCommandFromTool creates a cobra command from a tool schema

pkg/github/pullrequests.go

@@ -601,56 +601,65 @@ func GetPullRequestFiles(getClient GetClientFn, t translations.TranslationHelper
 			WithPagination(),
 		),
 		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-			owner, err := RequiredParam[string](request, "owner")
-			if err != nil {
-				return mcp.NewToolResultError(err.Error()), nil
-			}
-			repo, err := RequiredParam[string](request, "repo")
-			if err != nil {
-				return mcp.NewToolResultError(err.Error()), nil
-			}
-			pullNumber, err := RequiredInt(request, "pullNumber")
-			if err != nil {
-				return mcp.NewToolResultError(err.Error()), nil
-			}
-			pagination, err := OptionalPaginationParams(request)
-			if err != nil {
-				return mcp.NewToolResultError(err.Error()), nil
-			}
+			return getPullRequestFilesHandler(ctx, getClient, request)
+		}
+}
 
-			client, err := getClient(ctx)
-			if err != nil {
-				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
-			}
-			opts := &github.ListOptions{
-				PerPage: pagination.perPage,
-				Page:    pagination.page,
-			}
-			files, resp, err := client.PullRequests.ListFiles(ctx, owner, repo, pullNumber, opts)
-			if err != nil {
-				return ghErrors.NewGitHubAPIErrorResponse(ctx,
-					"failed to get pull request files",
-					resp,
-					err,
-				), nil
-			}
-			defer func() { _ = resp.Body.Close() }()
+func getPullRequestFilesHandler(ctx context.Context, getClient GetClientFn, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	owner, err := RequiredParam[string](request, "owner")
+	if err != nil {
+		return mcp.NewToolResultError(err.Error()), nil
+	}
+	repo, err := RequiredParam[string](request, "repo")
+	if err != nil {
+		return mcp.NewToolResultError(err.Error()), nil
+	}
+	pullNumber, err := RequiredInt(request, "pullNumber")
+	if err != nil {
+		return mcp.NewToolResultError(err.Error()), nil
+	}
+	pagination, err := OptionalPaginationParams(request)
+	if err != nil {
+		return mcp.NewToolResultError(err.Error()), nil
+	}
 
-			if resp.StatusCode != http.StatusOK {
-				body, err := io.ReadAll(resp.Body)
-				if err != nil {
-					return nil, fmt.Errorf("failed to read response body: %w", err)
-				}
-				return mcp.NewToolResultError(fmt.Sprintf("failed to get pull request files: %s", string(body))), nil
-			}
+	client, err := getClient(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get GitHub client: %w", err)
+	}
 
-			r, err := json.Marshal(files)
-			if err != nil {
-				return nil, fmt.Errorf("failed to marshal response: %w", err)
-			}
+	return fetchAndMarshalPullRequestFiles(ctx, client, owner, repo, pullNumber, pagination)
+}
 
-			return mcp.NewToolResultText(string(r)), nil
+func fetchAndMarshalPullRequestFiles(ctx context.Context, client *github.Client, owner, repo string, pullNumber int, pagination PaginationParams) (*mcp.CallToolResult, error) {
+	opts := &github.ListOptions{
+		PerPage: pagination.perPage,
+		Page:    pagination.page,
+	}
+	files, resp, err := client.PullRequests.ListFiles(ctx, owner, repo, pullNumber, opts)
+	if err != nil {
+		return ghErrors.NewGitHubAPIErrorResponse(ctx,
+			"failed to get pull request files",
+			resp,
+			err,
+		), nil
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		body, err := io.ReadAll(resp.Body)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read response body: %w", err)
 		}
+		return mcp.NewToolResultError(fmt.Sprintf("failed to get pull request files: %s", string(body))), nil
+	}
+
+	r, err := json.Marshal(files)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal response: %w", err)
+	}
+
+	return mcp.NewToolResultText(string(r)), nil
 }
 
 // GetPullRequestStatus creates a tool to get the combined status of all status checks for a pull request.

pkg/github/search.go

@@ -13,6 +13,11 @@ import (
 	"github.com/mark3labs/mcp-go/server"
 )
 
+const (
+	errReadResponseBody = "failed to read response body: %w"
+	errMarshalResponse  = "failed to marshal response: %w"
+)
+
 // SearchRepositories creates a tool to search for GitHub repositories.
 func SearchRepositories(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
 	return mcp.NewTool("search_repositories",
@@ -61,14 +66,14 @@ func SearchRepositories(getClient GetClientFn, t translations.TranslationHelperF
 			if resp.StatusCode != 200 {
 				body, err := io.ReadAll(resp.Body)
 				if err != nil {
-					return nil, fmt.Errorf("failed to read response body: %w", err)
+					return nil, fmt.Errorf(errReadResponseBody, err)
 				}
 				return mcp.NewToolResultError(fmt.Sprintf("failed to search repositories: %s", string(body))), nil
 			}
 
 			r, err := json.Marshal(result)
 			if err != nil {
-				return nil, fmt.Errorf("failed to marshal response: %w", err)
+				return nil, fmt.Errorf(errMarshalResponse, err)
 			}
 
 			return mcp.NewToolResultText(string(r)), nil
@@ -141,14 +146,14 @@ func SearchCode(getClient GetClientFn, t translations.TranslationHelperFunc) (to
 			if resp.StatusCode != 200 {
 				body, err := io.ReadAll(resp.Body)
 				if err != nil {
-					return nil, fmt.Errorf("failed to read response body: %w", err)
+					return nil, fmt.Errorf(errReadResponseBody, err)
 				}
 				return mcp.NewToolResultError(fmt.Sprintf("failed to search code: %s", string(body))), nil
 			}
 
 			r, err := json.Marshal(result)
 			if err != nil {
-				return nil, fmt.Errorf("failed to marshal response: %w", err)
+				return nil, fmt.Errorf(errMarshalResponse, err)
 			}
 
 			return mcp.NewToolResultText(string(r)), nil
@@ -215,7 +220,7 @@ func userOrOrgHandler(accountType string, getClient GetClientFn) server.ToolHand
 		if resp.StatusCode != 200 {
 			body, err := io.ReadAll(resp.Body)
 			if err != nil {
-				return nil, fmt.Errorf("failed to read response body: %w", err)
+				return nil, fmt.Errorf(errReadResponseBody, err)
 			}
 			return mcp.NewToolResultError(fmt.Sprintf("failed to search %ss: %s", accountType, string(body))), nil
 		}
@@ -251,7 +256,7 @@ func userOrOrgHandler(accountType string, getClient GetClientFn) server.ToolHand
 
 		r, err := json.Marshal(minimalResp)
 		if err != nil {
-			return nil, fmt.Errorf("failed to marshal response: %w", err)
+			return nil, fmt.Errorf(errMarshalResponse, err)
 		}
 		return mcp.NewToolResultText(string(r)), nil
 	}