Merge branch 'main' into wb/stderr-notice

Author: burmudar

cmd/src/mcp.go

@@ -17,10 +17,21 @@ var mcpFlagSet = flag.NewFlagSet("mcp", flag.ExitOnError)
 
 func init() {
 	commands = append(commands, &command{
-		flagSet: mcpFlagSet,
-		handler: mcpMain,
+		flagSet:   mcpFlagSet,
+		handler:   mcpMain,
+		usageFunc: mcpUsage,
 	})
 }
+
+func mcpUsage() {
+	fmt.Println("The 'mcp' command exposes MCP tools as subcommands for agents to use.")
+	fmt.Println("\nUSAGE:")
+	fmt.Println("  src mcp list-tools              List available tools")
+	fmt.Println("  src mcp <tool-name> schema      View the input/output schema of a tool")
+	fmt.Println("  src mcp <tool-name> <flags>     Invoke a tool with the given flags")
+	fmt.Println("  src mcp <tool-name> -h          List the available flags of a tool")
+}
+
 func mcpMain(args []string) error {
 	apiClient := cfg.apiClient(nil, mcpFlagSet.Output())
 
@@ -30,21 +41,21 @@ func mcpMain(args []string) error {
 		return err
 	}
 
+	if len(args) == 0 {
+		mcpUsage()
+		return nil
+	}
+
 	subcmd := args[0]
 	if subcmd == "list-tools" {
 		fmt.Println("The following tools are available:")
 		for name := range tools {
-			fmt.Printf(" • %s\n", name)
+			fmt.Printf("  %s\n", name)
 		}
 		fmt.Println("\nUSAGE:")
-		fmt.Printf(" • Invoke a tool\n")
-		fmt.Printf("     src mcp <tool-name> <flags>\n")
-		fmt.Printf("\n • View the Input / Output Schema of a tool\n")
-		fmt.Printf("     src mcp <tool-name> schema\n")
-		fmt.Printf("\n • List the available flags of a tool\n")
-		fmt.Printf("     src mcp <tool-name> -h\n")
-		fmt.Printf("\n • View the Input / Output Schema of a tool\n")
-		fmt.Printf("     src mcp <tool-name> schema\n")
+		fmt.Println("  src mcp <tool-name> schema      View the input/output schema of a tool")
+		fmt.Println("  src mcp <tool-name> <flags>     Invoke a tool with the given flags")
+		fmt.Println("  src mcp <tool-name> -h          List the available flags of a tool")
 		return nil
 	}
 	tool, ok := tools[subcmd]
@@ -64,7 +75,7 @@ func mcpMain(args []string) error {
 	if err := flags.Parse(flagArgs); err != nil {
 		return err
 	}
-	mcp.DerefFlagValues(vars)
+	mcp.DerefFlagValues(flags, vars)
 
 	if err := validateToolArgs(tool.InputSchema, args, vars); err != nil {
 		return err

internal/mcp/mcp_args.go

@@ -1,6 +1,7 @@
 package mcp
 
 import (
+	"encoding/json"
 	"flag"
 	"fmt"
 	"reflect"
@@ -16,6 +17,16 @@ type strSliceFlag struct {
 }
 
 func (s *strSliceFlag) Set(v string) error {
+	// The MCP Array properties accept JSON arrays so, if we get a value starting with "["
+	// it's probably a JSON array
+	if strings.HasPrefix(v, "[") {
+		var arr []string
+		if err := json.Unmarshal([]byte(v), &arr); err == nil {
+			s.vals = append(s.vals, arr...)
+			return nil
+		}
+	}
+	// Otherwise treat as a single value
 	s.vals = append(s.vals, v)
 	return nil
 }
@@ -24,36 +35,28 @@ func (s *strSliceFlag) String() string {
 	return strings.Join(s.vals, ",")
 }
 
-func DerefFlagValues(vars map[string]any) {
+func DerefFlagValues(fs *flag.FlagSet, vars map[string]any) {
+	setFlags := make(map[string]bool)
+	fs.Visit(func(f *flag.Flag) {
+		setFlags[f.Name] = true
+	})
+
 	for k, v := range vars {
+		if !setFlags[k] {
+			delete(vars, k)
+			continue
+		}
 		rfl := reflect.ValueOf(v)
 		if rfl.Kind() == reflect.Pointer {
 			vv := rfl.Elem().Interface()
 			if slice, ok := vv.(strSliceFlag); ok {
 				vv = slice.vals
 			}
-			if isNil(vv) {
-				delete(vars, k)
-			} else {
-				vars[k] = vv
-			}
+			vars[k] = vv
 		}
 	}
 }
 
-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 BuildArgFlagSet(tool *ToolDef) (*flag.FlagSet, map[string]any, error) {
 	if tool == nil {
 		return nil, nil, errors.New("cannot build flagset on nil Tool Definition")

internal/mcp/mcp_args_test.go

@@ -1,6 +1,7 @@
 package mcp
 
 import (
+	"slices"
 	"testing"
 )
 
@@ -58,20 +59,22 @@ func TestFlagSetParse(t *testing.T) {
 		t.Fatalf("vars from buildArgFlagSet should not be empty")
 	}
 
-	args := []string{"-repos=A", "-repos=B", "-count=10", "-boolFlag", "-tag=testTag"}
+	args := []string{"-repos=A", "-repos=B", `-repos=["repo1", "repo2"]`, "-count=10", "-boolFlag", "-tag=testTag"}
 
 	if err := flagSet.Parse(args); err != nil {
 		t.Fatalf("flagset parsing failed: %v", err)
 	}
-	DerefFlagValues(vars)
+	DerefFlagValues(flagSet, vars)
 
-	if v, ok := vars["repos"].([]string); ok {
-		if len(v) != 2 {
-			t.Fatalf("expected flag 'repos' values to have length %d but got %d", 2, len(v))
-		}
-	} else {
-		t.Fatalf("expected flag 'repos' to have type of []string but got %T", v)
+	expectedRepos := []string{"A", "B", "repo1", "repo2"}
+	actualRepos, ok := vars["repos"].([]string)
+	if !ok {
+		t.Fatalf("failed to cast repos to []string, got %T", actualRepos)
 	}
+	if !slices.Equal(expectedRepos, actualRepos) {
+		t.Fatalf("expected repos %v, got %v", expectedRepos, vars["repos"])
+	}
+
 	if v, ok := vars["tag"].(string); ok {
 		if v != "testTag" {
 			t.Fatalf("expected flag 'tag' values to have value %q but got %q", "testTag", v)