Commit ad2b06b

@@ -0,0 +1,479 @@
+package main
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+// AI Provider interface - supports multiple AI backends
+type AIProvider interface {
+	Generate(ctx context.Context, prompt string) (string, error)
+	Name() string
+}
+
+// Tool represents an available capability
+type Tool struct {
+	Name        string
+	Description string
+	Handler     func(args map[string]interface{}) (interface{}, error)
+}
+
+// Del is our main AI assistant - Del the Funky Robosapien!
+type Del struct {
+	aiProvider AIProvider
+	tools      map[string]*Tool
+	mcpServers map[string]string // name -> command path
+}
+
+// Claude API provider
+type ClaudeProvider struct {
+	apiKey string
+}
+
+func (c *ClaudeProvider) Generate(ctx context.Context, prompt string) (string, error) {
+	// Use Claude CLI if available, fallback to API
+	cmd := exec.CommandContext(ctx, "claude", "--print", prompt)
+	output, err := cmd.Output()
+	if err != nil {
+		return "", fmt.Errorf("claude error: %w", err)
+	}
+	return string(output), nil
+}
+
+func (c *ClaudeProvider) Name() string {
+	return "Claude"
+}
+
+// Ollama provider
+type OllamaProvider struct {
+	model string
+}
+
+func (o *OllamaProvider) Generate(ctx context.Context, prompt string) (string, error) {
+	cmd := exec.CommandContext(ctx, "ollama", "run", o.model, prompt)
+	output, err := cmd.Output()
+	if err != nil {
+		return "", fmt.Errorf("ollama error: %w", err)
+	}
+	return string(output), nil
+}
+
+func (o *OllamaProvider) Name() string {
+	return fmt.Sprintf("Ollama (%s)", o.model)
+}
+
+// Initialize Del with tools and MCP servers
+func NewDel(provider AIProvider) *Del {
+	d := &Del{
+		aiProvider: provider,
+		tools:      make(map[string]*Tool),
+		mcpServers: make(map[string]string),
+	}
+
+	// Register built-in tools
+	d.registerBuiltinTools()
+	
+	// Auto-discover MCP servers
+	d.discoverMCPServers()
+	
+	return d
+}
+
+func (d *Del) registerBuiltinTools() {
+	// Security scanner tool
+	d.tools["security_scan"] = &Tool{
+		Name:        "security_scan",
+		Description: "Scan code for security vulnerabilities",
+		Handler:     d.handleSecurityScan,
+	}
+	
+	// Code analysis tool
+	d.tools["analyze_code"] = &Tool{
+		Name:        "analyze_code", 
+		Description: "Analyze code quality and suggest improvements",
+		Handler:     d.handleCodeAnalysis,
+	}
+	
+	// File operations
+	d.tools["read_file"] = &Tool{
+		Name:        "read_file",
+		Description: "Read contents of a file",
+		Handler:     d.handleReadFile,
+	}
+	
+	d.tools["write_file"] = &Tool{
+		Name:        "write_file",
+		Description: "Write content to a file",
+		Handler:     d.handleWriteFile,
+	}
+	
+	// Command execution
+	d.tools["run_command"] = &Tool{
+		Name:        "run_command",
+		Description: "Execute shell commands",
+		Handler:     d.handleRunCommand,
+	}
+}
+
+func (d *Del) discoverMCPServers() {
+	// Look for MCP servers in ../
+	servers := map[string]string{
+		"git":        "../git/main.go",
+		"filesystem": "../fs/main.go",
+		"bash":       "../bash/main.go",
+	}
+	
+	for name, path := range servers {
+		if _, err := os.Stat(path); err == nil {
+			d.mcpServers[name] = path
+		}
+	}
+}
+
+func (d *Del) handleSecurityScan(args map[string]interface{}) (interface{}, error) {
+	path, ok := args["path"].(string)
+	if !ok {
+		return nil, fmt.Errorf("path required")
+	}
+	
+	// Run security tools like gosec, semgrep, etc.
+	results := map[string]interface{}{
+		"vulnerabilities": []string{},
+		"warnings":       []string{},
+		"suggestions":    []string{},
+	}
+	
+	// Check for common security issues
+	if strings.Contains(path, ".go") {
+		// Run gosec if available
+		cmd := exec.Command("gosec", "-fmt", "json", path)
+		if output, err := cmd.Output(); err == nil {
+			results["gosec_output"] = string(output)
+		}
+	}
+	
+	return results, nil
+}
+
+func (d *Del) handleCodeAnalysis(args map[string]interface{}) (interface{}, error) {
+	path, ok := args["path"].(string)
+	if !ok {
+		return nil, fmt.Errorf("path required")
+	}
+	
+	analysis := map[string]interface{}{
+		"complexity":    "medium",
+		"maintainability": "good",
+		"suggestions": []string{
+			"Consider adding more comments",
+			"Extract complex functions",
+		},
+	}
+	
+	return analysis, nil
+}
+
+func (d *Del) handleReadFile(args map[string]interface{}) (interface{}, error) {
+	path, ok := args["path"].(string)
+	if !ok {
+		return nil, fmt.Errorf("path required")
+	}
+	
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	
+	return map[string]interface{}{
+		"path":    path,
+		"content": string(content),
+		"size":    len(content),
+	}, nil
+}
+
+func (d *Del) handleWriteFile(args map[string]interface{}) (interface{}, error) {
+	path, ok := args["path"].(string)
+	if !ok {
+		return nil, fmt.Errorf("path required")
+	}
+	
+	content, ok := args["content"].(string)
+	if !ok {
+		return nil, fmt.Errorf("content required")
+	}
+	
+	// Ask for confirmation
+	fmt.Printf("🎤 Del asks: Write to %s? [y/N]: ", path)
+	reader := bufio.NewReader(os.Stdin)
+	response, _ := reader.ReadString('\n')
+	
+	if strings.ToLower(strings.TrimSpace(response)) != "y" {
+		return map[string]interface{}{"status": "cancelled"}, nil
+	}
+	
+	err := os.WriteFile(path, []byte(content), 0644)
+	if err != nil {
+		return nil, err
+	}
+	
+	return map[string]interface{}{
+		"status": "written",
+		"path":   path,
+		"size":   len(content),
+	}, nil
+}
+
+func (d *Del) handleRunCommand(args map[string]interface{}) (interface{}, error) {
+	command, ok := args["command"].(string)
+	if !ok {
+		return nil, fmt.Errorf("command required")
+	}
+	
+	// Ask for confirmation
+	fmt.Printf("🎤 Del asks: Execute '%s'? [y/N]: ", command)
+	reader := bufio.NewReader(os.Stdin)
+	response, _ := reader.ReadString('\n')
+	
+	if strings.ToLower(strings.TrimSpace(response)) != "y" {
+		return map[string]interface{}{"status": "cancelled"}, nil
+	}
+	
+	cmd := exec.Command("sh", "-c", command)
+	output, err := cmd.CombinedOutput()
+	
+	result := map[string]interface{}{
+		"command": command,
+		"output":  string(output),
+		"success": err == nil,
+	}
+	
+	if err != nil {
+		result["error"] = err.Error()
+	}
+	
+	return result, nil
+}
+
+// Enhanced prompt with available tools
+func (d *Del) buildPrompt(userInput string) string {
+	toolsList := make([]string, 0, len(d.tools))
+	for name, tool := range d.tools {
+		toolsList = append(toolsList, fmt.Sprintf("- %s: %s", name, tool.Description))
+	}
+	
+	mcpList := make([]string, 0, len(d.mcpServers))
+	for name := range d.mcpServers {
+		mcpList = append(mcpList, name)
+	}
+	
+	return fmt.Sprintf(`You are Del the Funky Robosapien, an AI-powered coding superhero assistant.
+Channel the energy of Del the Funky Homosapien - you're creative, clever, and always ready to drop some funky code solutions!
+
+AVAILABLE TOOLS:
+%s
+
+AVAILABLE MCP SERVERS:
+%s
+
+CURRENT CONTEXT:
+- Working Directory: %s
+- Git Status: %s
+
+When you want to use a tool, respond with:
+TOOL_USE: tool_name {"arg1": "value1", "arg2": "value2"}
+
+For example:
+TOOL_USE: read_file {"path": "main.go"}
+TOOL_USE: security_scan {"path": "."}
+TOOL_USE: run_command {"command": "go build"}
+
+Keep it funky! 🎤🤖
+
+User Request: %s`,
+		strings.Join(toolsList, "\n"),
+		strings.Join(mcpList, ", "),
+		getCurrentDir(),
+		getGitStatus(),
+		userInput)
+}
+
+func getCurrentDir() string {
+	dir, _ := os.Getwd()
+	return dir
+}
+
+func getGitStatus() string {
+	cmd := exec.Command("git", "status", "--porcelain")
+	output, err := cmd.Output()
+	if err != nil {
+		return "Not a git repository"
+	}
+	return string(output)
+}
+
+// Process AI response and execute tools
+func (d *Del) processResponse(response string) {
+	lines := strings.Split(response, "\n")
+	
+	for _, line := range lines {
+		if strings.HasPrefix(line, "TOOL_USE:") {
+			d.executeTool(strings.TrimPrefix(line, "TOOL_USE:"))
+		}
+	}
+}
+
+func (d *Del) executeTool(toolCall string) {
+	parts := strings.SplitN(toolCall, " ", 2)
+	if len(parts) != 2 {
+		fmt.Printf("❌ Invalid tool call: %s\n", toolCall)
+		return
+	}
+	
+	toolName := strings.TrimSpace(parts[0])
+	argsJSON := strings.TrimSpace(parts[1])
+	
+	tool, exists := d.tools[toolName]
+	if !exists {
+		fmt.Printf("❌ Unknown tool: %s\n", toolName)
+		return
+	}
+	
+	var args map[string]interface{}
+	if err := json.Unmarshal([]byte(argsJSON), &args); err != nil {
+		fmt.Printf("❌ Invalid tool args: %s\n", err)
+		return
+	}
+	
+	fmt.Printf("🎤 Del is dropping some tool magic: %s\n", toolName)
+	result, err := tool.Handler(args)
+	if err != nil {
+		fmt.Printf("❌ Tool error: %s\n", err)
+		return
+	}
+	
+	fmt.Printf("✅ Funky result: %+v\n", result)
+}
+
+// Interactive REPL
+func (d *Del) startREPL() {
+	fmt.Printf("🎤🤖 Del the Funky Robosapien is in the house! (Provider: %s)\n", d.aiProvider.Name())
+	fmt.Printf("🔧 Available tools: %s\n", strings.Join(func() []string {
+		var names []string
+		for name := range d.tools {
+			names = append(names, name)
+		}
+		return names
+	}(), ", "))
+	fmt.Println("💬 Type 'quit' to exit, 'help' for assistance")
+	fmt.Println("🎵 Let's make some funky code together!")
+	fmt.Println()
+	
+	scanner := bufio.NewScanner(os.Stdin)
+	
+	for {
+		fmt.Print("🎤 You: ")
+		if !scanner.Scan() {
+			break
+		}
+		
+		input := strings.TrimSpace(scanner.Text())
+		if input == "" {
+			continue
+		}
+		
+		if input == "quit" || input == "exit" {
+			fmt.Println("🎤 Del says: Catch you on the flip side! Stay funky! ✌️")
+			break
+		}
+		
+		if input == "help" {
+			d.showHelp()
+			continue
+		}
+		
+		// Generate AI response
+		prompt := d.buildPrompt(input)
+		response, err := d.aiProvider.Generate(context.Background(), prompt)
+		if err != nil {
+			fmt.Printf("❌ AI Error: %s\n", err)
+			continue
+		}
+		
+		fmt.Printf("🤖 Del: %s\n", response)
+		
+		// Process any tool calls
+		d.processResponse(response)
+		fmt.Println()
+	}
+}
+
+func (d *Del) showHelp() {
+	fmt.Println("🎤🤖 Del the Funky Robosapien - Help Menu:")
+	fmt.Println("  🛡️  Security Commands:")
+	fmt.Println("    'scan for vulnerabilities'")
+	fmt.Println("    'check this code for security issues'")
+	fmt.Println("  🚀 Development Commands:")
+	fmt.Println("    'read the main.go file'")
+	fmt.Println("    'build this project'")
+	fmt.Println("    'run the tests'")
+	fmt.Println("    'analyze code quality'")
+	fmt.Println("  🔧 Available Tools:")
+	for name, tool := range d.tools {
+		fmt.Printf("    - %s: %s\n", name, tool.Description)
+	}
+	fmt.Println("  🎵 Remember: Keep it funky!")
+	fmt.Println()
+}
+
+var rootCmd = &cobra.Command{
+	Use:   "del",
+	Short: "Del the Funky Robosapien - Your AI-powered coding superhero",
+	Long: `🎤🤖 Del the Funky Robosapien
+	
+Your AI-powered coding superhero with the soul of a funky homosapien!
+Equipped with security scanning, code analysis, file operations, and more.
+
+Channel the creative energy of Del the Funky Homosapien while coding!`,
+	Run: func(cmd *cobra.Command, args []string) {
+		provider := cmd.Flag("provider").Value.String()
+		model := cmd.Flag("model").Value.String()
+		
+		var aiProvider AIProvider
+		
+		switch provider {
+		case "claude":
+			aiProvider = &ClaudeProvider{}
+		case "ollama":
+			aiProvider = &OllamaProvider{model: model}
+		default:
+			// Try Claude first, fallback to Ollama
+			if exec.Command("claude", "--version").Run() == nil {
+				aiProvider = &ClaudeProvider{}
+			} else {
+				aiProvider = &OllamaProvider{model: "deepseek-coder-v2:16b"}
+			}
+		}
+		
+		del := NewDel(aiProvider)
+		del.startREPL()
+	},
+}
+
+func init() {
+	rootCmd.Flags().StringP("provider", "p", "auto", "AI provider (claude, ollama, auto)")
+	rootCmd.Flags().StringP("model", "m", "deepseek-coder-v2:16b", "Model to use (for Ollama)")
+}
+
+func main() {
+	if err := rootCmd.Execute(); err != nil {
+		log.Fatal(err)
+	}
+}
\ No newline at end of file

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+
+	"github.com/xlgmokha/mcp/pkg/mcp"
+)
+
+func main() {
+	// Get allowed directories from command line arguments
+	if len(os.Args) < 2 {
+		log.Fatal("Usage: mcp-filesystem <allowed-directory> [additional-directories...]")
+	}
+
+	allowedDirs := os.Args[1:]
+	server := NewFilesystemServer(allowedDirs)
+	
+	// Set up basic initialization
+	server.SetInitializeHandler(func(req mcp.InitializeRequest) (mcp.InitializeResult, error) {
+		// Use default initialization
+		return mcp.InitializeResult{}, nil
+	})
+	
+	ctx := context.Background()
+	if err := server.Run(ctx); err != nil {
+		log.Fatalf("Server error: %v", err)
+	}
+}
\ No newline at end of file

