make json rpc 2.0 call based on cli args

- basic sse resposne parsing
- remove zero / nil arguments before making the request

Author: burmudar

cmd/src/mcp.go

@@ -1,13 +1,25 @@
 package main
 
 import (
+	"bytes"
+	"context"
+	"encoding/json"
 	"flag"
 	"fmt"
+	"io"
+	"net/http"
 	"strings"
 
+	"github.com/sourcegraph/src-cli/internal/api"
 	"github.com/sourcegraph/src-cli/internal/mcp"
+
+	"github.com/sourcegraph/sourcegraph/lib/errors"
+
+
 )
 
+const McpPath = ".api/mcp/v1"
+
 func init() {
 	flagSet := flag.NewFlagSet("mcp", flag.ExitOnError)
 	commands = append(commands, &command{
@@ -35,37 +47,115 @@ func mcpMain(args []string) error {
 	if !ok {
 		return fmt.Errorf("tool definition for %q not found - run src mcp list-tools to see a list of available tools", subcmd)
 	}
-	return handleMcpTool(tool, args[1:])
-}
 
-func handleMcpTool(tool *mcp.MCPToolDef, args []string) error {
-	fs, vars, err := buildArgFlagSet(tool)
+	flagArgs := args[1:] // skip subcommand name
+	if len(args) > 1 && args[1] == "schema" {
+		return printSchemas(tool)
+	}
+
+	flags, vars, err := buildToolFlagSet(tool)
 	if err != nil {
 		return err
 	}
+	if err := flags.Parse(flagArgs); err != nil {
+		return err
+	}
+	sanitizeFlagValues(vars)
 
-	if err := fs.Parse(args); err != nil {
+	if err := validateToolArgs(tool.InputSchema, args, vars); err != nil {
 		return err
 	}
 
-	inputSchema := tool.InputSchema
+	apiClient := cfg.apiClient(nil, flags.Output())
+	return handleMcpTool(context.Background(), apiClient, tool, vars)
+}
 
+func printSchemas(tool *mcp.MCPToolDef) error {
+	input, err := json.MarshalIndent(tool.InputSchema, "", " ")
+	if err != nil {
+		return err
+	}
+	output, err := json.MarshalIndent(tool.OutputSchema, "", " ")
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Input:\n%v\nOutput:\n%v\n", string(input), string(output))
+	return nil
+}
+
+func validateToolArgs(inputSchema mcp.Schema, args []string, vars map[string]any) error {
 	for _, reqName := range inputSchema.Required {
 		if vars[reqName] == nil {
-			return fmt.Errorf("no value provided for required flag --%s", reqName)
+			return errors.Newf("no value provided for required flag --%s", reqName)
 		}
 	}
 
 	if len(args) < len(inputSchema.Required) {
-		return fmt.Errorf("not enough arguments provided - the following flags are required:\n%s", strings.Join(inputSchema.Required, "\n"))
+		return errors.Newf("not enough arguments provided - the following flags are required:\n%s", strings.Join(inputSchema.Required, "\n"))
+	}
+
+	return nil
+}
+
+func handleMcpTool(ctx context.Context, client api.Client, tool *mcp.MCPToolDef, vars map[string]any) error {
+	jsonRPC := struct {
+		Version string `json:"jsonrpc"`
+		ID      int    `json:"id"`
+		Method  string `json:"method"`
+		Params  any    `json:"params"`
+	}{
+		Version: "2.0",
+		ID:      1,
+		Method:  "tools/call",
+		Params: struct {
+			Name      string         `json:"name"`
+			Arguments map[string]any `json:"arguments"`
+		}{
+			Name:      tool.RawName,
+			Arguments: vars,
+		},
+	}
+
+	buf := bytes.NewBuffer(nil)
+	data, err := json.Marshal(jsonRPC)
+	if err != nil {
+		return err
 	}
+	buf.Write(data)
 
-	derefFlagValues(vars)
+	req, err := client.NewHTTPRequest(ctx, http.MethodPost, McpPath, buf)
+	if err != nil {
+		return err
+	}
+	req.Header.Add("Content-Type", "application/json")
+	req.Header.Add("Accept", "*/*")
 
-	fmt.Println("Flags")
-	for name, val := range vars {
-		fmt.Printf("--%s=%v\n", name, val)
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
 	}
 
+	data, err = io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	jsonData, err := parseSSEResponse(data)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println(string(jsonData))
 	return nil
 }
+
+func parseSSEResponse(data []byte) ([]byte, error) {
+	lines := bytes.SplitSeq(data, []byte("\n"))
+	for line := range lines {
+		if jsonData, ok := bytes.CutPrefix(line, []byte("data: ")); ok {
+			return jsonData, nil
+		}
+	}
+	return nil, errors.New("no data found in SSE response")
+}

cmd/src/mcp_args.go

@@ -22,20 +22,37 @@ func (s *strSliceFlag) String() string {
 	return strings.Join(s.vals, ",")
 }
 
-func derefFlagValues(vars map[string]any) {
+func sanitizeFlagValues(vars map[string]any) {
 	for k, v := range vars {
 		rfl := reflect.ValueOf(v)
 		if rfl.Kind() == reflect.Pointer {
 			vv := rfl.Elem().Interface()
 			if slice, ok := vv.(strSliceFlag); ok {
 				vv = slice.vals
 			}
-			vars[k] = vv
+			if isNil(vv) {
+				delete(vars, k)
+			} else {
+				vars[k] = vv
+			}
 		}
 	}
 }
 
-func buildArgFlagSet(tool *MCPToolDef) (*flag.FlagSet, map[string]any, error) {
+func isNil(v any) bool {
+	if v == nil {
+		return true
+	}
+	rv := reflect.ValueOf(v)
+	switch rv.Kind() {
+	case reflect.Slice, reflect.Map, reflect.Pointer, reflect.Interface:
+		return rv.IsNil()
+	default:
+		return false
+	}
+}
+
+func buildToolFlagSet(tool *MCPToolDef) (*flag.FlagSet, map[string]any, error) {
 	fs := flag.NewFlagSet(tool.Name(), flag.ContinueOnError)
 	flagVars := map[string]any{}
 

cmd/src/mcp_args_test.go

@@ -49,7 +49,7 @@ func TestFlagSetParse(t *testing.T) {
 		t.Fatalf("failed to load tool json: %v", err)
 	}
 
-	flagSet, vars, err := buildArgFlagSet(defs["sg_test_tool"])
+	flagSet, vars, err := buildToolFlagSet(defs["sg_test_tool"])
 	if err != nil {
 		t.Fatalf("failed to build flagset from mcp tool definition: %v", err)
 	}
@@ -63,7 +63,7 @@ func TestFlagSetParse(t *testing.T) {
 	if err := flagSet.Parse(args); err != nil {
 		t.Fatalf("flagset parsing failed: %v", err)
 	}
-	derefFlagValues(vars)
+	sanitizeFlagValues(vars)
 
 	if v, ok := vars["repos"].([]string); ok {
 		if len(v) != 2 {