feat(bridge) get default value from flag and add to schema

Author: njayp

internal/bridge/tool.go

@@ -1,8 +1,10 @@
 package bridge
 
 import (
+	"encoding/json"
 	"fmt"
 	"log/slog"
+	"strconv"
 	"strings"
 
 	"github.com/google/jsonschema-go/jsonschema"
@@ -204,9 +206,100 @@ func addFlagToSchema(schema *jsonschema.Schema, flag *pflag.Flag) {
 		slog.Debug("unknown flag type, defaulting to string", "flag", flag.Name, "type", t)
 	}
 
+	setDefaultValue(flagSchema, flag.DefValue)
 	schema.Properties[flag.Name] = flagSchema
 }
 
+// setDefaultValue sets the default value for a flag schema if it's not a zero value.
+func setDefaultValue(flagSchema *jsonschema.Schema, defValue string) {
+	if defValue == "" {
+		return
+	}
+
+	setDefault := func(val any) {
+		if raw, err := json.Marshal(val); err == nil {
+			flagSchema.Default = json.RawMessage(raw)
+		}
+	}
+
+	// Parse the default value based on the schema type
+	switch flagSchema.Type {
+	case "boolean":
+		if val, err := strconv.ParseBool(defValue); err == nil {
+			setDefault(val)
+		}
+	case "integer":
+		if val, err := strconv.ParseInt(defValue, 10, 64); err == nil {
+			setDefault(val)
+		}
+	case "number":
+		if val, err := strconv.ParseFloat(defValue, 64); err == nil {
+			setDefault(val)
+		}
+	case "string":
+		setDefault(defValue)
+	case "array":
+		// Handle array types (slices)
+		// pflag represents empty slices as "[]"
+		if defValue == "[]" {
+			return
+		}
+		// pflag represents arrays as "[item1,item2,item3]"
+		// We need to manually parse this into an actual JSON array
+		// --- Ewwww Gross ---
+		if strings.HasPrefix(defValue, "[") && strings.HasSuffix(defValue, "]") {
+			// Remove the brackets
+			inner := defValue[1 : len(defValue)-1]
+			if inner == "" {
+				return // Empty array
+			}
+			// Split by comma
+			parts := strings.Split(inner, ",")
+			// Determine the array item type from the schema
+			if flagSchema.Items != nil {
+				switch flagSchema.Items.Type {
+				case "integer":
+					// Parse as integer array
+					intArr := make([]int64, 0, len(parts))
+					for _, p := range parts {
+						if val, err := strconv.ParseInt(strings.TrimSpace(p), 10, 64); err == nil {
+							intArr = append(intArr, val)
+						}
+					}
+					setDefault(intArr)
+				case "number":
+					// Parse as float array
+					floatArr := make([]float64, 0, len(parts))
+					for _, p := range parts {
+						if val, err := strconv.ParseFloat(strings.TrimSpace(p), 64); err == nil {
+							floatArr = append(floatArr, val)
+						}
+					}
+					setDefault(floatArr)
+				case "boolean":
+					// Parse as boolean array
+					boolArr := make([]bool, 0, len(parts))
+					for _, p := range parts {
+						if val, err := strconv.ParseBool(strings.TrimSpace(p)); err == nil {
+							boolArr = append(boolArr, val)
+						}
+					}
+					setDefault(boolArr)
+				case "string":
+					// String array - trim whitespace from each element
+					strArr := make([]string, 0, len(parts))
+					for _, p := range parts {
+						strArr = append(strArr, strings.TrimSpace(p))
+					}
+					setDefault(strArr)
+				}
+
+				// there are no array of objects in pflag, so we don't handle that case
+			}
+		}
+	}
+}
+
 // enhanceArgsSchema adds detailed argument information to the args property.
 func enhanceArgsSchema(schema *jsonschema.Schema, cmd *cobra.Command) {
 	description := "Positional command line arguments"

internal/bridge/tool_test.go

@@ -23,7 +23,8 @@ func TestCreateToolFromCmd(t *testing.T) {
 	// Add some flags
 	cmd.Flags().String("output", "", "Output file")
 	cmd.Flags().Bool("verbose", false, "Verbose output")
-	cmd.Flags().StringSlice("include", []string{}, "Include patterns")
+	cmd.Flags().IntSlice("include", []int{}, "Include patterns")
+	cmd.Flags().StringSlice("greeting", []string{"hello", "world"}, "Include patterns")
 	cmd.Flags().Int("count", 10, "Number of items")
 
 	// Add a hidden flag
@@ -73,6 +74,7 @@ func TestCreateToolFromCmd(t *testing.T) {
 		assert.Contains(t, flagsSchema.Properties, "verbose")
 		assert.Contains(t, flagsSchema.Properties, "include")
 		assert.Contains(t, flagsSchema.Properties, "count")
+		assert.Contains(t, flagsSchema.Properties, "greeting")
 
 		// Verify excluded flags
 		assert.NotContains(t, flagsSchema.Properties, "hidden", "Should not include hidden flag")
@@ -83,15 +85,30 @@ func TestCreateToolFromCmd(t *testing.T) {
 		assert.Equal(t, "boolean", flagsSchema.Properties["verbose"].Type)
 		assert.Equal(t, "array", flagsSchema.Properties["include"].Type)
 		assert.Equal(t, "integer", flagsSchema.Properties["count"].Type)
+		assert.Equal(t, "array", flagsSchema.Properties["greeting"].Type)
 
 		// Verify required flags
 		require.Len(t, flagsSchema.Required, 1, "Should have 1 required flag")
 		assert.Contains(t, flagsSchema.Required, "count", "count flag should be marked as required")
 
+		// Verify default values
+		assert.NotNil(t, flagsSchema.Properties["verbose"].Default)
+		assert.JSONEq(t, "false", string(flagsSchema.Properties["verbose"].Default))
+		assert.NotNil(t, flagsSchema.Properties["count"].Default)
+		assert.JSONEq(t, "10", string(flagsSchema.Properties["count"].Default))
+		assert.NotNil(t, flagsSchema.Properties["greeting"].Default)
+		assert.JSONEq(t, `["hello","world"]`, string(flagsSchema.Properties["greeting"].Default))
+		// Empty string and empty array should not have defaults set
+		assert.Nil(t, flagsSchema.Properties["output"].Default)
+		assert.Nil(t, flagsSchema.Properties["include"].Default)
+
 		// Verify array items schema
 		includeSchema := flagsSchema.Properties["include"]
 		assert.NotNil(t, includeSchema.Items)
-		assert.Equal(t, "string", includeSchema.Items.Type)
+		assert.Equal(t, "integer", includeSchema.Items.Type)
+		greetingSchema := flagsSchema.Properties["greeting"]
+		assert.NotNil(t, greetingSchema.Items)
+		assert.Equal(t, "string", greetingSchema.Items.Type)
 
 		// Verify persistent flag from parent command
 		assert.Contains(t, flagsSchema.Properties, "config", "Should include persistent flag from parent command")