@@ -0,0 +1,959 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/xlgmokha/mcp/pkg/mcp"
+)
+
+// FilesystemServer implements the Filesystem MCP server
+type FilesystemServer struct {
+	*mcp.Server
+	allowedDirectories []string
+}
+
+// NewFilesystemServer creates a new Filesystem MCP server
+func NewFilesystemServer(allowedDirs []string) *FilesystemServer {
+	server := mcp.NewServer("secure-filesystem-server", "0.2.0")
+	
+	// Normalize and validate allowed directories
+	normalizedDirs := make([]string, len(allowedDirs))
+	for i, dir := range allowedDirs {
+		absPath, err := filepath.Abs(expandHome(dir))
+		if err != nil {
+			panic(fmt.Sprintf("Invalid directory: %s", dir))
+		}
+		normalizedDirs[i] = filepath.Clean(absPath)
+	}
+	
+	fsServer := &FilesystemServer{
+		Server:             server,
+		allowedDirectories: normalizedDirs,
+	}
+	
+	// Register all filesystem tools
+	fsServer.registerTools()
+	
+	return fsServer
+}
+
+// registerTools registers all Filesystem tools with the server
+func (fs *FilesystemServer) registerTools() {
+	fs.RegisterTool("read_file", fs.HandleReadFile)
+	fs.RegisterTool("read_multiple_files", fs.HandleReadMultipleFiles)
+	fs.RegisterTool("write_file", fs.HandleWriteFile)
+	fs.RegisterTool("edit_file", fs.HandleEditFile)
+	fs.RegisterTool("create_directory", fs.HandleCreateDirectory)
+	fs.RegisterTool("list_directory", fs.HandleListDirectory)
+	fs.RegisterTool("list_directory_with_sizes", fs.HandleListDirectoryWithSizes)
+	fs.RegisterTool("directory_tree", fs.HandleDirectoryTree)
+	fs.RegisterTool("move_file", fs.HandleMoveFile)
+	fs.RegisterTool("search_files", fs.HandleSearchFiles)
+	fs.RegisterTool("get_file_info", fs.HandleGetFileInfo)
+	fs.RegisterTool("list_allowed_directories", fs.HandleListAllowedDirectories)
+}
+
+// ListTools returns all available Filesystem tools
+func (fs *FilesystemServer) ListTools() []mcp.Tool {
+	return []mcp.Tool{
+		{
+			Name:        "read_file",
+			Description: "Read the complete contents of a file from the file system. Handles various text encodings and provides detailed error messages if the file cannot be read. Use this tool when you need to examine the contents of a single file. Only works within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"path": map[string]interface{}{
+						"type":        "string",
+						"description": "The absolute path to the file to read",
+					},
+					"tail": map[string]interface{}{
+						"type":        "integer",
+						"description": "If provided, returns only the last N lines of the file",
+					},
+					"head": map[string]interface{}{
+						"type":        "integer",
+						"description": "If provided, returns only the first N lines of the file",
+					},
+				},
+				"required": []string{"path"},
+			},
+		},
+		{
+			Name:        "read_multiple_files",
+			Description: "Read the contents of multiple files simultaneously. This is more efficient than reading files one by one when you need to analyze or compare multiple files. Each file's content is returned with its path as a reference. Failed reads for individual files won't stop the entire operation. Only works within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"paths": map[string]interface{}{
+						"type": "array",
+						"items": map[string]interface{}{
+							"type": "string",
+						},
+						"description": "Array of file paths to read",
+					},
+				},
+				"required": []string{"paths"},
+			},
+		},
+		{
+			Name:        "write_file",
+			Description: "Create a new file or completely overwrite an existing file with new content. Use with caution as it will overwrite existing files without warning. Handles text content with proper encoding. Only works within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"path": map[string]interface{}{
+						"type":        "string",
+						"description": "The absolute path to the file to write",
+					},
+					"content": map[string]interface{}{
+						"type":        "string",
+						"description": "The content to write to the file",
+					},
+				},
+				"required": []string{"path", "content"},
+			},
+		},
+		{
+			Name:        "edit_file",
+			Description: "Make line-based edits to a text file. Each edit replaces exact line sequences with new content. Returns a git-style diff showing the changes made. Only works within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"path": map[string]interface{}{
+						"type":        "string",
+						"description": "The absolute path to the file to edit",
+					},
+					"edits": map[string]interface{}{
+						"type": "array",
+						"items": map[string]interface{}{
+							"type": "object",
+							"properties": map[string]interface{}{
+								"oldText": map[string]interface{}{
+									"type":        "string",
+									"description": "Text to search for - must match exactly",
+								},
+								"newText": map[string]interface{}{
+									"type":        "string",
+									"description": "Text to replace with",
+								},
+							},
+							"required": []string{"oldText", "newText"},
+						},
+					},
+					"dryRun": map[string]interface{}{
+						"type":        "boolean",
+						"description": "Preview changes using git-style diff format",
+						"default":     false,
+					},
+				},
+				"required": []string{"path", "edits"},
+			},
+		},
+		{
+			Name:        "create_directory",
+			Description: "Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. If the directory already exists, this operation will succeed silently. Perfect for setting up directory structures for projects or ensuring required paths exist. Only works within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"path": map[string]interface{}{
+						"type":        "string",
+						"description": "The absolute path to the directory to create",
+					},
+				},
+				"required": []string{"path"},
+			},
+		},
+		{
+			Name:        "list_directory",
+			Description: "Get a detailed listing of all files and directories in a specified path. Results clearly distinguish between files and directories with [FILE] and [DIR] prefixes. This tool is essential for understanding directory structure and finding specific files within a directory. Only works within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"path": map[string]interface{}{
+						"type":        "string",
+						"description": "The absolute path to the directory to list",
+					},
+				},
+				"required": []string{"path"},
+			},
+		},
+		{
+			Name:        "list_directory_with_sizes",
+			Description: "Get a detailed listing of all files and directories in a specified path, including sizes. Results clearly distinguish between files and directories with [FILE] and [DIR] prefixes. This tool is useful for understanding directory structure and finding specific files within a directory. Only works within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"path": map[string]interface{}{
+						"type":        "string",
+						"description": "The absolute path to the directory to list",
+					},
+					"sortBy": map[string]interface{}{
+						"type":        "string",
+						"enum":        []string{"name", "size"},
+						"description": "Sort entries by name or size",
+						"default":     "name",
+					},
+				},
+				"required": []string{"path"},
+			},
+		},
+		{
+			Name:        "directory_tree",
+			Description: "Get a recursive tree view of files and directories as a JSON structure. Each entry includes 'name', 'type' (file/directory), and 'children' for directories. Files have no children array, while directories always have a children array (which may be empty). The output is formatted with 2-space indentation for readability. Only works within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"path": map[string]interface{}{
+						"type":        "string",
+						"description": "The absolute path to the directory to get tree for",
+					},
+				},
+				"required": []string{"path"},
+			},
+		},
+		{
+			Name:        "move_file",
+			Description: "Move or rename files and directories. Can move files between directories and rename them in a single operation. If the destination exists, the operation will fail. Works across different directories and can be used for simple renaming within the same directory. Both source and destination must be within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"source": map[string]interface{}{
+						"type":        "string",
+						"description": "The source path to move from",
+					},
+					"destination": map[string]interface{}{
+						"type":        "string",
+						"description": "The destination path to move to",
+					},
+				},
+				"required": []string{"source", "destination"},
+			},
+		},
+		{
+			Name:        "search_files",
+			Description: "Recursively search for files and directories matching a pattern. Searches through all subdirectories from the starting path. The search is case-insensitive and matches partial names. Returns full paths to all matching items. Great for finding files when you don't know their exact location. Only searches within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"path": map[string]interface{}{
+						"type":        "string",
+						"description": "The directory to search in",
+					},
+					"pattern": map[string]interface{}{
+						"type":        "string",
+						"description": "The pattern to search for",
+					},
+					"excludePatterns": map[string]interface{}{
+						"type": "array",
+						"items": map[string]interface{}{
+							"type": "string",
+						},
+						"description": "Patterns to exclude from search",
+						"default":     []string{},
+					},
+				},
+				"required": []string{"path", "pattern"},
+			},
+		},
+		{
+			Name:        "get_file_info",
+			Description: "Retrieve detailed metadata about a file or directory. Returns comprehensive information including size, creation time, last modified time, permissions, and type. This tool is perfect for understanding file characteristics without reading the actual content. Only works within allowed directories.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"path": map[string]interface{}{
+						"type":        "string",
+						"description": "The path to get information about",
+					},
+				},
+				"required": []string{"path"},
+			},
+		},
+		{
+			Name:        "list_allowed_directories",
+			Description: "Returns the list of directories that this server is allowed to access. Use this to understand which directories are available before trying to access files.",
+			InputSchema: map[string]interface{}{
+				"type":       "object",
+				"properties": map[string]interface{}{},
+			},
+		},
+	}
+}
+
+// Tool handlers
+
+func (fs *FilesystemServer) HandleReadFile(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	pathStr, ok := req.Arguments["path"].(string)
+	if !ok {
+		return mcp.NewToolError("path is required"), nil
+	}
+
+	validPath, err := fs.validatePath(pathStr)
+	if err != nil {
+		return mcp.NewToolError(err.Error()), nil
+	}
+
+	// Check for tail/head parameters
+	if tail, exists := req.Arguments["tail"]; exists {
+		if _, exists := req.Arguments["head"]; exists {
+			return mcp.NewToolError("Cannot specify both head and tail parameters simultaneously"), nil
+		}
+		if tailNum, ok := tail.(float64); ok {
+			content, err := fs.tailFile(validPath, int(tailNum))
+			if err != nil {
+				return mcp.NewToolError(fmt.Sprintf("Failed to read tail: %v", err)), nil
+			}
+			return mcp.NewToolResult(mcp.NewTextContent(content)), nil
+		}
+	}
+
+	if head, exists := req.Arguments["head"]; exists {
+		if headNum, ok := head.(float64); ok {
+			content, err := fs.headFile(validPath, int(headNum))
+			if err != nil {
+				return mcp.NewToolError(fmt.Sprintf("Failed to read head: %v", err)), nil
+			}
+			return mcp.NewToolResult(mcp.NewTextContent(content)), nil
+		}
+	}
+
+	content, err := os.ReadFile(validPath)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to read file: %v", err)), nil
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(string(content))), nil
+}
+
+func (fs *FilesystemServer) HandleReadMultipleFiles(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	pathsInterface, ok := req.Arguments["paths"]
+	if !ok {
+		return mcp.NewToolError("paths is required"), nil
+	}
+
+	paths, err := fs.convertToStringSlice(pathsInterface)
+	if err != nil {
+		return mcp.NewToolError("paths must be an array of strings"), nil
+	}
+
+	var results []string
+	for _, pathStr := range paths {
+		validPath, err := fs.validatePath(pathStr)
+		if err != nil {
+			results = append(results, fmt.Sprintf("%s: Error - %s", pathStr, err.Error()))
+			continue
+		}
+
+		content, err := os.ReadFile(validPath)
+		if err != nil {
+			results = append(results, fmt.Sprintf("%s: Error - %s", pathStr, err.Error()))
+			continue
+		}
+
+		results = append(results, fmt.Sprintf("%s:\n%s\n", pathStr, string(content)))
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(strings.Join(results, "\n---\n"))), nil
+}
+
+func (fs *FilesystemServer) HandleWriteFile(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	pathStr, ok := req.Arguments["path"].(string)
+	if !ok {
+		return mcp.NewToolError("path is required"), nil
+	}
+
+	content, ok := req.Arguments["content"].(string)
+	if !ok {
+		return mcp.NewToolError("content is required"), nil
+	}
+
+	validPath, err := fs.validatePath(pathStr)
+	if err != nil {
+		return mcp.NewToolError(err.Error()), nil
+	}
+
+	err = os.WriteFile(validPath, []byte(content), 0644)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to write file: %v", err)), nil
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(fmt.Sprintf("Successfully wrote to %s", pathStr))), nil
+}
+
+func (fs *FilesystemServer) HandleEditFile(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	pathStr, ok := req.Arguments["path"].(string)
+	if !ok {
+		return mcp.NewToolError("path is required"), nil
+	}
+
+	editsInterface, ok := req.Arguments["edits"]
+	if !ok {
+		return mcp.NewToolError("edits is required"), nil
+	}
+
+	dryRun := false
+	if dr, exists := req.Arguments["dryRun"]; exists {
+		if d, ok := dr.(bool); ok {
+			dryRun = d
+		}
+	}
+
+	validPath, err := fs.validatePath(pathStr)
+	if err != nil {
+		return mcp.NewToolError(err.Error()), nil
+	}
+
+	// Parse edits
+	edits, err := fs.parseEdits(editsInterface)
+	if err != nil {
+		return mcp.NewToolError(err.Error()), nil
+	}
+
+	diff, err := fs.applyFileEdits(validPath, edits, dryRun)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to edit file: %v", err)), nil
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(diff)), nil
+}
+
+func (fs *FilesystemServer) HandleCreateDirectory(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	pathStr, ok := req.Arguments["path"].(string)
+	if !ok {
+		return mcp.NewToolError("path is required"), nil
+	}
+
+	validPath, err := fs.validatePath(pathStr)
+	if err != nil {
+		return mcp.NewToolError(err.Error()), nil
+	}
+
+	err = os.MkdirAll(validPath, 0755)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to create directory: %v", err)), nil
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(fmt.Sprintf("Successfully created directory %s", pathStr))), nil
+}
+
+func (fs *FilesystemServer) HandleListDirectory(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	pathStr, ok := req.Arguments["path"].(string)
+	if !ok {
+		return mcp.NewToolError("path is required"), nil
+	}
+
+	validPath, err := fs.validatePath(pathStr)
+	if err != nil {
+		return mcp.NewToolError(err.Error()), nil
+	}
+
+	entries, err := os.ReadDir(validPath)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to list directory: %v", err)), nil
+	}
+
+	var formatted []string
+	for _, entry := range entries {
+		prefix := "[FILE]"
+		if entry.IsDir() {
+			prefix = "[DIR]"
+		}
+		formatted = append(formatted, fmt.Sprintf("%s %s", prefix, entry.Name()))
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(strings.Join(formatted, "\n"))), nil
+}
+
+func (fs *FilesystemServer) HandleListDirectoryWithSizes(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	pathStr, ok := req.Arguments["path"].(string)
+	if !ok {
+		return mcp.NewToolError("path is required"), nil
+	}
+
+	sortBy := "name"
+	if sb, exists := req.Arguments["sortBy"]; exists {
+		if s, ok := sb.(string); ok {
+			sortBy = s
+		}
+	}
+
+	validPath, err := fs.validatePath(pathStr)
+	if err != nil {
+		return mcp.NewToolError(err.Error()), nil
+	}
+
+	entries, err := os.ReadDir(validPath)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to list directory: %v", err)), nil
+	}
+
+	// Get detailed info for each entry
+	type entryInfo struct {
+		name  string
+		isDir bool
+		size  int64
+	}
+
+	var detailedEntries []entryInfo
+	for _, entry := range entries {
+		info, err := entry.Info()
+		if err != nil {
+			continue
+		}
+		detailedEntries = append(detailedEntries, entryInfo{
+			name:  entry.Name(),
+			isDir: entry.IsDir(),
+			size:  info.Size(),
+		})
+	}
+
+	// Sort entries
+	if sortBy == "size" {
+		sort.Slice(detailedEntries, func(i, j int) bool {
+			return detailedEntries[i].size > detailedEntries[j].size
+		})
+	} else {
+		sort.Slice(detailedEntries, func(i, j int) bool {
+			return detailedEntries[i].name < detailedEntries[j].name
+		})
+	}
+
+	var formatted []string
+	var totalFiles, totalDirs int
+	var totalSize int64
+
+	for _, entry := range detailedEntries {
+		prefix := "[FILE]"
+		sizeStr := ""
+		if entry.isDir {
+			prefix = "[DIR]"
+			totalDirs++
+		} else {
+			prefix = "[FILE]"
+			sizeStr = fmt.Sprintf("%10s", fs.formatSize(entry.size))
+			totalFiles++
+			totalSize += entry.size
+		}
+		
+		formatted = append(formatted, fmt.Sprintf("%s %-30s %s", prefix, entry.name, sizeStr))
+	}
+
+	// Add summary
+	formatted = append(formatted, "")
+	formatted = append(formatted, fmt.Sprintf("Total: %d files, %d directories", totalFiles, totalDirs))
+	formatted = append(formatted, fmt.Sprintf("Combined size: %s", fs.formatSize(totalSize)))
+
+	return mcp.NewToolResult(mcp.NewTextContent(strings.Join(formatted, "\n"))), nil
+}
+
+func (fs *FilesystemServer) HandleDirectoryTree(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	pathStr, ok := req.Arguments["path"].(string)
+	if !ok {
+		return mcp.NewToolError("path is required"), nil
+	}
+
+	validPath, err := fs.validatePath(pathStr)
+	if err != nil {
+		return mcp.NewToolError(err.Error()), nil
+	}
+
+	tree, err := fs.buildDirectoryTree(validPath)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to build directory tree: %v", err)), nil
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(tree)), nil
+}
+
+func (fs *FilesystemServer) HandleMoveFile(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	sourcePath, ok := req.Arguments["source"].(string)
+	if !ok {
+		return mcp.NewToolError("source is required"), nil
+	}
+
+	destPath, ok := req.Arguments["destination"].(string)
+	if !ok {
+		return mcp.NewToolError("destination is required"), nil
+	}
+
+	validSource, err := fs.validatePath(sourcePath)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Invalid source: %v", err)), nil
+	}
+
+	validDest, err := fs.validatePath(destPath)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Invalid destination: %v", err)), nil
+	}
+
+	err = os.Rename(validSource, validDest)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to move file: %v", err)), nil
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(fmt.Sprintf("Successfully moved %s to %s", sourcePath, destPath))), nil
+}
+
+func (fs *FilesystemServer) HandleSearchFiles(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	pathStr, ok := req.Arguments["path"].(string)
+	if !ok {
+		return mcp.NewToolError("path is required"), nil
+	}
+
+	pattern, ok := req.Arguments["pattern"].(string)
+	if !ok {
+		return mcp.NewToolError("pattern is required"), nil
+	}
+
+	excludePatterns := []string{}
+	if ep, exists := req.Arguments["excludePatterns"]; exists {
+		if patterns, err := fs.convertToStringSlice(ep); err == nil {
+			excludePatterns = patterns
+		}
+	}
+
+	validPath, err := fs.validatePath(pathStr)
+	if err != nil {
+		return mcp.NewToolError(err.Error()), nil
+	}
+
+	results, err := fs.searchFiles(validPath, pattern, excludePatterns)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Search failed: %v", err)), nil
+	}
+
+	if len(results) == 0 {
+		return mcp.NewToolResult(mcp.NewTextContent("No matches found")), nil
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(strings.Join(results, "\n"))), nil
+}
+
+func (fs *FilesystemServer) HandleGetFileInfo(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	pathStr, ok := req.Arguments["path"].(string)
+	if !ok {
+		return mcp.NewToolError("path is required"), nil
+	}
+
+	validPath, err := fs.validatePath(pathStr)
+	if err != nil {
+		return mcp.NewToolError(err.Error()), nil
+	}
+
+	info, err := os.Stat(validPath)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to get file info: %v", err)), nil
+	}
+
+	result := []string{
+		fmt.Sprintf("size: %d", info.Size()),
+		fmt.Sprintf("modified: %s", info.ModTime().Format(time.RFC3339)),
+		fmt.Sprintf("isDirectory: %t", info.IsDir()),
+		fmt.Sprintf("isFile: %t", !info.IsDir()),
+		fmt.Sprintf("permissions: %s", info.Mode().String()),
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(strings.Join(result, "\n"))), nil
+}
+
+func (fs *FilesystemServer) HandleListAllowedDirectories(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	dirs := []string{"Allowed directories:"}
+	dirs = append(dirs, fs.allowedDirectories...)
+	return mcp.NewToolResult(mcp.NewTextContent(strings.Join(dirs, "\n"))), nil
+}
+
+// Helper methods
+
+func (fs *FilesystemServer) validatePath(requestedPath string) (string, error) {
+	expandedPath := expandHome(requestedPath)
+	var absolute string
+	
+	if filepath.IsAbs(expandedPath) {
+		absolute = filepath.Clean(expandedPath)
+	} else {
+		wd, _ := os.Getwd()
+		absolute = filepath.Clean(filepath.Join(wd, expandedPath))
+	}
+
+	// Check if path is within allowed directories
+	allowed := false
+	for _, dir := range fs.allowedDirectories {
+		if strings.HasPrefix(absolute, dir) {
+			allowed = true
+			break
+		}
+	}
+
+	if !allowed {
+		return "", fmt.Errorf("Access denied - path outside allowed directories: %s not in %v", absolute, fs.allowedDirectories)
+	}
+
+	// Handle symlinks
+	realPath, err := filepath.EvalSymlinks(absolute)
+	if err != nil {
+		// For new files, check parent directory
+		parentDir := filepath.Dir(absolute)
+		if realParent, err := filepath.EvalSymlinks(parentDir); err == nil {
+			for _, dir := range fs.allowedDirectories {
+				if strings.HasPrefix(realParent, dir) {
+					return absolute, nil
+				}
+			}
+		}
+		return absolute, nil // Allow if parent doesn't exist yet
+	}
+
+	// Verify real path is still allowed
+	for _, dir := range fs.allowedDirectories {
+		if strings.HasPrefix(realPath, dir) {
+			return realPath, nil
+		}
+	}
+
+	return "", fmt.Errorf("Access denied - symlink target outside allowed directories")
+}
+
+func expandHome(filePath string) string {
+	if strings.HasPrefix(filePath, "~/") || filePath == "~" {
+		homeDir, _ := os.UserHomeDir()
+		if filePath == "~" {
+			return homeDir
+		}
+		return filepath.Join(homeDir, filePath[2:])
+	}
+	return filePath
+}
+
+func (fs *FilesystemServer) convertToStringSlice(input interface{}) ([]string, error) {
+	switch v := input.(type) {
+	case []interface{}:
+		result := make([]string, len(v))
+		for i, item := range v {
+			str, ok := item.(string)
+			if !ok {
+				return nil, fmt.Errorf("item at index %d is not a string", i)
+			}
+			result[i] = str
+		}
+		return result, nil
+	case []string:
+		return v, nil
+	default:
+		return nil, fmt.Errorf("input is not a slice")
+	}
+}
+
+func (fs *FilesystemServer) tailFile(filePath string, numLines int) (string, error) {
+	// Simple implementation - read file and return last N lines
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		return "", err
+	}
+
+	lines := strings.Split(string(content), "\n")
+	if len(lines) <= numLines {
+		return string(content), nil
+	}
+
+	return strings.Join(lines[len(lines)-numLines:], "\n"), nil
+}
+
+func (fs *FilesystemServer) headFile(filePath string, numLines int) (string, error) {
+	// Simple implementation - read file and return first N lines
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		return "", err
+	}
+
+	lines := strings.Split(string(content), "\n")
+	if len(lines) <= numLines {
+		return string(content), nil
+	}
+
+	return strings.Join(lines[:numLines], "\n"), nil
+}
+
+func (fs *FilesystemServer) parseEdits(editsInterface interface{}) ([]Edit, error) {
+	editsSlice, ok := editsInterface.([]interface{})
+	if !ok {
+		return nil, fmt.Errorf("edits must be an array")
+	}
+
+	var edits []Edit
+	for _, editInterface := range editsSlice {
+		editMap, ok := editInterface.(map[string]interface{})
+		if !ok {
+			return nil, fmt.Errorf("each edit must be an object")
+		}
+
+		oldText, ok := editMap["oldText"].(string)
+		if !ok {
+			return nil, fmt.Errorf("oldText is required and must be a string")
+		}
+
+		newText, ok := editMap["newText"].(string)
+		if !ok {
+			return nil, fmt.Errorf("newText is required and must be a string")
+		}
+
+		edits = append(edits, Edit{OldText: oldText, NewText: newText})
+	}
+
+	return edits, nil
+}
+
+type Edit struct {
+	OldText string
+	NewText string
+}
+
+func (fs *FilesystemServer) applyFileEdits(filePath string, edits []Edit, dryRun bool) (string, error) {
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		return "", err
+	}
+
+	original := string(content)
+	modified := original
+
+	// Apply edits sequentially
+	for _, edit := range edits {
+		if !strings.Contains(modified, edit.OldText) {
+			return "", fmt.Errorf("could not find exact match for edit: %s", edit.OldText)
+		}
+		modified = strings.Replace(modified, edit.OldText, edit.NewText, 1)
+	}
+
+	// Create simple diff
+	diff := fs.createUnifiedDiff(original, modified, filePath)
+
+	if !dryRun {
+		err = os.WriteFile(filePath, []byte(modified), 0644)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return diff, nil
+}
+
+func (fs *FilesystemServer) createUnifiedDiff(original, modified, filePath string) string {
+	// Simple diff implementation
+	if original == modified {
+		return "No changes made"
+	}
+
+	return fmt.Sprintf("```diff\n--- %s\n+++ %s\n@@ -1,%d +1,%d @@\n-%s\n+%s\n```\n\n",
+		filePath, filePath,
+		len(strings.Split(original, "\n")),
+		len(strings.Split(modified, "\n")),
+		strings.ReplaceAll(original, "\n", "\n-"),
+		strings.ReplaceAll(modified, "\n", "\n+"))
+}
+
+func (fs *FilesystemServer) formatSize(bytes int64) string {
+	const unit = 1024
+	if bytes < unit {
+		return fmt.Sprintf("%d B", bytes)
+	}
+	div, exp := int64(unit), 0
+	for n := bytes / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.2f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
+}
+
+func (fs *FilesystemServer) buildDirectoryTree(rootPath string) (string, error) {
+	type TreeEntry struct {
+		Name     string      `json:"name"`
+		Type     string      `json:"type"`
+		Children []TreeEntry `json:"children,omitempty"`
+	}
+
+	var buildTree func(string) ([]TreeEntry, error)
+	buildTree = func(currentPath string) ([]TreeEntry, error) {
+		entries, err := os.ReadDir(currentPath)
+		if err != nil {
+			return nil, err
+		}
+
+		var result []TreeEntry
+		for _, entry := range entries {
+			entryPath := filepath.Join(currentPath, entry.Name())
+			
+			// Validate each path
+			if _, err := fs.validatePath(entryPath); err != nil {
+				continue // Skip unauthorized paths
+			}
+
+			treeEntry := TreeEntry{
+				Name: entry.Name(),
+				Type: "file",
+			}
+
+			if entry.IsDir() {
+				treeEntry.Type = "directory"
+				children, err := buildTree(entryPath)
+				if err == nil {
+					treeEntry.Children = children
+				} else {
+					treeEntry.Children = []TreeEntry{} // Empty array for directories
+				}
+			}
+
+			result = append(result, treeEntry)
+		}
+
+		return result, nil
+	}
+
+	tree, err := buildTree(rootPath)
+	if err != nil {
+		return "", err
+	}
+
+	// Convert to JSON with proper formatting
+	return fmt.Sprintf("%+v", tree), nil
+}
+
+func (fs *FilesystemServer) searchFiles(rootPath, pattern string, excludePatterns []string) ([]string, error) {
+	var results []string
+	pattern = strings.ToLower(pattern)
+
+	err := filepath.Walk(rootPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil // Skip errors
+		}
+
+		// Validate path
+		if _, err := fs.validatePath(path); err != nil {
+			return nil // Skip unauthorized paths
+		}
+
+		// Check exclude patterns (simple implementation)
+		relativePath, _ := filepath.Rel(rootPath, path)
+		for _, excludePattern := range excludePatterns {
+			if strings.Contains(strings.ToLower(relativePath), strings.ToLower(excludePattern)) {
+				if info.IsDir() {
+					return filepath.SkipDir
+				}
+				return nil
+			}
+		}
+
+		// Check if name matches pattern
+		if strings.Contains(strings.ToLower(info.Name()), pattern) {
+			results = append(results, path)
+		}
+
+		return nil
+	})
+
+	return results, err
+}
\ No newline at end of file

