feat: add MCP prompts support

Add MCP prompts support to enable pre-defined workflow templates and guidance for AI assistants. Includes:

- New PromptLoader for loading prompts from YAML files or embedded filesystems
- Core prompt types (ServerPrompt, Prompt, PromptArgument, PromptMessage)
- Template argument substitution with {{variable}} syntax
- Required argument validation
- built-in prompts for common Kubernetes workflows (troubleshooting, deployment, scaling, cluster health, networking, resource usage)
- Integration with MCP server to register and serve prompts

Signed-off-by: Nader Ziada <[email protected]>

Author: nader-ziada

docs/PROMPTS.md

@@ -0,0 +1,225 @@
+# MCP Prompts Support
+
+The Kubernetes MCP Server now supports [MCP Prompts](https://modelcontextprotocol.io/docs/concepts/prompts), which provide pre-defined workflow templates and guidance to AI assistants. Prompts help standardize common Kubernetes operations and provide structured approaches to troubleshooting and deployment tasks.
+
+## What are MCP Prompts?
+
+MCP Prompts are pre-defined templates that guide AI assistants through specific workflows. They combine:
+- **Structured guidance**: Step-by-step instructions for common tasks
+- **Parameterization**: Arguments that customize the prompt for specific contexts
+- **Conversation templates**: Pre-formatted messages that guide the interaction
+
+## Available Prompts
+
+The Kubernetes MCP Server currently provides the following prompts in the `core` toolset:
+
+### 1. `troubleshoot-pod`
+Guide for troubleshooting a failing or crashed pod in Kubernetes.
+
+**Arguments:**
+- `namespace` (required): The namespace where the pod is located
+- `pod_name` (required): The name of the pod to troubleshoot
+
+**Usage:**
+```
+When to use: Pod is failing, crashing, or not working as expected
+What it does: Systematically investigates pod status, events, logs, and resource constraints
+```
+
+### 2. `deploy-application`
+Workflow for deploying a new application to Kubernetes.
+
+**Arguments:**
+- `app_name` (required): The name of the application to deploy
+- `namespace` (optional): The namespace to deploy to (defaults to 'default')
+
+**Usage:**
+```
+When to use: Deploying a new application to the cluster
+What it does: Guides through namespace setup, manifest creation, deployment, and verification
+```
+
+### 3. `scale-deployment`
+Guide for scaling a deployment up or down.
+
+**Arguments:**
+- `deployment_name` (required): The name of the deployment to scale
+- `namespace` (required): The namespace of the deployment
+- `replicas` (required): The desired number of replicas
+
+**Usage:**
+```
+When to use: Need to scale application replicas
+What it does: Checks current status, scales deployment, and monitors the scaling process
+```
+
+### 4. `investigate-cluster-health`
+Comprehensive workflow for investigating overall cluster health.
+
+**Arguments:** None
+
+**Usage:**
+```
+When to use: Want to understand overall cluster status and health
+What it does: Checks nodes, system pods, events, resource usage, and namespaces
+```
+
+### 5. `debug-networking`
+Workflow for debugging networking issues between pods or services.
+
+**Arguments:**
+- `source_pod` (optional): The source pod name
+- `source_namespace` (optional): The source pod namespace
+- `target_service` (optional): The target service name
+
+**Usage:**
+```
+When to use: Experiencing connectivity or networking problems
+What it does: Investigates pod IPs, service configuration, network policies, DNS, and connectivity
+```
+
+### 6. `review-resource-usage`
+Analyze resource usage across the cluster or specific namespace.
+
+**Arguments:**
+- `namespace` (optional): Focus on specific namespace (leave empty for cluster-wide)
+
+**Usage:**
+```
+When to use: Need to understand resource consumption and identify bottlenecks
+What it does: Analyzes CPU and memory usage, identifies top consumers, and provides recommendations
+```
+
+## Creating Custom Prompts
+
+Toolsets can provide their own prompts by implementing the `GetPrompts()` method and creating YAML definition files.
+
+### YAML Prompt Definition Format
+
+Prompts are defined in YAML files with the following structure:
+
+```yaml
+- name: prompt-name
+  description: Human-readable description of what this prompt does
+  arguments:
+    - name: argument_name
+      description: What this argument is for
+      required: true/false
+  messages:
+    - role: user
+      content: |
+        The user's initial message with {{argument_name}} placeholders
+    - role: assistant
+      content: |
+        The assistant's response template
+```
+
+### Example: Creating a Custom Prompt
+
+**Step 1: Create a YAML file** (`pkg/toolsets/yourname/prompts.yaml`):
+
+```yaml
+- name: check-pod-logs
+  description: Retrieve and analyze logs from a specific pod
+  arguments:
+    - name: pod_name
+      description: The name of the pod to check
+      required: true
+    - name: namespace
+      description: The namespace of the pod
+      required: false
+  messages:
+    - role: user
+      content: |
+        I need to check the logs for pod {{pod_name}}{{#namespace}} in namespace {{namespace}}{{/namespace}}.
+    - role: assistant
+      content: |
+        I'll retrieve the logs for {{pod_name}}. Let me:
+        1. Verify the pod exists and its status
+        2. Retrieve the latest logs
+        3. Analyze for errors or warnings
+```
+
+**Step 2: Embed the YAML file** in your Go code:
+
+```go
+package yourname
+
+import (
+	_ "embed"
+	"github.com/containers/kubernetes-mcp-server/pkg/api"
+)
+
+//go:embed prompts.yaml
+var promptsYAML []byte
+
+func initPrompts() []api.ServerPrompt {
+	loader := api.NewPromptLoader()
+	if err := loader.LoadFromBytes(promptsYAML); err != nil {
+		return nil
+	}
+	return loader.GetServerPrompts()
+}
+```
+
+**Step 3: Implement `GetPrompts()`** in your toolset:
+
+```go
+func (t *Toolset) GetPrompts(_ internalk8s.Openshift) []api.ServerPrompt {
+	return initPrompts()
+}
+```
+
+### Argument Substitution
+
+Prompts support template variable substitution using `{{argument_name}}` syntax:
+
+- `{{argument_name}}` - Replaced with the argument value
+- Simple string replacement is performed automatically by the prompt loader
+
+### Advanced: Custom Prompt Handlers
+
+For more complex prompt logic, you can create custom handlers instead of using YAML:
+
+```go
+func customPromptHandler(params api.PromptHandlerParams) (*api.PromptCallResult, error) {
+	args := params.GetArguments()
+
+	// Custom logic here
+	namespace := args["namespace"]
+	podName := args["pod_name"]
+
+	// Build dynamic messages
+	messages := []api.PromptMessage{
+		{
+			Role: "user",
+			Content: api.PromptContent{
+				Type: "text",
+				Text: fmt.Sprintf("Check pod %s in namespace %s", podName, namespace),
+			},
+		},
+		{
+			Role: "assistant",
+			Content: api.PromptContent{
+				Type: "text",
+				Text: "I'll check the pod status...",
+			},
+		},
+	}
+
+	return api.NewPromptCallResult("Custom prompt", messages, nil), nil
+}
+```
+
+## Using Prompts with AI Assistants
+
+When using the Kubernetes MCP Server with an AI assistant (like Claude):
+
+1. **List available prompts**: The assistant can discover available prompts via the MCP protocol
+2. **Invoke a prompt**: The assistant can call a prompt with specific arguments
+3. **Follow the workflow**: The prompt provides structured guidance for the task
+
+### Example Interaction
+
+```
+User: "My pod is crashing, can you help?"