Commit 0bf769b

@@ -66,7 +66,7 @@ func main() {
 	}
 
 	// Create and start the server
-	server, err := bash.NewBashServer(config)
+	server, err := bash.New(config)
 	if err != nil {
 		log.Fatalf("Failed to create bash server: %v", err)
 	}

@@ -99,7 +99,7 @@ For more information, visit: https://github.com/xlgmokha/mcp
 		url = envURL
 	}
 
-	server, err := gitlab.NewServer(url, token)
+	server, err := gitlab.New(url, token)
 	if err != nil {
 		log.Fatalf("Failed to create GitLab server: %v", err)
 	}

@@ -1,114 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log"
-
-	"github.com/xlgmokha/mcp/pkg/packages"
-)
-
-func main() {
-	var showHelp bool
-	flag.BoolVar(&showHelp, "help", false, "Show help information")
-	flag.Parse()
-
-	if showHelp {
-		showHelpText()
-		return
-	}
-
-	server := packages.NewServer()
-	if err := server.Run(context.Background()); err != nil {
-		log.Fatalf("Server error: %v", err)
-	}
-}
-
-func showHelpText() {
-	fmt.Printf(`Package Manager MCP Server
-
-A Model Context Protocol server that provides package management tools for multiple 
-ecosystems including Rust (Cargo) and macOS (Homebrew).
-
-USAGE:
-    mcp-packages [OPTIONS]
-
-OPTIONS:
-    --help                Show this help message
-
-TOOLS PROVIDED:
-
-Cargo (Rust) Tools:
-    cargo_build          Build Rust projects with optional flags
-    cargo_run            Run Rust applications with arguments
-    cargo_test           Execute test suites with filtering
-    cargo_add            Add dependencies to Cargo.toml
-    cargo_update         Update dependencies to latest versions
-    cargo_check          Quick compile check without building
-    cargo_clippy         Run Rust linter with suggestions
-
-Homebrew Tools:
-    brew_install         Install packages or casks
-    brew_uninstall       Remove packages or casks
-    brew_search          Search for available packages
-    brew_update          Update Homebrew itself
-    brew_upgrade         Upgrade installed packages
-    brew_doctor          Check system health
-    brew_list            List installed packages
-
-Cross-Platform Tools:
-    check_vulnerabilities    Scan for security vulnerabilities
-    outdated_packages       Find packages needing updates
-    package_info            Get detailed package information
-
-EXAMPLES:
-
-Cargo Operations:
-    # Build a Rust project in release mode
-    {"name": "cargo_build", "arguments": {"directory": ".", "release": true}}
-    
-    # Run with arguments
-    {"name": "cargo_run", "arguments": {"args": ["--version"]}}
-    
-    # Add a dependency
-    {"name": "cargo_add", "arguments": {"packages": ["serde", "tokio"]}}
-
-Homebrew Operations:
-    # Install a package
-    {"name": "brew_install", "arguments": {"packages": ["git"]}}
-    
-    # Search for packages
-    {"name": "brew_search", "arguments": {"query": "nodejs"}}
-    
-    # Check system health
-    {"name": "brew_doctor", "arguments": {}}
-
-Security & Maintenance:
-    # Check for vulnerabilities in current directory
-    {"name": "check_vulnerabilities", "arguments": {"directory": "."}}
-    
-    # Find outdated packages
-    {"name": "outdated_packages", "arguments": {"package_manager": "cargo"}}
-
-INTEGRATION:
-Add to your Claude Code configuration (~/.claude.json):
-
-{
-  "mcpServers": {
-    "packages": {
-      "command": "mcp-packages"
-    }
-  }
-}
-
-ENVIRONMENT:
-The server auto-detects package managers based on project files:
-- Cargo.toml → Rust/Cargo tools
-- package.json → NPM tools  
-- go.mod → Go modules
-- Homebrew → System-wide macOS packages
-
-For support or issues, see: https://github.com/xlgmokha/mcp
-`)
-}

