Add MCP tool auto-selection and improve test coverage

This commit enhances the kubectl-datadog MCP server with several improvements:

**Auto-selection for MCP tools:**
- Made `name` parameter optional in GetAgentStatusArgs, DescribeAgentFeaturesArgs,
  DescribeAgentComponentsArgs, and GetClusterAgentLeaderArgs
- Added `selectDatadogAgent` helper method to eliminate code duplication
- Auto-selects first DatadogAgent when name not provided (convenient for single-agent clusters)
- Updated tool descriptions to reflect auto-selection capability

**Added get_cluster_agent_leader tool:**
- Implements cluster-agent leader discovery functionality
- Returns leader pod name and election method (Lease or ConfigMap)
- Supports auto-selection like other tools

**Test improvements:**
- Created comprehensive test suite for tools.go (0% → 100% coverage for helper functions)
- Added 11 tests covering schema generation, auto-selection, and tool registration
- Refactored tests to eliminate duplication using helper functions
- Reduced test code from 377 to 230 lines (39% reduction)
- Package coverage improved from 23.7% to 29.7%

**Documentation updates:**
- Updated kubectl-datadog-mcp.md with auto-selection examples
- Added documentation for get_cluster_agent_leader tool
- Updated architecture diagram with all 5 local tools

**Code quality:**
- Added explicit channel lifecycle documentation in PortForwarder
- All changes pass linting with 0 issues

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: clamoriniere

LICENSE-3rdparty.csv

@@ -103,6 +103,7 @@ core,github.com/google/btree,Apache-2.0
 core,github.com/google/cel-go,Apache-2.0
 core,github.com/google/gnostic-models,Apache-2.0
 core,github.com/google/go-cmp/cmp,BSD-3-Clause
+core,github.com/google/jsonschema-go/jsonschema,MIT
 core,github.com/google/pprof/profile,Apache-2.0
 core,github.com/google/shlex,Apache-2.0
 core,github.com/google/uuid,BSD-3-Clause
@@ -145,6 +146,7 @@ core,github.com/mitchellh/mapstructure,MIT
 core,github.com/mitchellh/reflectwalk,MIT
 core,github.com/moby/spdystream,Apache-2.0
 core,github.com/moby/term,Apache-2.0
+core,github.com/modelcontextprotocol/go-sdk,MIT
 core,github.com/modern-go/concurrent,Apache-2.0
 core,github.com/modern-go/reflect2,Apache-2.0
 core,github.com/mohae/deepcopy,MIT
@@ -200,6 +202,7 @@ core,github.com/ulikunitz/xz,BSD-3-Clause
 core,github.com/x448/float16,MIT
 core,github.com/xi2/xz,Unknown
 core,github.com/xlab/treeprint,MIT
+core,github.com/yosida95/uritemplate/v3,BSD-3-Clause
 core,go.etcd.io/bbolt,MIT
 core,go.opentelemetry.io/auto/sdk,Apache-2.0
 core,go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp,Apache-2.0

cmd/kubectl-datadog/autoscaling/cluster/install/guess/aws-auth.go

@@ -10,7 +10,7 @@ import (
 )
 
 // IsAwsAuthConfigMapPresent checks if the aws-auth ConfigMap exists in the kube-system namespace
