Added tool read_multiple_files

Author: Dimitar Grigorov

filetoolsserver/handler/read_multiple.go

@@ -0,0 +1,83 @@
+package handler
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+// HandleReadMultipleFiles reads multiple files concurrently.
+// Individual file failures don't stop the operation - errors are reported per file.
+func (h *Handler) HandleReadMultipleFiles(ctx context.Context, req *mcp.CallToolRequest, input ReadMultipleFilesInput) (*mcp.CallToolResult, ReadMultipleFilesOutput, error) {
+	if len(input.Paths) == 0 {
+		return errorResult("paths array is required and must contain at least one path"), ReadMultipleFilesOutput{}, nil
+	}
+
+	results := make([]FileReadResult, len(input.Paths))
+	var wg sync.WaitGroup
+
+	for i, path := range input.Paths {
+		wg.Add(1)
+		go func(idx int, filePath string) {
+			defer wg.Done()
+			results[idx] = h.readSingleFile(filePath, input.Encoding)
+		}(i, path)
+	}
+
+	wg.Wait()
+
+	var successCount, errorCount int
+	for _, r := range results {
+		if r.Error != "" {
+			errorCount++
+		} else {
+			successCount++
+		}
+	}
+
+	return &mcp.CallToolResult{}, ReadMultipleFilesOutput{
+		Results:      results,
+		SuccessCount: successCount,
+		ErrorCount:   errorCount,
+	}, nil
+}
+
+// readSingleFile reads a single file with optional encoding.
+func (h *Handler) readSingleFile(path, requestedEncoding string) FileReadResult {
+	result := FileReadResult{Path: path}
+
+	v := h.ValidatePath(path)
+	if !v.Ok() {
+		result.Error = v.Err.Error()
+		return result
+	}
+
+	data, err := os.ReadFile(v.Path)
+	if err != nil {
+		result.Error = fmt.Sprintf("failed to read file: %v", err)
+		return result
+	}
+
+	encResult, err := resolveEncoding(requestedEncoding, data)
+	if err != nil {
+		result.Error = err.Error()
+		return result
+	}
+
+	content, err := decodeContent(data, encResult)
+	if err != nil {
+		result.Error = fmt.Sprintf("failed to decode file content: %v", err)
+		return result
+	}
+
+	result.Content = content
+	if encResult.autoDetected {
+		result.DetectedEncoding = encResult.detectedEncoding
+		result.EncodingConfidence = encResult.encodingConfidence
+	}
+
+	return result
+}

filetoolsserver/handler/read_multiple_test.go