@@ -36,10 +36,13 @@ func main() {
 	setupLogging(*logLevel)
 
 	// Create and configure the semantic server
-	server := semantic.NewServer()
+	server, err := semantic.New()
+	if err != nil {
+		log.Fatalf("Failed to create semantic server: %v", err)
+	}
 
 	// Initialize project discovery
-	if err := initializeProject(server, *projectRoot, *configFile); err != nil {
+	if err := initializeProject(*projectRoot, *configFile); err != nil {
 		log.Fatalf("Failed to initialize project: %v", err)
 	}
 
@@ -50,9 +53,8 @@ func main() {
 	go func() {
 		<-sigChan
 		log.Println("Shutting down semantic server...")
-		if err := server.Shutdown(); err != nil {
-			log.Printf("Error during shutdown: %v", err)
-		}
+		// Note: Shutdown is no longer available in the new pattern
+		// LSP managers are handled internally
 		os.Exit(0)
 	}()
 
@@ -207,7 +209,7 @@ func setupLogging(level string) {
 	}
 }
 
-func initializeProject(server *semantic.Server, projectRoot, configFile string) error {
+func initializeProject(projectRoot, configFile string) error {
 	// This is a placeholder for project initialization
 	// In the full implementation, this would:
 	// 1. Load configuration from file if provided

@@ -68,7 +68,7 @@ For more information, visit: https://github.com/xlgmokha/mcp
 		return
 	}
 
-	server, err := signal.NewServer(*signalPath)
+	server, err := signal.New(*signalPath)
 	if err != nil {
 		log.Fatalf("Failed to create Signal server: %v", err)
 	}

@@ -19,7 +19,10 @@ func main() {
 		return
 	}
 
-	server := speech.NewServer()
+	server, err := speech.New()
+	if err != nil {
+		log.Fatalf("Failed to create speech server: %v", err)
+	}
 	if err := server.Run(context.Background()); err != nil {
 		log.Fatalf("Server error: %v", err)
 	}

@@ -1,890 +0,0 @@
-# MCP Server Feature Specifications for Go Implementation
-
-This document provides detailed specifications for implementing MCP servers in Go based on analysis of the Python reference implementations. Each server must implement the Model Context Protocol using JSON-RPC 2.0 over stdio.
-
-## Core MCP Protocol Requirements
-
-### Base Protocol
-- **Transport**: JSON-RPC 2.0 over stdio (stdin/stdout)
-- **Connection**: Stateful client-server connection
-- **Initialization**: Capability negotiation during handshake
-- **Message Format**: All messages must follow JSON-RPC 2.0 specification
-
-### Required MCP Methods
-All servers must implement these base protocol methods:
-- `initialize` - Capability negotiation and server info
-- `initialized` - Notification that initialization is complete
-- `shutdown` - Graceful shutdown request
-- `exit` - Immediate termination notification
-
-### Server Capabilities
-Servers can implement any combination of:
-- **Tools** - Functions the AI model can execute
-- **Resources** - Context and data access
-- **Prompts** - Templated messages and workflows
-
-## 1. Git Server (`mcp-server-git`)
-
-### Dependencies
-- Git CLI or go-git library
-- File system access for repository operations
-
-### Tools
-
-#### `git_status`
-- **Description**: Shows the working tree status
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"}
-    },
-    "required": ["repo_path"]
-  }
-  ```
-- **Implementation**: Execute `git status` or use go-git Status()
-- **Output**: TextContent with repository status
-
-#### `git_diff_unstaged`
-- **Description**: Shows changes in working directory not yet staged
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"}
-    },
-    "required": ["repo_path"]
-  }
-  ```
-- **Implementation**: Execute `git diff` or use go-git diff functionality
-- **Output**: TextContent with unstaged changes
-
-#### `git_diff_staged`
-- **Description**: Shows changes that are staged for commit
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"}
-    },
-    "required": ["repo_path"]
-  }
-  ```
-- **Implementation**: Execute `git diff --cached`
-- **Output**: TextContent with staged changes
-
-#### `git_diff`
-- **Description**: Shows differences between branches or commits
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"},
-      "target": {"type": "string", "description": "Target branch or commit to compare with"}
-    },
-    "required": ["repo_path", "target"]
-  }
-  ```
-- **Implementation**: Execute `git diff <target>`
-- **Output**: TextContent with diff output
-
-#### `git_commit`
-- **Description**: Records changes to the repository
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"},
-      "message": {"type": "string", "description": "Commit message"}
-    },
-    "required": ["repo_path", "message"]
-  }
-  ```
-- **Implementation**: Execute `git commit -m "message"`
-- **Output**: TextContent with commit confirmation and hash
-
-#### `git_add`
-- **Description**: Adds file contents to the staging area
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"},
-      "files": {"type": "array", "items": {"type": "string"}, "description": "Array of file paths to stage"}
-    },
-    "required": ["repo_path", "files"]
-  }
-  ```
-- **Implementation**: Execute `git add <files...>`
-- **Output**: TextContent with staging confirmation
-
-#### `git_reset`
-- **Description**: Unstages all staged changes
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"}
-    },
-    "required": ["repo_path"]
-  }
-  ```
-- **Implementation**: Execute `git reset`
-- **Output**: TextContent with reset confirmation
-
-#### `git_log`
-- **Description**: Shows the commit logs
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"},
-      "max_count": {"type": "integer", "description": "Maximum number of commits to show", "default": 10}
-    },
-    "required": ["repo_path"]
-  }
-  ```
-- **Implementation**: Execute `git log --max-count=<n>` or use go-git log iterator
-- **Output**: TextContent with formatted commit history
-
-#### `git_create_branch`
-- **Description**: Creates a new branch from an optional base branch
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"},
-      "branch_name": {"type": "string", "description": "Name of the new branch"},
-      "base_branch": {"type": "string", "description": "Starting point for the new branch", "default": null}
-    },
-    "required": ["repo_path", "branch_name"]
-  }
-  ```
-- **Implementation**: Execute `git checkout -b <branch_name> [base_branch]`
-- **Output**: TextContent with branch creation confirmation
-
-#### `git_checkout`
-- **Description**: Switches branches
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"},
-      "branch_name": {"type": "string", "description": "Name of branch to checkout"}
-    },
-    "required": ["repo_path", "branch_name"]
-  }
-  ```
-- **Implementation**: Execute `git checkout <branch_name>`
-- **Output**: TextContent with checkout confirmation
-
-#### `git_show`
-- **Description**: Shows the contents of a commit
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to Git repository"},
-      "revision": {"type": "string", "description": "The revision (commit hash, branch name, tag) to show"}
-    },
-    "required": ["repo_path", "revision"]
-  }
-  ```
-- **Implementation**: Execute `git show <revision>` or use go-git commit details
-- **Output**: TextContent with commit details and diff
-
-#### `git_init`
-- **Description**: Initialize a new Git repository
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "repo_path": {"type": "string", "description": "Path to directory to initialize git repo"}
-    },
-    "required": ["repo_path"]
-  }
-  ```
-- **Implementation**: Execute `git init` or use go-git PlainInit()
-- **Output**: TextContent with initialization confirmation
-
-### Configuration
-- Command line argument: `--repository <path>` to specify default repository
-- Can also detect repositories from MCP roots capability
-
-## 2. Filesystem Server (`mcp-server-filesystem`)
-
-### Dependencies
-- File system access with configurable permissions
-- Pattern matching for file search
-- Text diff generation
-
-### Security Model
-- **Sandboxing**: Only allow operations within specified directories
-- **Validation**: All paths must be validated against allowed directories
-- **Error Handling**: Graceful handling of permission errors
-
-### Tools
-
-#### `read_file`
-- **Description**: Read complete contents of a file
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "path": {"type": "string", "description": "Absolute path to the file to read"}
-    },
-    "required": ["path"]
-  }
-  ```
-- **Implementation**: Read file with UTF-8 encoding, handle various encodings
-- **Output**: TextContent with file contents
-- **Security**: Validate path is within allowed directories
-
-#### `read_multiple_files`
-- **Description**: Read multiple files simultaneously
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "paths": {"type": "array", "items": {"type": "string"}, "description": "Array of file paths to read"}
-    },
-    "required": ["paths"]
-  }
-  ```
-- **Implementation**: Read multiple files, continue on individual failures
-- **Output**: TextContent with results for each file
-- **Security**: Validate all paths are within allowed directories
-
-#### `write_file`
-- **Description**: Create new file or overwrite existing
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "path": {"type": "string", "description": "File location"},
-      "content": {"type": "string", "description": "File content"}
-    },
-    "required": ["path", "content"]
-  }
-  ```
-- **Implementation**: Write content to file with UTF-8 encoding
-- **Output**: TextContent with write confirmation
-- **Security**: Validate path is within allowed directories
-
-#### `edit_file`
-- **Description**: Make selective edits using pattern matching
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "path": {"type": "string", "description": "File to edit"},
-      "edits": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "oldText": {"type": "string", "description": "Text to search for"},
-            "newText": {"type": "string", "description": "Text to replace with"}
-          },
-          "required": ["oldText", "newText"]
-        }
-      },
-      "dryRun": {"type": "boolean", "description": "Preview changes without applying", "default": false}
-    },
-    "required": ["path", "edits"]
-  }
-  ```
-- **Implementation**: 
-  - Line-based and multi-line content matching
-  - Whitespace normalization with indentation preservation
-  - Multiple simultaneous edits with correct positioning
-  - Git-style diff output
-- **Output**: TextContent with diff information or edit confirmation
-- **Security**: Validate path is within allowed directories
-
-#### `create_directory`
-- **Description**: Create new directory or ensure it exists
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "path": {"type": "string", "description": "Directory path to create"}
-    },
-    "required": ["path"]
-  }
-  ```
-- **Implementation**: Create directory and parent directories if needed
-- **Output**: TextContent with creation confirmation
-- **Security**: Validate path is within allowed directories
-
-#### `list_directory`
-- **Description**: List directory contents with type indicators
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "path": {"type": "string", "description": "Directory path to list"}
-    },
-    "required": ["path"]
-  }
-  ```
-- **Implementation**: List files and directories with [FILE] or [DIR] prefixes
-- **Output**: TextContent with directory listing
-- **Security**: Validate path is within allowed directories
-
-#### `move_file`
-- **Description**: Move or rename files and directories
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "source": {"type": "string", "description": "Source path"},
-      "destination": {"type": "string", "description": "Destination path"}
-    },
-    "required": ["source", "destination"]
-  }
-  ```
-- **Implementation**: Move/rename operation, fail if destination exists
-- **Output**: TextContent with move confirmation
-- **Security**: Validate both paths are within allowed directories
-
-#### `search_files`
-- **Description**: Recursively search for files/directories
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "path": {"type": "string", "description": "Starting directory"},
-      "pattern": {"type": "string", "description": "Search pattern"},
-      "excludePatterns": {"type": "array", "items": {"type": "string"}, "description": "Exclude patterns", "default": []}
-    },
-    "required": ["path", "pattern"]
-  }
-  ```
-- **Implementation**: Case-insensitive recursive search with glob patterns
-- **Output**: TextContent with matching file paths
-- **Security**: Validate path is within allowed directories
-
-#### `get_file_info`
-- **Description**: Get detailed file/directory metadata
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "path": {"type": "string", "description": "File/directory path"}
-    },
-    "required": ["path"]
-  }
-  ```
-- **Implementation**: Return size, timestamps, permissions, type
-- **Output**: TextContent with file metadata
-- **Security**: Validate path is within allowed directories
-
-#### `list_allowed_directories`
-- **Description**: List all directories the server is allowed to access
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {},
-    "required": []
-  }
-  ```
-- **Implementation**: Return configured allowed directories
-- **Output**: TextContent with allowed directory list
-
-### Configuration
-- Command line arguments: List of allowed directories
-- Example: `mcp-server-filesystem /home/user/documents /home/user/projects`
-
-## 3. Fetch Server (`mcp-server-fetch`)
-
-### Dependencies
-- HTTP client for web requests
-- HTML to Markdown conversion
-- robots.txt parsing
-- URL validation and parsing
-
-### Security Considerations
-- **robots.txt Compliance**: Check robots.txt before autonomous fetching
-- **User Agent**: Different user agents for autonomous vs manual requests
-- **Proxy Support**: Optional proxy configuration
-- **Content Filtering**: Handle various content types appropriately
-
-### Tools
-
-#### `fetch`
-- **Description**: Fetches a URL from the internet and extracts its contents as markdown
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "url": {"type": "string", "format": "uri", "description": "URL to fetch"},
-      "max_length": {"type": "integer", "description": "Maximum number of characters to return", "default": 5000, "minimum": 1, "maximum": 999999},
-      "start_index": {"type": "integer", "description": "Start content from this character index", "default": 0, "minimum": 0},
-      "raw": {"type": "boolean", "description": "Get raw content without markdown conversion", "default": false}
-    },
-    "required": ["url"]
-  }
-  ```
-- **Implementation**:
-  - Check robots.txt compliance for autonomous requests
-  - Fetch URL with appropriate user agent
-  - Convert HTML to markdown unless raw requested
-  - Handle content truncation and pagination
-  - Support content type detection
-- **Output**: TextContent with fetched content
-- **Error Handling**: Detailed error messages for robots.txt violations, HTTP errors
-
-### Prompts
-
-#### `fetch`
-- **Description**: Fetch a URL and extract its contents as markdown
-- **Arguments**:
-  ```json
-  [
-    {
-      "name": "url",
-      "description": "URL to fetch",
-      "required": true
-    }
-  ]
-  ```
-- **Implementation**: Manual fetch without robots.txt restrictions
-
-### Configuration Options
-- `--custom-user-agent`: Custom User-Agent string
-- `--ignore-robots-txt`: Ignore robots.txt restrictions
-- `--proxy-url`: Proxy URL for requests
-
-## 4. Memory Server (`mcp-server-memory`)
-
-### Dependencies
-- JSON file storage for persistence
-- Graph data structure for entities and relations
-- Text search capabilities
-
-### Data Model
-
-#### Entity
-```json
-{
-  "name": "string (unique identifier)",
-  "entityType": "string (e.g., 'person', 'organization', 'event')",
-  "observations": ["array of strings"]
-}
-```
-
-#### Relation
-```json
-{
-  "from": "string (source entity name)",
-  "to": "string (target entity name)",
-  "relationType": "string (relationship type in active voice)"
-}
-```
-
-### Tools
-
-#### `create_entities`
-- **Description**: Create multiple new entities in the knowledge graph
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "entities": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "name": {"type": "string", "description": "Entity identifier"},
-            "entityType": {"type": "string", "description": "Type classification"},
-            "observations": {"type": "array", "items": {"type": "string"}, "description": "Associated observations"}
-          },
-          "required": ["name", "entityType", "observations"]
-        }
-      }
-    },
-    "required": ["entities"]
-  }
-  ```
-- **Implementation**: Add entities to graph, ignore duplicates by name
-- **Output**: TextContent with creation results
-
-#### `create_relations`
-- **Description**: Create multiple new relations between entities
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "relations": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "from": {"type": "string", "description": "Source entity name"},
-            "to": {"type": "string", "description": "Target entity name"},
-            "relationType": {"type": "string", "description": "Relationship type"}
-          },
-          "required": ["from", "to", "relationType"]
-        }
-      }
-    },
-    "required": ["relations"]
-  }
-  ```
-- **Implementation**: Add relations to graph, skip duplicates
-- **Output**: TextContent with creation results
-
-#### `add_observations`
-- **Description**: Add new observations to existing entities
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "observations": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "entityName": {"type": "string", "description": "Target entity"},
-            "contents": {"type": "array", "items": {"type": "string"}, "description": "New observations to add"}
-          },
-          "required": ["entityName", "contents"]
-        }
-      }
-    },
-    "required": ["observations"]
-  }
-  ```
-- **Implementation**: Add observations to existing entities
-- **Output**: TextContent with added observations per entity
-- **Error**: Fail if entity doesn't exist
-
-#### `delete_entities`
-- **Description**: Remove entities and their relations
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "entityNames": {"type": "array", "items": {"type": "string"}, "description": "Entity names to delete"}
-    },
-    "required": ["entityNames"]
-  }
-  ```
-- **Implementation**: Remove entities and cascade delete relations
-- **Output**: TextContent with deletion results
-
-#### `delete_observations`
-- **Description**: Remove specific observations from entities
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "deletions": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "entityName": {"type": "string", "description": "Target entity"},
-            "observations": {"type": "array", "items": {"type": "string"}, "description": "Observations to remove"}
-          },
-          "required": ["entityName", "observations"]
-        }
-      }
-    },
-    "required": ["deletions"]
-  }
-  ```
-- **Implementation**: Remove specific observations from entities
-- **Output**: TextContent with deletion results
-
-#### `delete_relations`
-- **Description**: Remove specific relations from the graph
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "relations": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "from": {"type": "string", "description": "Source entity name"},
-            "to": {"type": "string", "description": "Target entity name"},
-            "relationType": {"type": "string", "description": "Relationship type"}
-          },
-          "required": ["from", "to", "relationType"]
-        }
-      }
-    },
-    "required": ["relations"]
-  }
-  ```
-- **Implementation**: Remove specific relations
-- **Output**: TextContent with deletion results
-
-#### `read_graph`
-- **Description**: Read the entire knowledge graph
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {},
-    "required": []
-  }
-  ```
-- **Implementation**: Return complete graph structure
-- **Output**: TextContent with full graph data
-
-#### `search_nodes`
-- **Description**: Search for nodes based on query
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "query": {"type": "string", "description": "Search query"}
-    },
-    "required": ["query"]
-  }
-  ```
-- **Implementation**: Search entity names, types, and observation content
-- **Output**: TextContent with matching entities and relations
-
-#### `open_nodes`
-- **Description**: Retrieve specific nodes by name
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "names": {"type": "array", "items": {"type": "string"}, "description": "Entity names to retrieve"}
-    },
-    "required": ["names"]
-  }
-  ```
-- **Implementation**: Return requested entities and their relations
-- **Output**: TextContent with requested nodes
-
-### Configuration
-- Environment variable: `MEMORY_FILE_PATH` for custom storage location
-- Default: `memory.json` in server directory
-
-## 5. Sequential Thinking Server (`mcp-server-sequential-thinking`)
-
-### Dependencies
-- JSON file storage for session persistence
-- State management for thought sequences and branches
-- Thread-safe concurrent access controls
-
-### Configuration
-- Command line argument: `--session-file <path>` for persistent session storage
-
-### Tools
-
-#### `sequentialthinking`
-- **Description**: Dynamic problem-solving through structured thought sequences with session persistence
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "thought": {"type": "string", "description": "Your current thinking step"},
-      "nextThoughtNeeded": {"type": "boolean", "description": "Whether another thought step is needed"},
-      "thoughtNumber": {"type": "integer", "description": "Current thought number", "minimum": 1},
-      "totalThoughts": {"type": "integer", "description": "Estimated total thoughts needed", "minimum": 1},
-      "isRevision": {"type": "boolean", "description": "Whether this revises previous thinking"},
-      "revisesThought": {"type": "integer", "description": "Which thought is being reconsidered", "minimum": 1},
-      "branchFromThought": {"type": "integer", "description": "Branching point thought number", "minimum": 1},
-      "branchId": {"type": "string", "description": "Branch identifier"},
-      "needsMoreThoughts": {"type": "boolean", "description": "If more thoughts are needed"},
-      "sessionId": {"type": "string", "description": "Session ID for thought continuity (auto-generated if not provided)"}
-    },
-    "required": ["thought", "nextThoughtNeeded", "thoughtNumber", "totalThoughts"]
-  }
-  ```
-- **Implementation**:
-  - Track thought sequences with persistent sessions
-  - Support branching for alternative reasoning paths
-  - Support revision and refinement of previous thoughts
-  - Thread-safe concurrent session access
-  - JSON file persistence across server restarts
-- **Output**: TextContent with thought processing results and session context
-
-#### `get_session_history`
-- **Description**: Retrieve complete thought history for a thinking session
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "sessionId": {"type": "string", "description": "Session ID to get history for"}
-    },
-    "required": ["sessionId"]
-  }
-  ```
-- **Output**: JSON TextContent with complete session data and thoughts
-
-#### `list_sessions`
-- **Description**: List all active thinking sessions
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {}
-  }
-  ```
-- **Output**: JSON TextContent with array of session summaries
-
-#### `get_branch_history`
-- **Description**: Get thought history for a specific reasoning branch
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "branchId": {"type": "string", "description": "Branch ID to get history for"}
-    },
-    "required": ["branchId"]
-  }
-  ```
-- **Output**: JSON TextContent with complete branch data and thoughts
-
-#### `clear_session`
-- **Description**: Clear a thinking session and all its branches
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "sessionId": {"type": "string", "description": "Session ID to clear"}
-    },
-    "required": ["sessionId"]
-  }
-  ```
-- **Output**: JSON TextContent with confirmation message and details
-
-## 6. Time Server (`mcp-server-time`)
-
-### Dependencies
-- Timezone database (IANA timezones)
-- System timezone detection
-- Time parsing and formatting
-
-### Tools
-
-#### `get_current_time`
-- **Description**: Get current time in a specific timezone
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "timezone": {"type": "string", "description": "IANA timezone name (e.g., 'America/New_York', 'Europe/London')"}
-    },
-    "required": ["timezone"]
-  }
-  ```
-- **Implementation**: Get current time in specified timezone with DST information
-- **Output**: JSON TextContent with timezone, datetime (ISO format), is_dst
-
-#### `convert_time`
-- **Description**: Convert time between timezones
-- **Input Schema**:
-  ```json
-  {
-    "type": "object",
-    "properties": {
-      "source_timezone": {"type": "string", "description": "Source IANA timezone name"},
-      "time": {"type": "string", "description": "Time in 24-hour format (HH:MM)"},
-      "target_timezone": {"type": "string", "description": "Target IANA timezone name"}
-    },
-    "required": ["source_timezone", "time", "target_timezone"]
-  }
-  ```
-- **Implementation**: Convert time between timezones, calculate time difference
-- **Output**: JSON TextContent with source and target time information plus difference
-
-### Configuration
-- Command line argument: `--local-timezone` to override system timezone detection
-
-## Common Go Implementation Requirements
-
-### JSON-RPC 2.0 Implementation
-- Message framing over stdio
-- Request/response correlation with IDs
-- Notification handling (no response expected)
-- Error response formatting
-
-### Shared Types
-```go
-type TextContent struct {
-    Type string `json:"type"`
-    Text string `json:"text"`
-}
-
-type Tool struct {
-    Name        string      `json:"name"`
-    Description string      `json:"description"`
-    InputSchema interface{} `json:"inputSchema"`
-}
-
-type ServerInfo struct {
-    Name    string `json:"name"`
-    Version string `json:"version"`
-}
-```
-
-### Error Handling
-- Standard JSON-RPC error codes
-- Descriptive error messages
-- Graceful degradation
-- Input validation with clear error messages
-
-### Logging and Debugging
-- Structured logging support
-- Debug mode for development
-- Request/response tracing capability
-
-### Configuration
-- Command line argument parsing
-- Environment variable support
-- Configuration file support where appropriate
-- Sensible defaults
-
-### Testing Requirements
-- Unit tests for all tools
-- Integration tests with MCP clients
-- Error condition testing
-- Mock external dependencies where needed
-
-This specification provides the foundation for implementing full-featured MCP servers in Go with complete compatibility with the Python reference implementations.
\ No newline at end of file