-func IsAwsAuthConfigMapPresent(ctx context.Context, clientset *kubernetes.Clientset) (bool, error) {
+func IsAwsAuthConfigMapPresent(ctx context.Context, clientset kubernetes.Interface) (bool, error) {
 	if _, err := clientset.CoreV1().ConfigMaps("kube-system").Get(ctx, "aws-auth", metav1.GetOptions{}); err != nil {
 		if apierrors.IsNotFound(err) {
 			return false, nil

cmd/kubectl-datadog/autoscaling/cluster/install/guess/nodesproperties.go

@@ -23,7 +23,7 @@ const nodeListChunkSize = 100
 // Format: aws:///ZONE/INSTANCE_ID (e.g., aws:///us-east-1a/i-0abc123def456789)
 var awsProviderIDRegexp = regexp.MustCompile(`^aws:///[^/]+/(i-[0-9a-f]+)$`)
 
-func GetNodesProperties(ctx context.Context, clientset *kubernetes.Clientset, ec2Client *ec2.Client) (*NodePoolsSet, error) {
+func GetNodesProperties(ctx context.Context, clientset kubernetes.Interface, ec2Client *ec2.Client) (*NodePoolsSet, error) {
 	nps := NewNodePoolsSet()
 
 	var cont string

cmd/kubectl-datadog/autoscaling/cluster/install/install.go

@@ -271,8 +271,8 @@ type clients struct {
 	sts            *sts.Client
 
 	// Kubernetes clients
-	k8sClient    client.Client         // controller-runtime client
-	k8sClientset *kubernetes.Clientset // typed Kubernetes client
+	k8sClient    client.Client        // controller-runtime client
+	k8sClientset kubernetes.Interface // typed Kubernetes client
 }
 
 func (o *options) getClusterNameFromKubeconfig(ctx context.Context) (string, error) {

cmd/kubectl-datadog/clusteragent/leader/leader.go

@@ -131,12 +131,22 @@ func (o *options) run(cmd *cobra.Command) error {
 }
 
 func (o *options) getLeaderFromLease(objKey client.ObjectKey) (string, error) {
+	return GetLeaderFromLease(o.Client, objKey)
+}
+
+func (o *options) getLeaderFromConfigMap(objKey client.ObjectKey) (string, error) {
+	return GetLeaderFromConfigMap(o.Client, objKey)
+}
+
+// GetLeaderFromLease retrieves the leader pod name from a Lease resource
+// This is a public function that can be reused by other packages
+func GetLeaderFromLease(c client.Client, objKey client.ObjectKey) (string, error) {
 	lease := &coordv1.Lease{}
-	err := o.Client.Get(context.TODO(), objKey, lease)
+	err := c.Get(context.TODO(), objKey, lease)
 	if err != nil && apierrors.IsNotFound(err) {
 		return "", fmt.Errorf("lease %s/%s not found", objKey.Namespace, objKey.Name)
 	} else if err != nil {
-		return "", fmt.Errorf("unable to get leader election config map: %w", err)
+		return "", fmt.Errorf("unable to get leader election lease: %w", err)
 	}
 
 	// get the info from the lease
@@ -147,10 +157,12 @@ func (o *options) getLeaderFromLease(objKey client.ObjectKey) (string, error) {
 	return *lease.Spec.HolderIdentity, nil
 }
 
-func (o *options) getLeaderFromConfigMap(objKey client.ObjectKey) (string, error) {
+// GetLeaderFromConfigMap retrieves the leader pod name from a ConfigMap annotation
+// This is a public function that can be reused by other packages
+func GetLeaderFromConfigMap(c client.Client, objKey client.ObjectKey) (string, error) {
 	// Get the config map holding the leader identity.
 	cm := &corev1.ConfigMap{}
-	err := o.Client.Get(context.TODO(), objKey, cm)
+	err := c.Get(context.TODO(), objKey, cm)
 	if err != nil && apierrors.IsNotFound(err) {
 		return "", fmt.Errorf("config map %s/%s not found", objKey.Namespace, objKey.Name)
 	} else if err != nil {
@@ -172,7 +184,13 @@ func (o *options) getLeaderFromConfigMap(objKey client.ObjectKey) (string, error
 }
 
 func isLeaseSupported(client discovery.DiscoveryInterface) (bool, error) {
-	apiGroupList, err := client.ServerGroups()
+	return IsLeaseSupported(client)
+}
+
+// IsLeaseSupported checks if the Kubernetes cluster supports Lease resources
+// This is a public function that can be reused by other packages
+func IsLeaseSupported(discoveryClient discovery.DiscoveryInterface) (bool, error) {
+	apiGroupList, err := discoveryClient.ServerGroups()
 	if err != nil {
 		return false, fmt.Errorf("unable to discover APIGroups, err:%w", err)
 	}

cmd/kubectl-datadog/mcp/client.go

@@ -0,0 +1,179 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2016-present Datadog, Inc.
+
+package mcp
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+// ClusterAgentMCPClient communicates with the cluster-agent MCP server via HTTP
+type ClusterAgentMCPClient struct {
+	baseURL    string
+	endpoint   string
+	httpClient *http.Client
+	mcpClient  *mcp.Client
+	session    *mcp.ClientSession
+}
+
+// ClusterAgentMCPClientConfig contains configuration for creating a ClusterAgentMCPClient
+type ClusterAgentMCPClientConfig struct {
+	BaseURL    string        // e.g., "http://localhost:12345"
+	Endpoint   string        // e.g., "/mcp"
+	Timeout    time.Duration // HTTP timeout for tool calls
+	MaxRetries int           // Maximum reconnection retries
+}
+
+// NewClusterAgentMCPClient creates a new MCP HTTP client for cluster-agent communication
+func NewClusterAgentMCPClient(config ClusterAgentMCPClientConfig) (*ClusterAgentMCPClient, error) {
+	if config.BaseURL == "" {
+		return nil, fmt.Errorf("baseURL is required")
+	}
+
+	if config.Endpoint == "" {
+		config.Endpoint = "/mcp"
+	}
+
+	if config.Timeout == 0 {
+		config.Timeout = 120 * time.Second
+	}
+
+	if config.MaxRetries == 0 {
+		config.MaxRetries = 3
+	}
+
+	// Create HTTP client with timeout
+	httpClient := &http.Client{
+		Timeout: config.Timeout,
+	}
+
+	// Create MCP client
+	mcpClient := mcp.NewClient(&mcp.Implementation{
+		Name:    "kubectl-datadog-proxy",
+		Version: "1.0.0",
+	}, nil)
+
+	return &ClusterAgentMCPClient{
+		baseURL:    config.BaseURL,
+		endpoint:   config.Endpoint,
+		httpClient: httpClient,
+		mcpClient:  mcpClient,
+	}, nil
+}
+
+// Connect establishes a connection to the cluster-agent MCP server
+func (c *ClusterAgentMCPClient) Connect(ctx context.Context) error {
+	// Build full endpoint URL
+	fullURL := c.baseURL + c.endpoint
+
+	// Create streamable HTTP transport
+	transport := &mcp.StreamableClientTransport{
+		Endpoint:   fullURL,
+		HTTPClient: c.httpClient,
+		MaxRetries: 3,
+	}
+
+	// Connect to the cluster-agent MCP server
+	session, err := c.mcpClient.Connect(ctx, transport, nil)
+	if err != nil {
+		return fmt.Errorf("failed to connect to cluster-agent MCP server: %w", err)
+	}
+
+	c.session = session
+	return nil
+}
+
+// ListTools fetches the list of available tools from the cluster-agent
+func (c *ClusterAgentMCPClient) ListTools(ctx context.Context) ([]*mcp.Tool, error) {
+	if c.session == nil {
+		return nil, fmt.Errorf("client not connected, call Connect() first")
+	}
+
+	// List tools from the cluster-agent
+	result, err := c.session.ListTools(ctx, &mcp.ListToolsParams{})
+	if err != nil {
+		return nil, fmt.Errorf("failed to list tools: %w", err)
+	}
+
+	return result.Tools, nil
+}
+
+// CallTool executes a tool on the cluster-agent
+func (c *ClusterAgentMCPClient) CallTool(ctx context.Context, name string, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
+	if c.session == nil {
+		return nil, fmt.Errorf("client not connected, call Connect() first")
+	}
+
+	// Call the tool on the cluster-agent
+	result, err := c.session.CallTool(ctx, &mcp.CallToolParams{
+		Name:      name,
+		Arguments: arguments,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to call tool %s: %w", name, err)
+	}
+
+	return result, nil
+}
+
+// Close closes the connection to the cluster-agent MCP server
+func (c *ClusterAgentMCPClient) Close() error {
+	if c.session != nil {
+		return c.session.Close()
+	}
+	return nil
+}
+
+// IsConnected returns true if the client is connected to the cluster-agent
+func (c *ClusterAgentMCPClient) IsConnected() bool {
+	return c.session != nil
+}
+
+// GetServerCapabilities returns capabilities of the connected MCP server
+func (c *ClusterAgentMCPClient) GetServerCapabilities() (*mcp.ServerCapabilities, error) {
+	if c.session == nil {
+		return nil, fmt.Errorf("client not connected")
+	}
+
+	// Server capabilities are available in the InitializeResult
+	initResult := c.session.InitializeResult()
+	if initResult == nil {
+		return nil, fmt.Errorf("server not initialized")
+	}
+
+	return initResult.Capabilities, nil
+}
+
+// Ping sends a ping request to verify the connection is alive
+func (c *ClusterAgentMCPClient) Ping(ctx context.Context) error {
+	if c.session == nil {
+		return fmt.Errorf("client not connected")
+	}
+
+	// Use a simple operation like listing tools to verify connectivity
+	_, err := c.session.ListTools(ctx, &mcp.ListToolsParams{})
+	if err != nil {
+		return fmt.Errorf("ping failed: %w", err)
+	}
+
+	return nil
+}
+
+// Reconnect attempts to reconnect to the cluster-agent MCP server
+func (c *ClusterAgentMCPClient) Reconnect(ctx context.Context) error {
+	// Close existing connection if any
+	if c.session != nil {
+		_ = c.session.Close()
+		c.session = nil
+	}
+
+	// Attempt to reconnect
+	return c.Connect(ctx)
+}