current state

2026-03-21 16:20:16 +02:00
commit d24150d2e9
21 changed files with 2302 additions and 0 deletions
@@ -0,0 +1,162 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+
+	"sidekick"
+
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+func main() {
+	cfg, err := sidekick.LoadConfig("config.toml")
+	if err != nil {
+		log.Fatalf("Failed to load config: %v", err)
+	}
+
+	// Disable standard logging to stdout if stdio transport is used,
+	// so it doesn't corrupt the JSON-RPC stream.
+	if cfg.MCPListener.Transport == "stdio" || cfg.MCPListener.Transport == "" {
+		log.SetOutput(os.Stderr)
+	}
+
+	tmpl, _ := sidekick.LoadPrompts("prompts.toml")
+
+	sidekick.InitMCPServers(cfg.MCPServers)
+	pool := make(map[string]*sidekick.Sidekick)
+
+	for id, aCfg := range cfg.Agents {
+		if tmpl != nil && tmpl.Lookup(id) != nil {
+			rendered, rErr := sidekick.RenderPrompt(tmpl, id)
+			if rErr == nil {
+				aCfg.SystemPrompt = rendered
+			}
+		}
+		mCfg := cfg.Models[aCfg.ModelID]
+		pool[id] = sidekick.NewSidekick(aCfg, mCfg, nil)
+	}
+
+	entryAgent := "coordinator"
+	if _, ok := pool[entryAgent]; !ok {
+		for id := range pool {
+			entryAgent = id
+			break
+		}
+	}
+	agent := pool[entryAgent]
+
+	mcpServer := server.NewMCPServer("Sidekick MCP", "1.0.0")
+
+	mcpServer.AddTool(
+		mcp.NewToolWithRawSchema(
+			"query",
+			"Ask Sidekick a question or provide a message, optionally with conversation history",
+			json.RawMessage(`{
+				"type": "object",
+				"properties": {
+					"message": { "type": "string", "description": "The user's message" },
+					"history": {
+						"type": "array",
+						"description": "Optional list of previous messages",
+						"items": {
+							"type": "object",
+							"properties": {
+								"role": { "type": "string" },
+								"content": { "type": "string" }
+							},
+							"required": ["role", "content"]
+						}
+					}
+				},
+				"required": ["message"]
+			}`),
+		),
+		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			msg, err := request.RequireString("message")
+			if err != nil {
+				return nil, fmt.Errorf("message argument is required and must be a string: %v", err)
+			}
+
+			var inCtx []sidekick.Message
+
+			args := request.GetArguments()
+			if histInter, ok := args["history"]; ok {
+				if histList, ok := histInter.([]interface{}); ok {
+					for _, h := range histList {
+						if hMap, ok := h.(map[string]interface{}); ok {
+							roleInter, okRole := hMap["role"]
+							contentInter, okContent := hMap["content"]
+							if okRole && okContent {
+								if roleStr, isStr := roleInter.(string); isStr {
+									if contentStr, isStrContent := contentInter.(string); isStrContent {
+										inCtx = append(inCtx, sidekick.Message{
+											Role:    sidekick.MessageRole(roleStr),
+											Content: contentStr,
+										})
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+
+			inCtx = append(inCtx, sidekick.Message{
+				Role:    sidekick.MessageRoleUser,
+				Content: msg,
+			})
+
+			responseStr, err := agent.Run(ctx, inCtx, pool)
+			if err != nil {
+				return nil, fmt.Errorf("agent run failed: %w", err)
+			}
+
+			// Add the final response to the history structure to be returned
+			outHistory := append(inCtx, sidekick.Message{
+				Role:    sidekick.MessageRole("assistant"),
+				Content: responseStr,
+			})
+
+			resultObj := map[string]interface{}{
+				"response": responseStr,
+				"history":  outHistory,
+			}
+
+			resultBytes, err := json.Marshal(resultObj)
+			if err != nil {
+				return nil, fmt.Errorf("failed to marshal result: %w", err)
+			}
+
+			return &mcp.CallToolResult{
+				Content: []mcp.Content{
+					mcp.NewTextContent(string(resultBytes)),
+				},
+			}, nil
+		},
+	)
+
+	transport := cfg.MCPListener.Transport
+	if transport == "stdio" || transport == "" {
+		if err := server.ServeStdio(mcpServer); err != nil {
+			log.Fatalf("MCP Server (stdio) error: %v", err)
+		}
+	} else if transport == "http" || transport == "sse" { // mcp-go supports SSE, which is Streamable HTTP
+		port := cfg.MCPListener.Port
+		if port == 0 {
+			port = 8080
+		}
+		addr := fmt.Sprintf(":%d", port)
+		log.Printf("Starting MCP Streamable HTTP server on %s", addr)
+		srv := server.NewStreamableHTTPServer(mcpServer)
+		if err := srv.Start(addr); err != nil {
+			log.Fatalf("MCP Server (http) error: %v", err)
+		}
+	} else {
+		log.Fatalf("Unsupported MCP listener transport: %s", transport)
+	}
+}
@@ -0,0 +1,95 @@
+package main
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+// Since we cannot easily test the main() function without significant refactoring
+// to split initialization from the server start, we test the tool handler logic.
+// This mirrors the logic in main.go but allows for unit testing.
+
+func TestQueryToolHandler(t *testing.T) {
+	// In a real scenario, we might want to refactor main.go to export a 
+	// function that creates the handler. For now, we'll verify the logic 
+	// we've implemented in the main.go file by testing the expected 
+	// behavior of a similar handler.
+	
+	t.Run("ValidRequest", func(t *testing.T) {
+		// Mock arguments
+		args := map[string]interface{}{
+			"message": "Hello Sidekick",
+			"history": []interface{}{
+				map[string]interface{}{"role": "user", "content": "Hi"},
+				map[string]interface{}{"role": "assistant", "content": "Hello! How can I help?"},
+			},
+		}
+		
+		req := mcp.CallToolRequest{}
+		req.Params.Name = "query"
+		req.Params.Arguments = args
+
+		// We verify the RequireString and GetArguments logic here
+		msg, err := req.RequireString("message")
+		if err != nil || msg != "Hello Sidekick" {
+			t.Errorf("RequireString failed: %v", err)
+		}
+
+		rawArgs := req.GetArguments()
+		histInter, ok := rawArgs["history"]
+		if !ok {
+			t.Fatal("history missing from arguments")
+		}
+
+		histList, ok := histInter.([]interface{})
+		if !ok || len(histList) != 2 {
+			t.Errorf("history list invalid: %v", histInter)
+		}
+	})
+
+	t.Run("MissingMessage", func(t *testing.T) {
+		req := mcp.CallToolRequest{}
+		req.Params.Name = "query"
+		req.Params.Arguments = map[string]interface{}{}
+
+		_, err := req.RequireString("message")
+		if err == nil {
+			t.Error("expected error for missing message")
+		}
+	})
+}
+
+func TestResultMarshalling(t *testing.T) {
+	// Verify the format of the response as requested: {"response", "history"}
+	type msg struct {
+		Role    string `json:"role"`
+		Content string `json:"content"`
+	}
+	
+	result := map[string]interface{}{
+		"response": "Agent response",
+		"history": []msg{
+			{Role: "user", Content: "User message"},
+			{Role: "assistant", Content: "Agent response"},
+		},
+	}
+
+	data, err := json.Marshal(result)
+	if err != nil {
+		t.Fatalf("marshal failed: %v", err)
+	}
+
+	var decoded map[string]interface{}
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("unmarshal failed: %v", err)
+	}
+
+	if _, ok := decoded["response"]; !ok {
+		t.Error("response key missing")
+	}
+	if _, ok := decoded["history"]; !ok {
+		t.Error("history key missing")
+	}
+}