@@ -13,7 +13,7 @@ import (
 // Core Execution Tools
 
 // HandleBashExec handles the bash_exec tool
-func (bs *BashServer) HandleBashExec(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+func (bash *BashOperations) HandleBashExec(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
 	var options ExecutionOptions
 
 	// Parse command (required)
@@ -51,7 +51,7 @@ func (bs *BashServer) HandleBashExec(req mcp.CallToolRequest) (mcp.CallToolResul
 	}
 
 	// Execute command
-	result, err := bs.executeCommand(options)
+	result, err := bash.executeCommand(options)
 	if err != nil {
 		return mcp.NewToolError(fmt.Sprintf("Failed to execute command: %v", err)), nil
 	}
@@ -68,16 +68,16 @@ func (bs *BashServer) HandleBashExec(req mcp.CallToolRequest) (mcp.CallToolResul
 }
 
 // HandleBashExecStream handles the bash_exec_stream tool
-func (bs *BashServer) HandleBashExecStream(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+func (bash *BashOperations) HandleBashExecStream(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
 	// For now, this is the same as regular execution
 	// TODO: Implement actual streaming in future version
-	return bs.HandleBashExec(req)
+	return bash.HandleBashExec(req)
 }
 
 // Documentation Tools
 
 // HandleManPage handles the man_page tool
-func (bs *BashServer) HandleManPage(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+func (bash *BashOperations) HandleManPage(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
 	command, ok := req.Arguments["command"].(string)
 	if !ok || command == "" {
 		return mcp.NewToolError("command parameter is required"), nil
@@ -94,7 +94,7 @@ func (bs *BashServer) HandleManPage(req mcp.CallToolRequest) (mcp.CallToolResult
 		CaptureStderr: true,
 	}
 
-	result, err := bs.executeCommand(options)
+	result, err := bash.executeCommand(options)
 	if err != nil {
 		return mcp.NewToolError(fmt.Sprintf("Failed to get man page: %v", err)), nil
 	}
@@ -110,7 +110,7 @@ func (bs *BashServer) HandleManPage(req mcp.CallToolRequest) (mcp.CallToolResult
 }
 
 // HandleWhichCommand handles the which_command tool
-func (bs *BashServer) HandleWhichCommand(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+func (bash *BashOperations) HandleWhichCommand(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
 	command, ok := req.Arguments["command"].(string)
 	if !ok || command == "" {
 		return mcp.NewToolError("command parameter is required"), nil
@@ -128,7 +128,7 @@ func (bs *BashServer) HandleWhichCommand(req mcp.CallToolRequest) (mcp.CallToolR
 		CaptureStderr: true,
 	}
 
-	result, err := bs.executeCommand(options)
+	result, err := bash.executeCommand(options)
 	if err != nil {
 		return mcp.NewToolError(fmt.Sprintf("Failed to locate command: %v", err)), nil
 	}
@@ -144,7 +144,7 @@ func (bs *BashServer) HandleWhichCommand(req mcp.CallToolRequest) (mcp.CallToolR
 }
 
 // HandleCommandHelp handles the command_help tool
-func (bs *BashServer) HandleCommandHelp(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+func (bash *BashOperations) HandleCommandHelp(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
 	command, ok := req.Arguments["command"].(string)
 	if !ok || command == "" {
 		return mcp.NewToolError("command parameter is required"), nil
@@ -157,7 +157,7 @@ func (bs *BashServer) HandleCommandHelp(req mcp.CallToolRequest) (mcp.CallToolRe
 		CaptureStderr: true,
 	}
 
-	result, err := bs.executeCommand(options)
+	result, err := bash.executeCommand(options)
 	if err != nil {
 		return mcp.NewToolError(fmt.Sprintf("Failed to get command help: %v", err)), nil
 	}
@@ -181,7 +181,7 @@ func (bs *BashServer) HandleCommandHelp(req mcp.CallToolRequest) (mcp.CallToolRe
 // Environment Management Tools
 
 // HandleGetEnv handles the get_env tool
-func (bs *BashServer) HandleGetEnv(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+func (bash *BashOperations) HandleGetEnv(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
 	// Check if requesting all environment variables
 	if all, ok := req.Arguments["all"].(bool); ok && all {
 		envVars := make(map[string]string)
@@ -224,8 +224,8 @@ func (bs *BashServer) HandleGetEnv(req mcp.CallToolRequest) (mcp.CallToolResult,
 }
 
 // HandleGetWorkingDir handles the get_working_dir tool
-func (bs *BashServer) HandleGetWorkingDir(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
-	workingDir := bs.getWorkingDir()
+func (bash *BashOperations) HandleGetWorkingDir(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	workingDir := bash.getWorkingDir()
 
 	result := map[string]string{
 		"working_directory": workingDir,
@@ -242,18 +242,18 @@ func (bs *BashServer) HandleGetWorkingDir(req mcp.CallToolRequest) (mcp.CallTool
 }
 
 // HandleSetWorkingDir handles the set_working_dir tool
-func (bs *BashServer) HandleSetWorkingDir(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+func (bash *BashOperations) HandleSetWorkingDir(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
 	directory, ok := req.Arguments["directory"].(string)
 	if !ok || directory == "" {
 		return mcp.NewToolError("directory parameter is required"), nil
 	}
 
-	if err := bs.setWorkingDir(directory); err != nil {
+	if err := bash.setWorkingDir(directory); err != nil {
 		return mcp.NewToolError(fmt.Sprintf("Failed to set working directory: %v", err)), nil
 	}
 
 	result := map[string]string{
-		"working_directory": bs.getWorkingDir(),
+		"working_directory": bash.getWorkingDir(),
 		"message":          "Working directory updated successfully",
 	}
 
@@ -270,8 +270,8 @@ func (bs *BashServer) HandleSetWorkingDir(req mcp.CallToolRequest) (mcp.CallTool
 // System Information Tools
 
 // HandleSystemInfo handles the system_info tool
-func (bs *BashServer) HandleSystemInfo(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
-	sysInfo, err := bs.getSystemInfo()
+func (bash *BashOperations) HandleSystemInfo(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	sysInfo, err := bash.getSystemInfo()
 	if err != nil {
 		return mcp.NewToolError(fmt.Sprintf("Failed to get system information: %v", err)), nil
 	}
@@ -287,7 +287,7 @@ func (bs *BashServer) HandleSystemInfo(req mcp.CallToolRequest) (mcp.CallToolRes
 }
 
 // HandleProcessInfo handles the process_info tool
-func (bs *BashServer) HandleProcessInfo(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+func (bash *BashOperations) HandleProcessInfo(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
 	// Build ps command
 	format := "aux" // default format
 	if f, ok := req.Arguments["format"].(string); ok && f != "" {
@@ -315,7 +315,7 @@ func (bs *BashServer) HandleProcessInfo(req mcp.CallToolRequest) (mcp.CallToolRe
 		CaptureStderr: true,
 	}
 
-	result, err := bs.executeCommand(options)
+	result, err := bash.executeCommand(options)
 	if err != nil {
 		return mcp.NewToolError(fmt.Sprintf("Failed to get process information: %v", err)), nil
 	}
@@ -333,8 +333,8 @@ func (bs *BashServer) HandleProcessInfo(req mcp.CallToolRequest) (mcp.CallToolRe
 // Resource Handlers
 
 // HandleSystemResource handles the system information resource
-func (bs *BashServer) HandleSystemResource(req mcp.ReadResourceRequest) (mcp.ReadResourceResult, error) {
-	sysInfo, err := bs.getSystemInfo()
+func (bash *BashOperations) HandleSystemResource(req mcp.ReadResourceRequest) (mcp.ReadResourceResult, error) {
+	sysInfo, err := bash.getSystemInfo()
 	if err != nil {
 		return mcp.ReadResourceResult{}, fmt.Errorf("failed to get system information: %w", err)
 	}
@@ -350,8 +350,8 @@ func (bs *BashServer) HandleSystemResource(req mcp.ReadResourceRequest) (mcp.Rea
 }
 
 // HandleHistoryResource handles the command history resource
-func (bs *BashServer) HandleHistoryResource(req mcp.ReadResourceRequest) (mcp.ReadResourceResult, error) {
-	history := bs.getCommandHistory()
+func (bash *BashOperations) HandleHistoryResource(req mcp.ReadResourceRequest) (mcp.ReadResourceResult, error) {
+	history := bash.getCommandHistory()
 
 	return mcp.ReadResourceResult{
 		Contents: []mcp.Content{
@@ -364,7 +364,7 @@ func (bs *BashServer) HandleHistoryResource(req mcp.ReadResourceRequest) (mcp.Re
 }
 
 // HandleEnvResource handles the environment variables resource
-func (bs *BashServer) HandleEnvResource(req mcp.ReadResourceRequest) (mcp.ReadResourceResult, error) {
+func (bash *BashOperations) HandleEnvResource(req mcp.ReadResourceRequest) (mcp.ReadResourceResult, error) {
 	envVars := make(map[string]string)
 	for _, env := range os.Environ() {
 		parts := strings.SplitN(env, "=", 2)

@@ -16,9 +16,8 @@ import (
 	"github.com/xlgmokha/mcp/pkg/mcp"
 )
 
-// BashServer implements the Bash MCP server
-type BashServer struct {
-	*mcp.Server
+// BashOperations provides bash command execution operations
+type BashOperations struct {
 	workingDir     string
 	commandHistory []CommandRecord
 	mu             sync.RWMutex
@@ -74,8 +73,8 @@ type SystemInfo struct {
 	Path         string `json:"path"`
 }
 
-// NewBashServer creates a new Bash MCP server
-func NewBashServer(config *Config) (*BashServer, error) {
+// NewBashOperations creates a new BashOperations helper
+func NewBashOperations(config *Config) (*BashOperations, error) {
 	if config == nil {
 		config = DefaultConfig()
 	}
@@ -90,23 +89,200 @@ func NewBashServer(config *Config) (*BashServer, error) {
 		workingDir = cwd
 	}
 
-	// Create base MCP server
-	baseServer := mcp.NewServer("bash", "1.0.0", []mcp.Tool{}, []mcp.Resource{}, []mcp.Root{})
-	
-	server := &BashServer{
-		Server:         baseServer,
+	return &BashOperations{
 		workingDir:     workingDir,
 		commandHistory: make([]CommandRecord, 0, config.HistorySize),
 		config:         config,
-	}
+	}, nil
+}
 
-	// Register all tools
-	server.registerTools()
+// New creates a new Bash MCP server
+func New(config *Config) (*mcp.Server, error) {
+	bash, err := NewBashOperations(config)
+	if err != nil {
+		return nil, err
+	}
 	
-	// Register resources
-	server.registerResources()
-
-	return server, nil
+	builder := mcp.NewServerBuilder("bash", "1.0.0")
+
+	// Add bash_exec tool
+	builder.AddTool(mcp.NewTool("bash_exec", "Execute a shell command and return output", map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"command": map[string]interface{}{
+				"type":        "string",
+				"description": "Shell command to execute",
+			},
+			"working_dir": map[string]interface{}{
+				"type":        "string",
+				"description": "Working directory for command execution (optional)",
+			},
+			"timeout": map[string]interface{}{
+				"type":        "number",
+				"description": "Timeout in seconds (default: 30, max: 300)",
+			},
+			"capture_stderr": map[string]interface{}{
+				"type":        "boolean",
+				"description": "Include stderr in output (default: true)",
+			},
+			"env": map[string]interface{}{
+				"type":        "object",
+				"description": "Additional environment variables",
+			},
+		},
+		"required": []string{"command"},
+	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+		return bash.HandleBashExec(req)
+	}))
+
+	// Add bash_exec_stream tool
+	builder.AddTool(mcp.NewTool("bash_exec_stream", "Execute command with real-time output streaming", map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"command": map[string]interface{}{
+				"type":        "string",
+				"description": "Shell command to execute",
+			},
+			"working_dir": map[string]interface{}{
+				"type":        "string",
+				"description": "Working directory for command execution (optional)",
+			},
+			"timeout": map[string]interface{}{
+				"type":        "number",
+				"description": "Timeout in seconds (default: 30, max: 300)",
+			},
+			"buffer_size": map[string]interface{}{
+				"type":        "number",
+				"description": "Stream buffer size in bytes",
+			},
+		},
+		"required": []string{"command"},
+	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+		return bash.HandleBashExecStream(req)
+	}))
+
+	// Add man_page tool
+	builder.AddTool(mcp.NewTool("man_page", "Get manual page for a command", map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"command": map[string]interface{}{
+				"type":        "string",
+				"description": "Command to get manual for",
+			},
+			"section": map[string]interface{}{
+				"type":        "string",
+				"description": "Manual section (1-8)",
+			},
+		},
+		"required": []string{"command"},
+	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+		return bash.HandleManPage(req)
+	}))
+
+	// Add which_command tool
+	builder.AddTool(mcp.NewTool("which_command", "Find the location of a command", map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"command": map[string]interface{}{
+				"type":        "string",
+				"description": "Command to locate",
+			},
+		},
+		"required": []string{"command"},
+	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+		return bash.HandleWhichCommand(req)
+	}))
+
+	// Add command_help tool
+	builder.AddTool(mcp.NewTool("command_help", "Get help text for a command (--help flag)", map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"command": map[string]interface{}{
+				"type":        "string",
+				"description": "Command to get help for",
+			},
+		},
+		"required": []string{"command"},
+	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+		return bash.HandleCommandHelp(req)
+	}))
+
+	// Add get_env tool
+	builder.AddTool(mcp.NewTool("get_env", "Get environment variable value", map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"variable": map[string]interface{}{
+				"type":        "string",
+				"description": "Environment variable name",
+			},
+			"all": map[string]interface{}{
+				"type":        "boolean",
+				"description": "Return all environment variables",
+			},
+		},
+	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+		return bash.HandleGetEnv(req)
+	}))
+
+	// Add get_working_dir tool
+	builder.AddTool(mcp.NewTool("get_working_dir", "Get the current working directory", map[string]interface{}{
+		"type": "object",
+	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+		return bash.HandleGetWorkingDir(req)
+	}))
+
+	// Add set_working_dir tool
+	builder.AddTool(mcp.NewTool("set_working_dir", "Set working directory for future commands", map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"directory": map[string]interface{}{
+				"type":        "string",
+				"description": "Directory path to set as working directory",
+			},
+		},
+		"required": []string{"directory"},
+	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+		return bash.HandleSetWorkingDir(req)
+	}))
+
+	// Add system_info tool
+	builder.AddTool(mcp.NewTool("system_info", "Get basic system information", map[string]interface{}{
+		"type": "object",
+	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+		return bash.HandleSystemInfo(req)
+	}))
+
+	// Add process_info tool
+	builder.AddTool(mcp.NewTool("process_info", "Get information about running processes (ps command wrapper)", map[string]interface{}{
+		"type": "object",
+		"properties": map[string]interface{}{
+			"format": map[string]interface{}{
+				"type":        "string",
+				"description": "ps format string (default: aux)",
+			},
+			"filter": map[string]interface{}{
+				"type":        "string",
+				"description": "grep filter for processes",
+			},
+		},
+	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+		return bash.HandleProcessInfo(req)
+	}))
+
+	// Add resources
+	builder.AddResource(mcp.NewResource("bash://system/info", "System Information", "application/json", func(req mcp.ReadResourceRequest) (mcp.ReadResourceResult, error) {
+		return bash.HandleSystemResource(req)
+	}))
+
+	builder.AddResource(mcp.NewResource("bash://history/recent", "Command History", "application/json", func(req mcp.ReadResourceRequest) (mcp.ReadResourceResult, error) {
+		return bash.HandleHistoryResource(req)
+	}))
+
+	builder.AddResource(mcp.NewResource("bash://env/all", "Environment Variables", "application/json", func(req mcp.ReadResourceRequest) (mcp.ReadResourceResult, error) {
+		return bash.HandleEnvResource(req)
+	}))
+
+	return builder.Build(), nil
 }
 
 // DefaultConfig returns default configuration
@@ -148,106 +324,42 @@ func ConfigFromEnv() *Config {
 	return config
 }
 
-// registerTools registers all bash tools with the server
-func (bs *BashServer) registerTools() {
-	// Get all tool definitions from ListTools method
-	tools := bs.ListTools()
-	
-	// Register each tool with its proper definition
-	for _, tool := range tools {
-		var handler mcp.ToolHandler
-		switch tool.Name {
-		case "bash_exec":
-			handler = bs.HandleBashExec
-		case "bash_exec_stream":
-			handler = bs.HandleBashExecStream
-		case "man_page":
-			handler = bs.HandleManPage
-		case "which_command":
-			handler = bs.HandleWhichCommand
-		case "command_help":
-			handler = bs.HandleCommandHelp
-		case "get_env":
-			handler = bs.HandleGetEnv
-		case "get_working_dir":
-			handler = bs.HandleGetWorkingDir
-		case "set_working_dir":
-			handler = bs.HandleSetWorkingDir
-		case "system_info":
-			handler = bs.HandleSystemInfo
-		case "process_info":
-			handler = bs.HandleProcessInfo
-		default:
-			continue
-		}
-		bs.RegisterToolWithDefinition(tool, handler)
-	}
-}
 
-// registerResources registers MCP resources
-func (bs *BashServer) registerResources() {
-	// System information resource
-	systemResource := mcp.Resource{
-		URI:         "bash://system/info",
-		Name:        "System Information",
-		Description: "Live system information and environment state",
-		MimeType:    "application/json",
-	}
-	bs.Server.RegisterResourceWithDefinition(systemResource, bs.HandleSystemResource)
-
-	// Command history resource
-	historyResource := mcp.Resource{
-		URI:         "bash://history/recent",
-		Name:        "Command History",
-		Description: "Recent command execution history",
-		MimeType:    "application/json",
-	}
-	bs.Server.RegisterResourceWithDefinition(historyResource, bs.HandleHistoryResource)
-
-	// Environment variables resource
-	envResource := mcp.Resource{
-		URI:         "bash://env/all",
-		Name:        "Environment Variables",
-		Description: "Complete environment variables",
-		MimeType:    "application/json",
-	}
-	bs.Server.RegisterResourceWithDefinition(envResource, bs.HandleEnvResource)
-}
 
 // addCommandRecord adds a command record to history
-func (bs *BashServer) addCommandRecord(record CommandRecord) {
-	bs.mu.Lock()
-	defer bs.mu.Unlock()
+func (bash *BashOperations) addCommandRecord(record CommandRecord) {
+	bash.mu.Lock()
+	defer bash.mu.Unlock()
 
 	// Add record
-	bs.commandHistory = append(bs.commandHistory, record)
+	bash.commandHistory = append(bash.commandHistory, record)
 
 	// Trim history if it exceeds the maximum size
-	if len(bs.commandHistory) > bs.config.HistorySize {
-		bs.commandHistory = bs.commandHistory[len(bs.commandHistory)-bs.config.HistorySize:]
+	if len(bash.commandHistory) > bash.config.HistorySize {
+		bash.commandHistory = bash.commandHistory[len(bash.commandHistory)-bash.config.HistorySize:]
 	}
 }
 
 // getCommandHistory returns a copy of the command history
-func (bs *BashServer) getCommandHistory() []CommandRecord {
-	bs.mu.RLock()
-	defer bs.mu.RUnlock()
+func (bash *BashOperations) getCommandHistory() []CommandRecord {
+	bash.mu.RLock()
+	defer bash.mu.RUnlock()
 
 	// Return a copy to avoid race conditions
-	history := make([]CommandRecord, len(bs.commandHistory))
-	copy(history, bs.commandHistory)
+	history := make([]CommandRecord, len(bash.commandHistory))
+	copy(history, bash.commandHistory)
 	return history
 }
 
 // getWorkingDir returns the current working directory
-func (bs *BashServer) getWorkingDir() string {
-	bs.mu.RLock()
-	defer bs.mu.RUnlock()
-	return bs.workingDir
+func (bash *BashOperations) getWorkingDir() string {
+	bash.mu.RLock()
+	defer bash.mu.RUnlock()
+	return bash.workingDir
 }
 
 // setWorkingDir sets the working directory
-func (bs *BashServer) setWorkingDir(dir string) error {
+func (bash *BashOperations) setWorkingDir(dir string) error {
 	// Validate directory exists
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
 		return fmt.Errorf("directory does not exist: %s", dir)
@@ -259,30 +371,30 @@ func (bs *BashServer) setWorkingDir(dir string) error {
 		return fmt.Errorf("failed to get absolute path: %w", err)
 	}
 
-	bs.mu.Lock()
-	defer bs.mu.Unlock()
-	bs.workingDir = absDir
+	bash.mu.Lock()
+	defer bash.mu.Unlock()
+	bash.workingDir = absDir
 	return nil
 }
 
 // executeCommand executes a shell command with the given options
-func (bs *BashServer) executeCommand(options ExecutionOptions) (*ExecutionResult, error) {
+func (bash *BashOperations) executeCommand(options ExecutionOptions) (*ExecutionResult, error) {
 	startTime := time.Now()
 
 	// Set default timeout
 	if options.Timeout <= 0 {
-		options.Timeout = bs.config.DefaultTimeout
+		options.Timeout = bash.config.DefaultTimeout
 	}
 
 	// Enforce maximum timeout
-	if options.Timeout > bs.config.MaxTimeout {
-		options.Timeout = bs.config.MaxTimeout
+	if options.Timeout > bash.config.MaxTimeout {
+		options.Timeout = bash.config.MaxTimeout
 	}
 
 	// Set working directory
 	workingDir := options.WorkingDir
 	if workingDir == "" {
-		workingDir = bs.getWorkingDir()
+		workingDir = bash.getWorkingDir()
 	}
 
 	// Create context with timeout
@@ -314,7 +426,7 @@ func (bs *BashServer) executeCommand(options ExecutionOptions) (*ExecutionResult
 	var err error
 
 	if options.CaptureStderr {
-		stdout, stderr, err = bs.runCommandWithStderr(cmd)
+		stdout, stderr, err = bash.runCommandWithStderr(cmd)
 	} else {
 		stdout, err = cmd.Output()
 	}
@@ -351,13 +463,13 @@ func (bs *BashServer) executeCommand(options ExecutionOptions) (*ExecutionResult
 		Duration:   executionTime,
 		OutputSize: len(stdout) + len(stderr),
 	}
-	bs.addCommandRecord(record)
+	bash.addCommandRecord(record)
 
 	return result, nil
 }
 
 // runCommandWithStderr runs a command and captures both stdout and stderr
-func (bs *BashServer) runCommandWithStderr(cmd *exec.Cmd) ([]byte, []byte, error) {
+func (bash *BashOperations) runCommandWithStderr(cmd *exec.Cmd) ([]byte, []byte, error) {
 	var stdout, stderr []byte
 	var err error
 
@@ -413,7 +525,7 @@ func readAll(r interface{ Read([]byte) (int, error) }) ([]byte, error) {
 }
 
 // getSystemInfo returns current system information
-func (bs *BashServer) getSystemInfo() (*SystemInfo, error) {
+func (bash *BashOperations) getSystemInfo() (*SystemInfo, error) {
 	hostname, _ := os.Hostname()
 	
 	currentUser, _ := user.Current()
@@ -434,7 +546,7 @@ func (bs *BashServer) getSystemInfo() (*SystemInfo, error) {
 	// Get kernel version
 	kernel := "unknown"
 	if runtime.GOOS == "linux" {
-		if result, err := bs.executeCommand(ExecutionOptions{Command: "uname -r", CaptureStderr: false}); err == nil {
+		if result, err := bash.executeCommand(ExecutionOptions{Command: "uname -r", CaptureStderr: false}); err == nil {
 			kernel = strings.TrimSpace(result.Stdout)
 		}
 	}

@@ -1,423 +0,0 @@
-package bash
-
-import (
-	"testing"
-	"time"
-	
-	"github.com/xlgmokha/mcp/pkg/mcp"
-)
-
-func TestNewBashServer(t *testing.T) {
-	tests := []struct {
-		name    string
-		config  *Config
-		wantErr bool
-	}{
-		{
-			name:    "default config",
-			config:  nil,
-			wantErr: false,
-		},
-		{
-			name: "custom config",
-			config: &Config{
-				DefaultTimeout: 60,
-				MaxTimeout:     600,
-				HistorySize:    200,
-				WorkingDir:     "/tmp",
-			},
-			wantErr: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			server, err := NewBashServer(tt.config)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("NewBashServer() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr && server == nil {
-				t.Error("NewBashServer() returned nil server")
-			}
-		})
-	}
-}
-
-func TestDefaultConfig(t *testing.T) {
-	config := DefaultConfig()
-	
-	if config.DefaultTimeout != 30 {
-		t.Errorf("DefaultTimeout = %v, want 30", config.DefaultTimeout)
-	}
-	if config.MaxTimeout != 300 {
-		t.Errorf("MaxTimeout = %v, want 300", config.MaxTimeout)
-	}
-	if config.HistorySize != 100 {
-		t.Errorf("HistorySize = %v, want 100", config.HistorySize)
-	}
-	if config.WorkingDir != "" {
-		t.Errorf("WorkingDir = %v, want empty string", config.WorkingDir)
-	}
-}
-
-func TestConfigFromEnv(t *testing.T) {
-	// Set environment variables
-	t.Setenv("BASH_MCP_DEFAULT_TIMEOUT", "45")
-	t.Setenv("BASH_MCP_MAX_TIMEOUT", "600")
-	t.Setenv("BASH_MCP_MAX_HISTORY", "50")
-	t.Setenv("BASH_MCP_WORKING_DIR", "/tmp/test")
-	
-	config := ConfigFromEnv()
-	
-	if config.DefaultTimeout != 45 {
-		t.Errorf("DefaultTimeout = %v, want 45", config.DefaultTimeout)
-	}
-	if config.MaxTimeout != 600 {
-		t.Errorf("MaxTimeout = %v, want 600", config.MaxTimeout)
-	}
-	if config.HistorySize != 50 {
-		t.Errorf("HistorySize = %v, want 50", config.HistorySize)
-	}
-	if config.WorkingDir != "/tmp/test" {
-		t.Errorf("WorkingDir = %v, want /tmp/test", config.WorkingDir)
-	}
-}
-
-func TestExecuteCommand(t *testing.T) {
-	server, err := NewBashServer(nil)
-	if err != nil {
-		t.Fatalf("Failed to create server: %v", err)
-	}
-
-	tests := []struct {
-		name    string
-		options ExecutionOptions
-		wantErr bool
-		check   func(*testing.T, *ExecutionResult)
-	}{
-		{
-			name: "simple echo command",
-			options: ExecutionOptions{
-				Command: "echo 'Hello, World!'",
-			},
-			wantErr: false,
-			check: func(t *testing.T, result *ExecutionResult) {
-				if result.ExitCode != 0 {
-					t.Errorf("ExitCode = %v, want 0", result.ExitCode)
-				}
-				if result.Stdout != "Hello, World!\n" {
-					t.Errorf("Stdout = %v, want 'Hello, World!\\n'", result.Stdout)
-				}
-			},
-		},
-		{
-			name: "command with error",
-			options: ExecutionOptions{
-				Command:       "exit 1",
-				CaptureStderr: true,
-			},
-			wantErr: false,
-			check: func(t *testing.T, result *ExecutionResult) {
-				if result.ExitCode != 1 {
-					t.Errorf("ExitCode = %v, want 1", result.ExitCode)
-				}
-			},
-		},
-		{
-			name: "command with stderr",
-			options: ExecutionOptions{
-				Command:       "echo 'error' >&2",
-				CaptureStderr: true,
-			},
-			wantErr: false,
-			check: func(t *testing.T, result *ExecutionResult) {
-				if result.ExitCode != 0 {
-					t.Errorf("ExitCode = %v, want 0", result.ExitCode)
-				}
-				if result.Stderr != "error\n" {
-					t.Errorf("Stderr = %v, want 'error\\n'", result.Stderr)
-				}
-			},
-		},
-		{
-			name: "command with timeout",
-			options: ExecutionOptions{
-				Command: "sleep 0.1",
-				Timeout: 1,
-			},
-			wantErr: false,
-			check: func(t *testing.T, result *ExecutionResult) {
-				if result.ExitCode != 0 {
-					t.Errorf("ExitCode = %v, want 0", result.ExitCode)
-				}
-			},
-		},
-		{
-			name: "command with environment variable",
-			options: ExecutionOptions{
-				Command: "echo $TEST_VAR",
-				Env: map[string]string{
-					"TEST_VAR": "test_value",
-				},
-			},
-			wantErr: false,
-			check: func(t *testing.T, result *ExecutionResult) {
-				if result.ExitCode != 0 {
-					t.Errorf("ExitCode = %v, want 0", result.ExitCode)
-				}
-				if result.Stdout != "test_value\n" {
-					t.Errorf("Stdout = %v, want 'test_value\\n'", result.Stdout)
-				}
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result, err := server.executeCommand(tt.options)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("executeCommand() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr && result != nil && tt.check != nil {
-				tt.check(t, result)
-			}
-		})
-	}
-}
-
-func TestCommandHistory(t *testing.T) {
-	config := &Config{
-		DefaultTimeout: 30,
-		MaxTimeout:     300,
-		HistorySize:    3,
-		WorkingDir:     "",
-	}
-	
-	server, err := NewBashServer(config)
-	if err != nil {
-		t.Fatalf("Failed to create server: %v", err)
-	}
-
-	// Execute multiple commands
-	for i := 0; i < 5; i++ {
-		_, err := server.executeCommand(ExecutionOptions{
-			Command: "echo test",
-		})
-		if err != nil {
-			t.Fatalf("Failed to execute command: %v", err)
-		}
-	}
-
-	// Check history size is limited
-	history := server.getCommandHistory()
-	if len(history) != 3 {
-		t.Errorf("History length = %v, want 3", len(history))
-	}
-}
-
-func TestSetWorkingDir(t *testing.T) {
-	server, err := NewBashServer(nil)
-	if err != nil {
-		t.Fatalf("Failed to create server: %v", err)
-	}
-
-	tests := []struct {
-		name    string
-		dir     string
-		wantErr bool
-	}{
-		{
-			name:    "valid directory",
-			dir:     "/tmp",
-			wantErr: false,
-		},
-		{
-			name:    "non-existent directory",
-			dir:     "/this/does/not/exist",
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := server.setWorkingDir(tt.dir)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("setWorkingDir() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestGetSystemInfo(t *testing.T) {
-	server, err := NewBashServer(nil)
-	if err != nil {
-		t.Fatalf("Failed to create server: %v", err)
-	}
-
-	info, err := server.getSystemInfo()
-	if err != nil {
-		t.Fatalf("getSystemInfo() error = %v", err)
-	}
-
-	// Check that required fields are populated
-	if info.Hostname == "" {
-		t.Error("Hostname is empty")
-	}
-	if info.OS == "" {
-		t.Error("OS is empty")
-	}
-	if info.Architecture == "" {
-		t.Error("Architecture is empty")
-	}
-	if info.User == "" {
-		t.Error("User is empty")
-	}
-}
-
-func TestHandleBashExec(t *testing.T) {
-	server, err := NewBashServer(nil)
-	if err != nil {
-		t.Fatalf("Failed to create server: %v", err)
-	}
-
-	req := mcp.CallToolRequest{
-		Name: "bash_exec",
-		Arguments: map[string]interface{}{
-			"command": "echo 'test output'",
-		},
-	}
-
-	result, err := server.HandleBashExec(req)
-	if err != nil {
-		t.Fatalf("HandleBashExec() error = %v", err)
-	}
-
-	// Check that we got content back
-	if len(result.Content) == 0 {
-		t.Fatal("No content returned")
-	}
-
-	// The content should be a TextContent
-	textContent, ok := result.Content[0].(mcp.TextContent)
-	if !ok {
-		t.Fatal("Content is not TextContent")
-	}
-
-	// Should contain the output
-	if textContent.Text == "" {
-		t.Error("Text content is empty")
-	}
-}
-
-func TestHandleSystemInfo(t *testing.T) {
-	server, err := NewBashServer(nil)
-	if err != nil {
-		t.Fatalf("Failed to create server: %v", err)
-	}
-
-	req := mcp.CallToolRequest{
-		Name:      "system_info",
-		Arguments: map[string]interface{}{},
-	}
-
-	result, err := server.HandleSystemInfo(req)
-	if err != nil {
-		t.Fatalf("HandleSystemInfo() error = %v", err)
-	}
-
-	// Check that we got content back
-	if len(result.Content) == 0 {
-		t.Fatal("No content returned")
-	}
-}
-
-func TestHandleSetWorkingDir(t *testing.T) {
-	server, err := NewBashServer(nil)
-	if err != nil {
-		t.Fatalf("Failed to create server: %v", err)
-	}
-
-	req := mcp.CallToolRequest{
-		Name: "set_working_dir",
-		Arguments: map[string]interface{}{
-			"directory": "/tmp",
-		},
-	}
-
-	_, err = server.HandleSetWorkingDir(req)
-	if err != nil {
-		t.Fatalf("HandleSetWorkingDir() error = %v", err)
-	}
-
-	// Verify the working directory was changed
-	if server.getWorkingDir() != "/tmp" {
-		t.Errorf("Working directory = %v, want /tmp", server.getWorkingDir())
-	}
-}
-
-func TestHandleGetEnv(t *testing.T) {
-	server, err := NewBashServer(nil)
-	if err != nil {
-		t.Fatalf("Failed to create server: %v", err)
-	}
-
-	// Set a test environment variable
-	t.Setenv("TEST_ENV_VAR", "test_value")
-
-	req := mcp.CallToolRequest{
-		Name: "get_env",
-		Arguments: map[string]interface{}{
-			"name": "TEST_ENV_VAR",
-		},
-	}
-
-	result, err := server.HandleGetEnv(req)
-	if err != nil {
-		t.Fatalf("HandleGetEnv() error = %v", err)
-	}
-
-	// Check that we got content back
-	if len(result.Content) == 0 {
-		t.Fatal("No content returned")
-	}
-}
-
-func TestCommandRecordCreation(t *testing.T) {
-	server, err := NewBashServer(nil)
-	if err != nil {
-		t.Fatalf("Failed to create server: %v", err)
-	}
-
-	// Execute a command
-	startTime := time.Now()
-	result, err := server.executeCommand(ExecutionOptions{
-		Command: "echo test",
-	})
-	if err != nil {
-		t.Fatalf("Failed to execute command: %v", err)
-	}
-
-	// Get history
-	history := server.getCommandHistory()
-	if len(history) != 1 {
-		t.Fatalf("Expected 1 history record, got %d", len(history))
-	}
-
-	record := history[0]
-	
-	// Verify record fields
-	if record.Command != "echo test" {
-		t.Errorf("Command = %v, want 'echo test'", record.Command)
-	}
-	if record.ExitCode != 0 {
-		t.Errorf("ExitCode = %v, want 0", record.ExitCode)
-	}
-	if record.Timestamp.Before(startTime) {
-		t.Error("Timestamp is before command start time")
-	}
-	if record.Duration != result.ExecutionTime {
-		t.Errorf("Duration = %v, want %v", record.Duration, result.ExecutionTime)
-	}
-}
\ No newline at end of file