@@ -0,0 +1,308 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xlgmokha/mcp/pkg/mcp"
+)
+
+func TestFilesystemServer_ReadFile(t *testing.T) {
+	// Setup test directory
+	tempDir, err := os.MkdirTemp("", "fs-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create test file
+	testFile := filepath.Join(tempDir, "test.txt")
+	testContent := "Hello, World!"
+	if err := os.WriteFile(testFile, []byte(testContent), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	server := NewFilesystemServer([]string{tempDir})
+
+	req := mcp.CallToolRequest{
+		Name: "read_file",
+		Arguments: map[string]interface{}{
+			"path": testFile,
+		},
+	}
+
+	result, err := server.HandleReadFile(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if len(result.Content) == 0 {
+		t.Fatal("Expected content in result")
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	if textContent.Text != testContent {
+		t.Fatalf("Expected '%s', got '%s'", testContent, textContent.Text)
+	}
+}
+
+func TestFilesystemServer_WriteFile(t *testing.T) {
+	// Setup test directory
+	tempDir, err := os.MkdirTemp("", "fs-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	server := NewFilesystemServer([]string{tempDir})
+	testFile := filepath.Join(tempDir, "new_file.txt")
+	testContent := "New content"
+
+	req := mcp.CallToolRequest{
+		Name: "write_file",
+		Arguments: map[string]interface{}{
+			"path":    testFile,
+			"content": testContent,
+		},
+	}
+
+	result, err := server.HandleWriteFile(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		t.Fatal("Expected successful write")
+	}
+
+	// Verify file was created with correct content
+	content, err := os.ReadFile(testFile)
+	if err != nil {
+		t.Fatal("File should have been created")
+	}
+
+	if string(content) != testContent {
+		t.Fatalf("Expected '%s', got '%s'", testContent, string(content))
+	}
+}
+
+func TestFilesystemServer_SecurityValidation(t *testing.T) {
+	// Setup test directory
+	tempDir, err := os.MkdirTemp("", "fs-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	server := NewFilesystemServer([]string{tempDir})
+
+	// Try to access file outside allowed directory
+	req := mcp.CallToolRequest{
+		Name: "read_file",
+		Arguments: map[string]interface{}{
+			"path": "/etc/passwd", // Outside allowed directory
+		},
+	}
+
+	result, err := server.HandleReadFile(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if !result.IsError {
+		t.Fatal("Expected error for unauthorized path access")
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	if !contains(textContent.Text, "Access denied") {
+		t.Fatalf("Expected access denied error, got: %s", textContent.Text)
+	}
+}
+
+func TestFilesystemServer_ListDirectory(t *testing.T) {
+	// Setup test directory
+	tempDir, err := os.MkdirTemp("", "fs-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create test files and directories
+	testFile := filepath.Join(tempDir, "test.txt")
+	testDir := filepath.Join(tempDir, "subdir")
+	
+	if err := os.WriteFile(testFile, []byte("test"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Mkdir(testDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	server := NewFilesystemServer([]string{tempDir})
+
+	req := mcp.CallToolRequest{
+		Name: "list_directory",
+		Arguments: map[string]interface{}{
+			"path": tempDir,
+		},
+	}
+
+	result, err := server.HandleListDirectory(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if len(result.Content) == 0 {
+		t.Fatal("Expected content in result")
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should contain both file and directory
+	if !contains(textContent.Text, "[FILE] test.txt") {
+		t.Fatalf("Expected to find test.txt file, got: %s", textContent.Text)
+	}
+
+	if !contains(textContent.Text, "[DIR] subdir") {
+		t.Fatalf("Expected to find subdir directory, got: %s", textContent.Text)
+	}
+}
+
+func TestFilesystemServer_CreateDirectory(t *testing.T) {
+	// Setup test directory
+	tempDir, err := os.MkdirTemp("", "fs-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	server := NewFilesystemServer([]string{tempDir})
+	newDir := filepath.Join(tempDir, "new", "nested", "directory")
+
+	req := mcp.CallToolRequest{
+		Name: "create_directory",
+		Arguments: map[string]interface{}{
+			"path": newDir,
+		},
+	}
+
+	result, err := server.HandleCreateDirectory(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		t.Fatal("Expected successful directory creation")
+	}
+
+	// Verify directory was created
+	if _, err := os.Stat(newDir); os.IsNotExist(err) {
+		t.Fatal("Directory should have been created")
+	}
+}
+
+func TestFilesystemServer_ListTools(t *testing.T) {
+	server := NewFilesystemServer([]string{"/tmp"})
+	tools := server.ListTools()
+
+	expectedTools := []string{
+		"read_file", "read_multiple_files", "write_file", "edit_file",
+		"create_directory", "list_directory", "list_directory_with_sizes",
+		"directory_tree", "move_file", "search_files", "get_file_info",
+		"list_allowed_directories",
+	}
+
+	if len(tools) != len(expectedTools) {
+		t.Fatalf("Expected %d tools, got %d", len(expectedTools), len(tools))
+	}
+
+	toolNames := make(map[string]bool)
+	for _, tool := range tools {
+		toolNames[tool.Name] = true
+	}
+
+	for _, expected := range expectedTools {
+		if !toolNames[expected] {
+			t.Fatalf("Expected tool %s not found", expected)
+		}
+	}
+}
+
+func TestFilesystemServer_EditFile(t *testing.T) {
+	// Setup test directory
+	tempDir, err := os.MkdirTemp("", "fs-test-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create test file
+	testFile := filepath.Join(tempDir, "test.txt")
+	originalContent := "line1\nline2\nline3"
+	if err := os.WriteFile(testFile, []byte(originalContent), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	server := NewFilesystemServer([]string{tempDir})
+
+	req := mcp.CallToolRequest{
+		Name: "edit_file",
+		Arguments: map[string]interface{}{
+			"path": testFile,
+			"edits": []interface{}{
+				map[string]interface{}{
+					"oldText": "line2",
+					"newText": "modified_line2",
+				},
+			},
+		},
+	}
+
+	result, err := server.HandleEditFile(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		t.Fatal("Expected successful edit")
+	}
+
+	// Verify file was modified
+	content, err := os.ReadFile(testFile)
+	if err != nil {
+		t.Fatal("File should exist")
+	}
+
+	expectedContent := "line1\nmodified_line2\nline3"
+	if string(content) != expectedContent {
+		t.Fatalf("Expected '%s', got '%s'", expectedContent, string(content))
+	}
+}
+
+// Helper functions
+func contains(s, substr string) bool {
+	return len(s) > 0 && len(substr) > 0 && 
+		   (s == substr || (len(s) >= len(substr) && 
+		   findSubstring(s, substr)))
+}
+
+func findSubstring(s, substr string) bool {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}
\ No newline at end of file