@@ -0,0 +1,90 @@
+package handler
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/dimitar-grigorov/mcp-file-tools/internal/encoding"
+)
+
+func TestHandleReadMultipleFiles_Success(t *testing.T) {
+	tempDir := t.TempDir()
+	h := NewHandler([]string{tempDir})
+
+	file1 := filepath.Join(tempDir, "file1.txt")
+	file2 := filepath.Join(tempDir, "file2.txt")
+	os.WriteFile(file1, []byte("content1"), 0644)
+	os.WriteFile(file2, []byte("content2"), 0644)
+
+	input := ReadMultipleFilesInput{Paths: []string{file1, file2}}
+	result, output, err := h.HandleReadMultipleFiles(context.Background(), nil, input)
+
+	if err != nil || result.IsError {
+		t.Fatal("expected success")
+	}
+	if output.SuccessCount != 2 || output.ErrorCount != 0 {
+		t.Errorf("expected 2 successes, got %d successes, %d errors", output.SuccessCount, output.ErrorCount)
+	}
+	if output.Results[0].Content != "content1" || output.Results[1].Content != "content2" {
+		t.Errorf("unexpected content")
+	}
+}
+
+func TestHandleReadMultipleFiles_PartialFailure(t *testing.T) {
+	tempDir := t.TempDir()
+	h := NewHandler([]string{tempDir})
+
+	file1 := filepath.Join(tempDir, "exists.txt")
+	file2 := filepath.Join(tempDir, "nonexistent.txt")
+	os.WriteFile(file1, []byte("content1"), 0644)
+
+	input := ReadMultipleFilesInput{Paths: []string{file1, file2}}
+	result, output, _ := h.HandleReadMultipleFiles(context.Background(), nil, input)
+
+	if result.IsError {
+		t.Error("expected partial success, not tool error")
+	}
+	if output.SuccessCount != 1 || output.ErrorCount != 1 {
+		t.Errorf("expected 1 success, 1 error, got %d/%d", output.SuccessCount, output.ErrorCount)
+	}
+}
+
+func TestHandleReadMultipleFiles_EmptyPaths(t *testing.T) {
+	h := NewHandler([]string{t.TempDir()})
+	result, _, _ := h.HandleReadMultipleFiles(context.Background(), nil, ReadMultipleFilesInput{Paths: []string{}})
+	if !result.IsError {
+		t.Error("expected error for empty paths")
+	}
+}
+
+func TestHandleReadMultipleFiles_WithEncoding(t *testing.T) {
+	tempDir := t.TempDir()
+	h := NewHandler([]string{tempDir})
+
+	enc, _ := encoding.Get("cp1251")
+	cp1251Bytes, _ := enc.NewEncoder().Bytes([]byte("Здравей свят!"))
+	file1 := filepath.Join(tempDir, "cyrillic.txt")
+	os.WriteFile(file1, cp1251Bytes, 0644)
+
+	input := ReadMultipleFilesInput{Paths: []string{file1}, Encoding: "cp1251"}
+	_, output, _ := h.HandleReadMultipleFiles(context.Background(), nil, input)
+
+	if !strings.Contains(output.Results[0].Content, "Здравей свят!") {
+		t.Errorf("expected Cyrillic content, got %q", output.Results[0].Content)
+	}
+}
+
+func TestHandleReadMultipleFiles_PathOutsideAllowed(t *testing.T) {
+	tempDir := t.TempDir()
+	h := NewHandler([]string{tempDir})
+
+	input := ReadMultipleFilesInput{Paths: []string{filepath.Join(tempDir, "..", "..", "etc", "passwd")}}
+	_, output, _ := h.HandleReadMultipleFiles(context.Background(), nil, input)
+
+	if !strings.Contains(output.Results[0].Error, "access denied") {
+		t.Errorf("expected 'access denied' error, got %q", output.Results[0].Error)
+	}
+}

filetoolsserver/handler/types.go

@@ -192,3 +192,27 @@ type EditFileOutput struct {
 	Diff string `json:"diff"`
 }
 
+// ReadMultipleFilesInput defines input parameters for read_multiple_files tool.
+// Paths: Array of file paths to read (required, min 1)
+// Encoding: Encoding for all files - auto-detected per file if not specified (optional)
+type ReadMultipleFilesInput struct {
+	Paths    []string `json:"paths"`
+	Encoding string   `json:"encoding,omitempty"`
+}
+
+// FileReadResult represents the result of reading a single file
+type FileReadResult struct {
+	Path               string `json:"path"`
+	Content            string `json:"content,omitempty"`
+	Error              string `json:"error,omitempty"`
+	DetectedEncoding   string `json:"detectedEncoding,omitempty"`
+	EncodingConfidence int    `json:"encodingConfidence,omitempty"`
+}
+
+// ReadMultipleFilesOutput defines output for read_multiple_files tool
+type ReadMultipleFilesOutput struct {
+	Results      []FileReadResult `json:"results"`
+	SuccessCount int              `json:"successCount"`
+	ErrorCount   int              `json:"errorCount"`
+}
+

filetoolsserver/server.go

@@ -64,6 +64,16 @@ func NewServer(allowedDirs []string, logger *slog.Logger, cfg *config.Config) *m
 		},
 	}, handler.Wrap(logger, "read_text_file", h.HandleReadTextFile))
 
+	mcp.AddTool(server, &mcp.Tool{
+		Name:        "read_multiple_files",
+		Description: "Read the contents of multiple files simultaneously. More efficient than reading files one by one. Each file's content is returned with encoding info. Individual file failures don't stop the operation. Parameters: paths (required array of file paths), encoding (optional, applies to all files - auto-detected per file if not specified).",
+		Annotations: &mcp.ToolAnnotations{
+			Title:         "Read Multiple Files",
+			ReadOnlyHint:  true,
+			OpenWorldHint: boolPtr(false),
+		},
+	}, handler.Wrap(logger, "read_multiple_files", h.HandleReadMultipleFiles))
+
 	mcp.AddTool(server, &mcp.Tool{
 		Name:        "list_directory",
 		Description: "List files and directories with optional glob pattern filtering (e.g., *.pas, *.dfm). Parameters: path (required), pattern (optional, default: *).",