diff --git a/cmd/mcptools/commands/alias.go b/cmd/mcptools/commands/alias.go
new file mode 100644
index 0000000..dc934c6
--- /dev/null
+++ b/cmd/mcptools/commands/alias.go
@@ -0,0 +1,147 @@
+package commands
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/f/mcptools/pkg/alias"
+	"github.com/spf13/cobra"
+)
+
+// AliasCmd creates the alias command.
+func AliasCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "alias",
+		Short: "Manage MCP server aliases",
+		Long: `Manage aliases for MCP servers.
+
+This command allows you to register MCP server commands with a friendly name and
+reuse them later.
+
+Aliases are stored in $HOME/.mcpt/aliases.json.
+
+Examples:
+  # Add a new server alias
+  mcp alias add myfs npx -y @modelcontextprotocol/server-filesystem ~/
+
+  # List all registered server aliases
+  mcp alias list
+
+  # Remove a server alias
+  mcp alias remove myfs
+
+  # Use an alias with any MCP command
+  mcp tools myfs`,
+	}
+
+	cmd.AddCommand(aliasAddCmd())
+	cmd.AddCommand(aliasListCmd())
+	cmd.AddCommand(aliasRemoveCmd())
+
+	return cmd
+}
+
+func aliasAddCmd() *cobra.Command {
+	addCmd := &cobra.Command{
+		Use:                "add [alias] [command args...]",
+		Short:              "Add a new MCP server alias",
+		DisableFlagParsing: true,
+		Long: `Add a new alias for an MCP server command.
+
+The alias will be registered and can be used in place of the server command.
+
+Example:
+  mcp alias add myfs npx -y @modelcontextprotocol/server-filesystem ~/`,
+		Args: cobra.MinimumNArgs(2),
+		RunE: func(thisCmd *cobra.Command, args []string) error {
+			if len(args) == 1 && (args[0] == FlagHelp || args[0] == FlagHelpShort) {
+				_ = thisCmd.Help()
+				return nil
+			}
+
+			aliasName := args[0]
+			serverCommand := strings.Join(args[1:], " ")
+
+			aliases, err := alias.Load()
+			if err != nil {
+				return fmt.Errorf("error loading aliases: %w", err)
+			}
+
+			aliases[aliasName] = alias.ServerAlias{
+				Command: serverCommand,
+			}
+
+			if saveErr := alias.Save(aliases); saveErr != nil {
+				return fmt.Errorf("error saving aliases: %w", saveErr)
+			}
+
+			fmt.Fprintf(thisCmd.OutOrStdout(), "Alias '%s' registered for command: %s\n", aliasName, serverCommand)
+			return nil
+		},
+	}
+	return addCmd
+}
+
+func aliasListCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "list",
+		Short: "List all registered MCP server aliases",
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			// Load existing aliases
+			aliases, err := alias.Load()
+			if err != nil {
+				return fmt.Errorf("error loading aliases: %w", err)
+			}
+
+			if len(aliases) == 0 {
+				fmt.Fprintln(cmd.OutOrStdout(), "No aliases registered.")
+				return nil
+			}
+
+			fmt.Fprintln(cmd.OutOrStdout(), "Registered MCP server aliases:")
+			for name, a := range aliases {
+				fmt.Fprintf(cmd.OutOrStdout(), "  %s: %s\n", name, a.Command)
+			}
+
+			return nil
+		},
+	}
+}
+
+func aliasRemoveCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "remove <name>",
+		Short: "Remove an MCP server alias",
+		Long: `Remove a registered alias for an MCP server command.
+
+Example:
+  mcp alias remove myfs`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(thisCmd *cobra.Command, args []string) error {
+			if len(args) == 1 && (args[0] == FlagHelp || args[0] == FlagHelpShort) {
+				_ = thisCmd.Help()
+				return nil
+			}
+
+			aliasName := args[0]
+
+			aliases, err := alias.Load()
+			if err != nil {
+				return fmt.Errorf("error loading aliases: %w", err)
+			}
+
+			if _, exists := aliases[aliasName]; !exists {
+				return fmt.Errorf("alias '%s' does not exist", aliasName)
+			}
+
+			delete(aliases, aliasName)
+
+			if saveErr := alias.Save(aliases); saveErr != nil {
+				return fmt.Errorf("error saving aliases: %w", saveErr)
+			}
+
+			fmt.Fprintf(thisCmd.OutOrStdout(), "Alias '%s' removed.\n", aliasName)
+			return nil
+		},
+	}
+}
diff --git a/cmd/mcptools/commands/alias_test.go b/cmd/mcptools/commands/alias_test.go
new file mode 100644
index 0000000..3582052
--- /dev/null
+++ b/cmd/mcptools/commands/alias_test.go
@@ -0,0 +1,167 @@
+package commands
+
+import (
+	"bytes"
+	"os"
+	"testing"
+
+	"github.com/f/mcptools/pkg/alias"
+)
+
+func TestAliasCommands(t *testing.T) {
+	// Create a temporary directory for test files
+	tmpDir := t.TempDir()
+	if err := os.Setenv("HOME", tmpDir); err != nil {
+		t.Fatalf("Failed to set HOME environment variable: %v", err)
+	}
+
+	// Test alias add command
+	t.Run("add", func(t *testing.T) {
+		cmd := aliasAddCmd()
+		buf := new(bytes.Buffer)
+		cmd.SetOut(buf)
+
+		// Run add command
+		cmd.SetArgs([]string{"myalias", "echo", "hello"})
+		err := cmd.Execute()
+		if err != nil {
+			t.Errorf("add command failed: %v", err)
+		}
+
+		// Check output
+		output := buf.String()
+		if output == "" {
+			t.Error("Expected output from add command, got empty string")
+		}
+
+		// Verify alias was saved
+		aliases, err := alias.Load()
+		if err != nil {
+			t.Errorf("Failed to load aliases: %v", err)
+		}
+
+		serverAlias, exists := aliases["myalias"]
+		if !exists {
+			t.Error("Alias 'myalias' was not saved")
+		} else if serverAlias.Command != "echo hello" {
+			t.Errorf("Incorrect command stored. Expected 'echo hello', got '%s'", serverAlias.Command)
+		}
+	})
+
+	// Test alias list command
+	t.Run("list", func(t *testing.T) {
+		// First verify the alias exists
+		aliases, err := alias.Load()
+		if err != nil {
+			t.Errorf("Failed to load aliases: %v", err)
+		}
+
+		if _, exists := aliases["myalias"]; !exists {
+			t.Log("Alias 'myalias' not found, adding it for list test")
+			// Add it back if missing
+			aliases["myalias"] = alias.ServerAlias{Command: "echo hello"}
+			err = alias.Save(aliases)
+			if err != nil {
+				t.Fatalf("Failed to save alias for test: %v", err)
+			}
+		}
+
+		// Setup cmd
+		cmd := aliasListCmd()
+		buf := new(bytes.Buffer)
+		cmd.SetOut(buf)
+
+		// Run list command
+		err = cmd.Execute()
+		if err != nil {
+			t.Errorf("list command failed: %v", err)
+		}
+
+		// Check output
+		output := buf.String()
+		if !bytes.Contains(buf.Bytes(), []byte("myalias")) {
+			t.Errorf("Expected output to contain 'myalias', got: %s", output)
+		}
+		if !bytes.Contains(buf.Bytes(), []byte("echo hello")) {
+			t.Errorf("Expected output to contain 'echo hello', got: %s", output)
+		}
+	})
+
+	// Test alias remove command
+	t.Run("remove", func(t *testing.T) {
+		// First verify the alias exists
+		aliases, err := alias.Load()
+		if err != nil {
+			t.Errorf("Failed to load aliases: %v", err)
+		}
+
+		if _, exists := aliases["myalias"]; !exists {
+			t.Log("Alias 'myalias' not found, adding it for remove test")
+			// Add it back if missing
+			aliases["myalias"] = alias.ServerAlias{Command: "echo hello"}
+			err = alias.Save(aliases)
+			if err != nil {
+				t.Fatalf("Failed to save alias for test: %v", err)
+			}
+		}
+
+		// Setup cmd
+		cmd := aliasRemoveCmd()
+		buf := new(bytes.Buffer)
+		cmd.SetOut(buf)
+
+		// Run remove command
+		cmd.SetArgs([]string{"myalias"})
+		err = cmd.Execute()
+		if err != nil {
+			t.Errorf("remove command failed: %v", err)
+		}
+
+		// Check output
+		output := buf.String()
+		if !bytes.Contains(buf.Bytes(), []byte("removed")) {
+			t.Errorf("Expected output to contain 'removed', got: %s", output)
+		}
+
+		// Verify alias was removed
+		updatedAliases, err := alias.Load()
+		if err != nil {
+			t.Errorf("Failed to load aliases: %v", err)
+		}
+
+		if _, exists := updatedAliases["myalias"]; exists {
+			t.Error("Alias 'myalias' was not removed")
+		}
+	})
+
+	// Test remove non-existent alias
+	t.Run("remove_nonexistent", func(t *testing.T) {
+		// Setup cmd
+		cmd := aliasRemoveCmd()
+		cmd.SetArgs([]string{"nonexistent"})
+		err := cmd.Execute()
+
+		// Should get an error
+		if err == nil {
+			t.Error("Expected error when removing non-existent alias, got nil")
+		}
+	})
+
+	// Test main alias command
+	t.Run("main_command_help", func(t *testing.T) {
+		cmd := AliasCmd()
+		buf := new(bytes.Buffer)
+		cmd.SetOut(buf)
+
+		cmd.SetArgs([]string{"--help"})
+		err := cmd.Execute()
+		if err != nil {
+			t.Errorf("main alias help command failed: %v", err)
+		}
+
+		output := buf.String()
+		if output == "" {
+			t.Error("Expected help output for main alias command, got empty string")
+		}
+	})
+}
diff --git a/cmd/mcptools/commands/call.go b/cmd/mcptools/commands/call.go
new file mode 100644
index 0000000..83133c0
--- /dev/null
+++ b/cmd/mcptools/commands/call.go
@@ -0,0 +1,120 @@
+package commands
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+// CallCmd creates the call command.
+func CallCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:                "call entity [command args...]",
+		Short:              "Call a tool, resource, or prompt on the MCP server",
+		DisableFlagParsing: true,
+		SilenceUsage:       true,
+		Run: func(thisCmd *cobra.Command, args []string) {
+			if len(args) == 1 && (args[0] == FlagHelp || args[0] == FlagHelpShort) {
+				_ = thisCmd.Help()
+				return
+			}
+
+			if len(args) == 0 {
+				fmt.Fprintln(os.Stderr, "Error: entity name is required")
+				fmt.Fprintln(
+					os.Stderr,
+					"Example: mcp call read_file npx -y @modelcontextprotocol/server-filesystem ~",
+				)
+				os.Exit(1)
+			}
+
+			cmdArgs := args
+			parsedArgs := []string{}
+			entityName := ""
+
+			i := 0
+			entityExtracted := false
+
+			for i < len(cmdArgs) {
+				switch {
+				case (cmdArgs[i] == FlagFormat || cmdArgs[i] == FlagFormatShort) && i+1 < len(cmdArgs):
+					FormatOption = cmdArgs[i+1]
+					i += 2
+				case (cmdArgs[i] == FlagParams || cmdArgs[i] == FlagParamsShort) && i+1 < len(cmdArgs):
+					ParamsString = cmdArgs[i+1]
+					i += 2
+				case !entityExtracted:
+					entityName = cmdArgs[i]
+					entityExtracted = true
+					i++
+				default:
+					parsedArgs = append(parsedArgs, cmdArgs[i])
+					i++
+				}
+			}
+
+			if entityName == "" {
+				fmt.Fprintln(os.Stderr, "Error: entity name is required")
+				fmt.Fprintln(
+					os.Stderr,
+					"Example: mcp call read_file npx -y @modelcontextprotocol/server-filesystem ~",
+				)
+				os.Exit(1)
+			}
+
+			entityType := EntityTypeTool
+
+			parts := strings.SplitN(entityName, ":", 2)
+			if len(parts) == 2 {
+				entityType = parts[0]
+				entityName = parts[1]
+			}
+
+			if len(parsedArgs) == 0 {
+				fmt.Fprintln(os.Stderr, "Error: command to execute is required when using stdio transport")
+				fmt.Fprintln(
+					os.Stderr,
+					"Example: mcp call read_file npx -y @modelcontextprotocol/server-filesystem ~",
+				)
+				os.Exit(1)
+			}
+
+			var params map[string]any
+			if ParamsString != "" {
+				if jsonErr := json.Unmarshal([]byte(ParamsString), &params); jsonErr != nil {
+					fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
+					os.Exit(1)
+				}
+			}
+
+			mcpClient, clientErr := CreateClientFunc(parsedArgs)
+			if clientErr != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
+				os.Exit(1)
+			}
+
+			var resp map[string]any
+			var execErr error
+
+			switch entityType {
+			case EntityTypeTool:
+				resp, execErr = mcpClient.CallTool(entityName, params)
+			case EntityTypeRes:
+				resp, execErr = mcpClient.ReadResource(entityName)
+			case EntityTypePrompt:
+				resp, execErr = mcpClient.GetPrompt(entityName)
+			default:
+				fmt.Fprintf(os.Stderr, "Error: unsupported entity type: %s\n", entityType)
+				os.Exit(1)
+			}
+
+			if formatErr := FormatAndPrintResponse(thisCmd, resp, execErr); formatErr != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
+				os.Exit(1)
+			}
+		},
+	}
+}
diff --git a/cmd/mcptools/commands/call_test.go b/cmd/mcptools/commands/call_test.go
new file mode 100644
index 0000000..b9c0112
--- /dev/null
+++ b/cmd/mcptools/commands/call_test.go
@@ -0,0 +1,103 @@
+package commands
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestCallCmdRun_Help(t *testing.T) {
+	// Test that the help flag displays help text
+	cmd := CallCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+
+	// Execute with help flag
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+
+	// Check that help output is not empty
+	if buf.String() == "" {
+		t.Error("Expected help output, got empty string")
+	}
+}
+
+func TestCallCmdRun_Tool(t *testing.T) {
+	// Create a mock client that returns successful response
+	mockResponse := map[string]any{
+		"content": []any{
+			map[string]any{
+				"type": "text",
+				"text": "Tool executed successfully",
+			},
+		},
+	}
+
+	cleanup := setupMockClient(func(method string, _ any) (map[string]any, error) {
+		if method != "tools/call" {
+			t.Errorf("Expected method 'tools/call', got %q", method)
+		}
+		return mockResponse, nil
+	})
+	defer cleanup()
+
+	// Set up command
+	cmd := CallCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+
+	// Execute command with tool
+	cmd.SetArgs([]string{"test-tool", "--params", `{"key":"value"}`, "server", "arg"})
+	err := cmd.Execute()
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+
+	// Verify output contains expected content
+	output := strings.TrimSpace(buf.String())
+	expectedOutput := "Tool executed successfully"
+	assertEquals(t, output, expectedOutput)
+}
+
+func TestCallCmdRun_Resource(t *testing.T) {
+	t.Skip("Skipping resource command test as resources are not working as expected")
+
+	// Create a mock client that returns successful response
+	mockResponse := map[string]any{
+		"resources": []any{
+			map[string]any{
+				"uri":         "test-resource",
+				"type":        "text",
+				"description": "Test resource description",
+			},
+		},
+	}
+
+	cleanup := setupMockClient(func(method string, _ any) (map[string]any, error) {
+		if method != "resources/read" {
+			t.Errorf("Expected method 'resources/read', got %q", method)
+		}
+		return mockResponse, nil
+	})
+	defer cleanup()
+
+	// Set up command
+	cmd := CallCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+
+	// Execute command with resource
+	cmd.SetArgs([]string{"resource:test-resource", "server", "arg"})
+	err := cmd.Execute()
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+
+	// Verify output contains expected content
+	output := buf.String()
+	expectedOutput := "Resource content"
+	assertContains(t, output, expectedOutput)
+}
diff --git a/cmd/mcptools/commands/get_prompt.go b/cmd/mcptools/commands/get_prompt.go
new file mode 100644
index 0000000..a39ed95
--- /dev/null
+++ b/cmd/mcptools/commands/get_prompt.go
@@ -0,0 +1,88 @@
+package commands
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+// GetPromptCmd creates the get-prompt command.
+func GetPromptCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:                "get-prompt prompt [command args...]",
+		Short:              "Get a prompt on the MCP server",
+		DisableFlagParsing: true,
+		SilenceUsage:       true,
+		Run: func(thisCmd *cobra.Command, args []string) {
+			if len(args) == 1 && (args[0] == FlagHelp || args[0] == FlagHelpShort) {
+				_ = thisCmd.Help()
+				return
+			}
+
+			if len(args) == 0 {
+				fmt.Fprintln(os.Stderr, "Error: prompt name is required")
+				fmt.Fprintln(
+					os.Stderr,
+					"Example: mcp get-prompt read_file npx -y @modelcontextprotocol/server-filesystem ~",
+				)
+				os.Exit(1)
+			}
+
+			cmdArgs := args
+			parsedArgs := []string{}
+			promptName := ""
+
+			i := 0
+			promptExtracted := false
+
+			for i < len(cmdArgs) {
+				switch {
+				case (cmdArgs[i] == FlagFormat || cmdArgs[i] == FlagFormatShort) && i+1 < len(cmdArgs):
+					FormatOption = cmdArgs[i+1]
+					i += 2
+				case (cmdArgs[i] == FlagParams || cmdArgs[i] == FlagParamsShort) && i+1 < len(cmdArgs):
+					ParamsString = cmdArgs[i+1]
+					i += 2
+				case !promptExtracted:
+					promptName = cmdArgs[i]
+					promptExtracted = true
+					i++
+				default:
+					parsedArgs = append(parsedArgs, cmdArgs[i])
+					i++
+				}
+			}
+
+			if promptName == "" {
+				fmt.Fprintln(os.Stderr, "Error: prompt name is required")
+				fmt.Fprintln(
+					os.Stderr,
+					"Example: mcp get-prompt read_file npx -y @modelcontextprotocol/server-filesystem ~",
+				)
+				os.Exit(1)
+			}
+
+			var params map[string]any
+			if ParamsString != "" {
+				if jsonErr := json.Unmarshal([]byte(ParamsString), &params); jsonErr != nil {
+					fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
+					os.Exit(1)
+				}
+			}
+
+			mcpClient, clientErr := CreateClientFunc(parsedArgs)
+			if clientErr != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
+				os.Exit(1)
+			}
+
+			resp, execErr := mcpClient.GetPrompt(promptName)
+			if formatErr := FormatAndPrintResponse(thisCmd, resp, execErr); formatErr != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
+				os.Exit(1)
+			}
+		},
+	}
+}
diff --git a/cmd/mcptools/commands/mock.go b/cmd/mcptools/commands/mock.go
new file mode 100644
index 0000000..3f03700
--- /dev/null
+++ b/cmd/mcptools/commands/mock.go
@@ -0,0 +1,126 @@
+package commands
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/f/mcptools/pkg/mock"
+	"github.com/spf13/cobra"
+)
+
+// MockCmd creates the mock command.
+func MockCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "mock [type] [name] [description] [content]...",
+		Short: "Create a mock MCP server with tools, prompts, and resources",
+		Long: `Create a mock MCP server with tools, prompts, and resources.
+This is useful for testing MCP clients without implementing a full server.
+
+The mock server implements the MCP protocol with:
+- Full initialization handshake (initialize method)
+- Support for notifications/initialized notification
+- Tool listing with standardized schema format
+- Tool calling with simple responses
+- Resource listing and reading with proper format
+- Prompt listing and retrieving with proper format
+- Standard error codes (-32601 for method not found)
+- Detailed request/response logging to ~/.mcpt/logs/mock.log
+
+Available types:
+- tool <name> <description>
+- prompt <name> <description> <template>
+- resource <uri> <description> <content>
+
+Example:
+  mcp mock tool hello_world "when user says hello world, run this tool"
+  mcp mock tool hello_world "A greeting tool" \
+         prompt welcome "A welcome prompt" "Hello {{name}}, welcome to {{location}}!" \
+         resource docs:readme "Documentation" "# Mock MCP Server\nThis is a mock server"`,
+		Args: cobra.MinimumNArgs(2),
+		Run: func(_ *cobra.Command, args []string) {
+			tools := make(map[string]string)
+			prompts := make(map[string]map[string]string)
+			resources := make(map[string]map[string]string)
+
+			i := 0
+			for i < len(args) {
+				entityType := args[i]
+				i++
+
+				switch entityType {
+				case EntityTypeTool:
+					if i+1 >= len(args) {
+						fmt.Fprintln(os.Stderr, "Error: each tool must have both a name and description")
+						fmt.Fprintln(os.Stderr, "Example: mcp mock tool hello_world \"when user says hello world, run this tool\"")
+						os.Exit(1)
+					}
+
+					toolName := args[i]
+					toolDescription := args[i+1]
+					tools[toolName] = toolDescription
+					fmt.Fprintf(os.Stderr, "Added tool: %s - %s\n", toolName, toolDescription)
+					i += 2
+
+				case EntityTypePrompt:
+					if i+2 >= len(args) {
+						fmt.Fprintln(os.Stderr, "Error: each prompt must have a name, description, and template")
+						fmt.Fprintln(os.Stderr, "Example: mcp mock prompt welcome \"Welcome message\" \"Hello {{name}}!\"")
+						os.Exit(1)
+					}
+
+					promptName := args[i]
+					promptDescription := args[i+1]
+					promptTemplate := args[i+2]
+
+					prompts[promptName] = map[string]string{
+						"description": promptDescription,
+						"template":    promptTemplate,
+					}
+
+					fmt.Fprintf(os.Stderr, "Added prompt: %s - %s\n", promptName, promptDescription)
+					i += 3
+
+				case EntityTypeRes:
+					if i+2 >= len(args) {
+						fmt.Fprintln(os.Stderr, "Error: each resource must have a URI, description, and content")
+						fmt.Fprintln(os.Stderr, "Example: mcp mock resource docs:readme \"Documentation\" \"# README\"")
+						os.Exit(1)
+					}
+
+					resourceURI := args[i]
+					resourceDescription := args[i+1]
+					resourceContent := args[i+2]
+
+					resources[resourceURI] = map[string]string{
+						"description": resourceDescription,
+						"content":     resourceContent,
+					}
+
+					fmt.Fprintf(os.Stderr, "Added resource: %s - %s\n", resourceURI, resourceDescription)
+					i += 3
+
+				default:
+					fmt.Fprintf(os.Stderr, "Error: unknown entity type: %s\n", entityType)
+					fmt.Fprintln(os.Stderr, "Available types: tool, prompt, resource")
+					os.Exit(1)
+				}
+			}
+
+			if len(tools) == 0 && len(prompts) == 0 && len(resources) == 0 {
+				fmt.Fprintln(os.Stderr, "Error: at least one tool, prompt, or resource must be specified")
+				os.Exit(1)
+			}
+
+			fmt.Fprintf(os.Stderr, "Starting mock MCP server with %d tool(s), %d prompt(s), and %d resource(s)\n",
+				len(tools), len(prompts), len(resources))
+			fmt.Fprintf(os.Stderr, "Use Ctrl+C to exit\n")
+
+			if err := mock.RunMockServer(tools, prompts, resources); err != nil {
+				fmt.Fprintf(os.Stderr, "Error running mock server: %v\n", err)
+				os.Exit(1)
+			}
+		},
+	}
+
+	return cmd
+}
diff --git a/cmd/mcptools/new.go b/cmd/mcptools/commands/new.go
similarity index 97%
rename from cmd/mcptools/new.go
rename to cmd/mcptools/commands/new.go
index 3f806c3..557bca3 100644
--- a/cmd/mcptools/new.go
+++ b/cmd/mcptools/commands/new.go
@@ -1,4 +1,4 @@
-package main
+package commands
 
 import (
 	"fmt"
@@ -17,8 +17,8 @@ const (
 	transportSSE   = "sse"
 )
 
-// newNewCmd returns a new 'new' command for scaffolding MCP projects.
-func newNewCmd() *cobra.Command {
+// NewCmd returns a new 'new' command for scaffolding MCP projects.
+func NewCmd() *cobra.Command {
 	var sdkFlag string
 	var transportFlag string
 
@@ -183,10 +183,8 @@ func copyFile(srcPath, destPath string, replacements map[string]string) error {
 
 	// Apply replacements
 	fileContent := string(content)
-	if replacements != nil { // nolint
-		for key, value := range replacements {
-			fileContent = strings.ReplaceAll(fileContent, key, value)
-		}
+	for key, value := range replacements {
+		fileContent = strings.ReplaceAll(fileContent, key, value)
 	}
 
 	// Ensure parent directory exists
diff --git a/cmd/mcptools/commands/prompts.go b/cmd/mcptools/commands/prompts.go
new file mode 100644
index 0000000..c15b79a
--- /dev/null
+++ b/cmd/mcptools/commands/prompts.go
@@ -0,0 +1,39 @@
+package commands
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+// PromptsCmd creates the prompts command.
+func PromptsCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:                "prompts [command args...]",
+		Short:              "List available prompts on the MCP server",
+		DisableFlagParsing: true,
+		SilenceUsage:       true,
+		Run: func(thisCmd *cobra.Command, args []string) {
+			if len(args) == 1 && (args[0] == FlagHelp || args[0] == FlagHelpShort) {
+				_ = thisCmd.Help()
+				return
+			}
+
+			parsedArgs := ProcessFlags(args)
+
+			mcpClient, err := CreateClientFunc(parsedArgs)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+				fmt.Fprintf(os.Stderr, "Example: mcp prompts npx -y @modelcontextprotocol/server-filesystem ~\n")
+				os.Exit(1)
+			}
+
+			resp, listErr := mcpClient.ListPrompts()
+			if formatErr := FormatAndPrintResponse(thisCmd, resp, listErr); formatErr != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
+				os.Exit(1)
+			}
+		},
+	}
+}
diff --git a/cmd/mcptools/commands/prompts_test.go b/cmd/mcptools/commands/prompts_test.go
new file mode 100644
index 0000000..cb89d8f
--- /dev/null
+++ b/cmd/mcptools/commands/prompts_test.go
@@ -0,0 +1,62 @@
+package commands
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestPromptsCmdRun_Help(t *testing.T) {
+	// Test that the help flag displays help text
+	cmd := PromptsCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+
+	// Execute with help flag
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+
+	// Check that help output is not empty
+	if buf.String() == "" {
+		t.Error("Expected help output, got empty string")
+	}
+}
+
+func TestPromptsCmdRun_Success(t *testing.T) {
+	// Create a mock client that returns successful response
+	mockResponse := map[string]any{
+		"prompts": []any{
+			map[string]any{
+				"name":        "test-prompt",
+				"description": "Test prompt description",
+			},
+		},
+	}
+
+	cleanup := setupMockClient(func(method string, _ any) (map[string]any, error) {
+		if method != "prompts/list" {
+			t.Errorf("Expected method 'prompts/list', got %q", method)
+		}
+		return mockResponse, nil
+	})
+	defer cleanup()
+
+	// Set up command
+	cmd := PromptsCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+
+	// Execute command
+	cmd.SetArgs([]string{"server", "arg"})
+	err := cmd.Execute()
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+
+	// Verify output contains expected content
+	output := buf.String()
+	assertContains(t, output, "test-prompt")
+	assertContains(t, output, "Test prompt description")
+}
diff --git a/cmd/mcptools/commands/proxy.go b/cmd/mcptools/commands/proxy.go
new file mode 100644
index 0000000..e2de9da
--- /dev/null
+++ b/cmd/mcptools/commands/proxy.go
@@ -0,0 +1,234 @@
+package commands
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/f/mcptools/pkg/proxy"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// ProxyCmd creates the proxy command.
+func ProxyCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "proxy",
+		Short: "Proxy MCP tool requests to shell scripts",
+		Long: `Proxy MCP tool requests to shell scripts.
+
+This command allows you to register shell scripts as MCP tools and proxy MCP requests to them.
+The scripts will receive tool parameters as environment variables.
+
+Examples:
+  # Register a shell script as an MCP tool
+  mcp proxy tool add_operation "Adds a and b" "a:int,b:int" ./add.sh
+
+  # Register an inline command as an MCP tool
+  mcp proxy tool add_operation "Adds a and b" "a:int,b:int" -e 'echo "total is $a + $b = $(($a+$b))"'
+
+  # Start a proxy server with the registered tools
+  mcp proxy start`,
+	}
+
+	cmd.AddCommand(ProxyToolCmd())
+	cmd.AddCommand(ProxyStartCmd())
+
+	return cmd
+}
+
+// ProxyToolCmd creates the proxy tool command.
+func ProxyToolCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "tool [name] [description] [parameters] [script]",
+		Short: "Register a shell script as an MCP tool",
+		Long: `Register a shell script or inline command as an MCP tool that can be called via the MCP protocol.
+Parameters should be specified in the format "name:type,name:type,..." where type can be:
+- string: Text values
+- int: Integer numbers
+- float: Floating-point numbers
+- bool: Boolean values (true/false)
+
+The script or command will receive parameters as environment variables.
+
+You can either provide a script file path or use the -e flag to specify an inline command.
+Example with script:
+  mcp proxy tool add_operation "Adds a and b" "a:int,b:int" ./add.sh
+
+Example with inline command:
+  mcp proxy tool add_op "Adds given numbers" "a:int,b:int" -e "echo \"total is $a + $b = ${$a+$b}\""
+
+To unregister a tool, use the --unregister flag:
+  mcp proxy tool --unregister tool_name`,
+		Args: func(cmd *cobra.Command, args []string) error {
+			unregister, _ := cmd.Flags().GetBool("unregister")
+			if unregister {
+				if len(args) != 1 {
+					return fmt.Errorf("unregister requires exactly one argument: the tool name")
+				}
+				return nil
+			}
+			return cobra.RangeArgs(3, 4)(cmd, args)
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			unregister, _ := cmd.Flags().GetBool("unregister")
+			if unregister {
+				name := args[0]
+				// Load existing config
+				config, loadErr := LoadProxyConfig()
+				if loadErr != nil {
+					return fmt.Errorf("error loading config: %w", loadErr)
+				}
+
+				// Check if tool exists
+				if _, exists := config[name]; !exists {
+					return fmt.Errorf("tool %s not found", name)
+				}
+
+				// Remove the tool from config
+				delete(config, name)
+
+				// Save updated config
+				if saveErr := SaveProxyConfig(config); saveErr != nil {
+					return fmt.Errorf("error saving config: %w", saveErr)
+				}
+
+				fmt.Printf("Unregistered tool: %s\n", name)
+				return nil
+			}
+
+			name := args[0]
+			description := args[1]
+			parameters := args[2]
+			scriptPath := ""
+			if len(args) > 3 {
+				scriptPath = args[3]
+			}
+
+			// Get the inline command from the -e flag
+			command, _ := cmd.Flags().GetString("execute")
+
+			// Either script path or command must be provided
+			if scriptPath == "" && command == "" {
+				return fmt.Errorf("either script path or command (-e) must be provided")
+			}
+
+			// Load existing config
+			config, loadErr := LoadProxyConfig()
+			if loadErr != nil {
+				return fmt.Errorf("error loading config: %w", loadErr)
+			}
+
+			// Add the new tool to config
+			config[name] = map[string]string{
+				"description": description,
+				"parameters":  parameters,
+				"script":      scriptPath,
+				"command":     command,
+			}
+
+			// Save updated config
+			if saveErr := SaveProxyConfig(config); saveErr != nil {
+				return fmt.Errorf("error saving config: %w", saveErr)
+			}
+
+			fmt.Printf("Registered tool: %s\n", name)
+			return nil
+		},
+	}
+
+	cmd.Flags().StringP("execute", "e", "", "Inline command to execute instead of a script file")
+	cmd.Flags().Bool("unregister", false, "Unregister a tool")
+	return cmd
+}
+
+// ProxyStartCmd creates the proxy start command.
+func ProxyStartCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "start",
+		Short: "Start a proxy server with registered tools",
+		Long: `Start a proxy server that forwards MCP tool requests to shell scripts.
+
+The server reads tool configurations from $HOME/.mcpt/proxy_config.json.
+
+Example:
+  mcp proxy start`,
+		Run: func(_ *cobra.Command, _ []string) {
+			// Load tool configurations
+			viper.SetConfigName("proxy_config")
+			viper.SetConfigType("json")
+			viper.AddConfigPath("$HOME/.mcpt")
+
+			if err := viper.ReadInConfig(); err != nil {
+				log.Fatalf("Error reading config: %v", err)
+			}
+
+			var config map[string]map[string]string
+			if err := viper.Unmarshal(&config); err != nil {
+				log.Fatalf("Error unmarshaling config: %v", err)
+			}
+
+			// Run proxy server
+			fmt.Fprintln(os.Stderr, "Starting proxy server...")
+			if err := proxy.RunProxyServer(config); err != nil {
+				log.Fatalf("Error running proxy server: %v", err)
+			}
+		},
+	}
+
+	return cmd
+}
+
+// LoadProxyConfig loads the proxy configuration from the config file.
+func LoadProxyConfig() (map[string]map[string]string, error) {
+	// Initialize config
+	viper.SetConfigName("proxy_config")
+	viper.SetConfigType("json")
+	viper.AddConfigPath("$HOME/.mcpt")
+
+	// Create config directory if it doesn't exist
+	configDir := os.ExpandEnv("$HOME/.mcpt")
+	if err := os.MkdirAll(configDir, 0o750); err != nil {
+		return nil, fmt.Errorf("error creating config directory: %w", err)
+	}
+
+	// Load existing config if it exists
+	var config map[string]map[string]string
+	var configFileNotFound viper.ConfigFileNotFoundError
+	err := viper.ReadInConfig()
+	if err != nil {
+		if errors.As(err, &configFileNotFound) {
+			// Config file not found, create a new one
+			config = make(map[string]map[string]string)
+		} else {
+			return nil, fmt.Errorf("error reading config: %w", err)
+		}
+	} else {
+		// Config file found, unmarshal it
+		config = make(map[string]map[string]string)
+		unmarshalErr := viper.Unmarshal(&config)
+		if unmarshalErr != nil {
+			return nil, fmt.Errorf("error unmarshaling config: %w", unmarshalErr)
+		}
+	}
+
+	return config, nil
+}
+
+// SaveProxyConfig saves the proxy configuration to the config file.
+func SaveProxyConfig(config map[string]map[string]string) error {
+	configPath := os.ExpandEnv("$HOME/.mcpt/proxy_config.json")
+	configJSON, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return fmt.Errorf("error marshaling config: %w", err)
+	}
+
+	writeErr := os.WriteFile(configPath, configJSON, 0o600)
+	if writeErr != nil {
+		return fmt.Errorf("error writing config: %w", writeErr)
+	}
+
+	return nil
+}
diff --git a/cmd/mcptools/commands/read_resource.go b/cmd/mcptools/commands/read_resource.go
new file mode 100644
index 0000000..d4cd2ac
--- /dev/null
+++ b/cmd/mcptools/commands/read_resource.go
@@ -0,0 +1,89 @@
+package commands
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+// ReadResourceCmd creates the read-resource command.
+func ReadResourceCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:                "read-resource resource [command args...]",
+		Short:              "Read a resource on the MCP server",
+		DisableFlagParsing: true,
+		SilenceUsage:       true,
+		Run: func(thisCmd *cobra.Command, args []string) {
+			if len(args) == 1 && (args[0] == FlagHelp || args[0] == FlagHelpShort) {
+				_ = thisCmd.Help()
+				return
+			}
+
+			if len(args) == 0 {
+				fmt.Fprintln(os.Stderr, "Error: resource name is required")
+				fmt.Fprintln(
+					os.Stderr,
+					"Example: mcp read-resource npx -y @modelcontextprotocol/server-filesystem ~",
+				)
+				os.Exit(1)
+			}
+
+			cmdArgs := args
+			parsedArgs := []string{}
+			resourceName := ""
+
+			i := 0
+			resourceExtracted := false
+
+			for i < len(cmdArgs) {
+				switch {
+				case (cmdArgs[i] == FlagFormat || cmdArgs[i] == FlagFormatShort) && i+1 < len(cmdArgs):
+					FormatOption = cmdArgs[i+1]
+					i += 2
+				case (cmdArgs[i] == FlagParams || cmdArgs[i] == FlagParamsShort) && i+1 < len(cmdArgs):
+					ParamsString = cmdArgs[i+1]
+					i += 2
+				case !resourceExtracted:
+					resourceName = cmdArgs[i]
+					resourceExtracted = true
+					i++
+				default:
+					parsedArgs = append(parsedArgs, cmdArgs[i])
+					i++
+				}
+			}
+
+			if resourceName == "" {
+				fmt.Fprintln(os.Stderr, "Error: resource name is required")
+				fmt.Fprintln(
+					os.Stderr,
+					"Example: mcp read-resource npx -y @modelcontextprotocol/server-filesystem ~",
+				)
+				os.Exit(1)
+			}
+
+			var params map[string]any
+			if len(parsedArgs) > 0 {
+				if jsonErr := json.Unmarshal([]byte(strings.Join(parsedArgs, " ")), &params); jsonErr != nil {
+					fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
+					os.Exit(1)
+				}
+			}
+
+			mcpClient, clientErr := CreateClientFunc(parsedArgs)
+			if clientErr != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
+				os.Exit(1)
+			}
+
+			resp, execErr := mcpClient.ReadResource(resourceName)
+			if formatErr := FormatAndPrintResponse(thisCmd, resp, execErr); formatErr != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
+				os.Exit(1)
+			}
+		},
+	}
+}
diff --git a/cmd/mcptools/commands/resources.go b/cmd/mcptools/commands/resources.go
new file mode 100644
index 0000000..9a79d1c
--- /dev/null
+++ b/cmd/mcptools/commands/resources.go
@@ -0,0 +1,39 @@
+package commands
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+// ResourcesCmd creates the resources command.
+func ResourcesCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:                "resources [command args...]",
+		Short:              "List available resources on the MCP server",
+		DisableFlagParsing: true,
+		SilenceUsage:       true,
+		Run: func(thisCmd *cobra.Command, args []string) {
+			if len(args) == 1 && (args[0] == FlagHelp || args[0] == FlagHelpShort) {
+				_ = thisCmd.Help()
+				return
+			}
+
+			parsedArgs := ProcessFlags(args)
+
+			mcpClient, err := CreateClientFunc(parsedArgs)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+				fmt.Fprintf(os.Stderr, "Example: mcp resources npx -y @modelcontextprotocol/server-filesystem ~\n")
+				os.Exit(1)
+			}
+
+			resp, listErr := mcpClient.ListResources()
+			if formatErr := FormatAndPrintResponse(thisCmd, resp, listErr); formatErr != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
+				os.Exit(1)
+			}
+		},
+	}
+}
diff --git a/cmd/mcptools/commands/resources_test.go b/cmd/mcptools/commands/resources_test.go
new file mode 100644
index 0000000..19f23bf
--- /dev/null
+++ b/cmd/mcptools/commands/resources_test.go
@@ -0,0 +1,64 @@
+package commands
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestResourcesCmdRun_Help(t *testing.T) {
+	// Test that the help flag displays help text
+	cmd := ResourcesCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+
+	// Execute with help flag
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+
+	// Check that help output is not empty
+	if buf.String() == "" {
+		t.Error("Expected help output, got empty string")
+	}
+}
+
+func TestResourcesCmdRun_Success(t *testing.T) {
+	t.Skip("Skipping resources command test as resources are not working as expected")
+	// Create a mock client that returns successful response
+	mockResponse := map[string]any{
+		"resources": []any{
+			map[string]any{
+				"uri":         "test-resource",
+				"type":        "text",
+				"description": "Test resource description",
+			},
+		},
+	}
+
+	cleanup := setupMockClient(func(method string, _ any) (map[string]any, error) {
+		if method != "resources/list" {
+			t.Errorf("Expected method 'resources/list', got %q", method)
+		}
+		return mockResponse, nil
+	})
+	defer cleanup()
+
+	// Set up command
+	cmd := ResourcesCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+
+	// Execute command
+	cmd.SetArgs([]string{"server", "arg"})
+	err := cmd.Execute()
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+
+	// Verify output contains expected content
+	output := buf.String()
+	assertContains(t, output, "test-resource")
+	assertContains(t, output, "Test resource description")
+}
diff --git a/cmd/mcptools/commands/root.go b/cmd/mcptools/commands/root.go
new file mode 100644
index 0000000..fd5f2f9
--- /dev/null
+++ b/cmd/mcptools/commands/root.go
@@ -0,0 +1,49 @@
+/*
+Package commands implements individual commands for the MCP CLI.
+*/
+package commands
+
+import (
+	"github.com/spf13/cobra"
+)
+
+// flags.
+const (
+	FlagFormat      = "--format"
+	FlagFormatShort = "-f"
+	FlagParams      = "--params"
+	FlagParamsShort = "-p"
+	FlagHelp        = "--help"
+	FlagHelpShort   = "-h"
+)
+
+// entity types.
+const (
+	EntityTypeTool   = "tool"
+	EntityTypePrompt = "prompt"
+	EntityTypeRes    = "resource"
+)
+
+var (
+	// FormatOption is the format option for the command, valid values are "table", "json", and
+	// "pretty".
+	FormatOption string
+	// ParamsString is the params for the command.
+	ParamsString string
+)
+
+// RootCmd creates the root command.
+func RootCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "mcp",
+		Short: "MCP is a command line interface for interacting with MCP servers",
+		Long: `MCP is a command line interface for interacting with Model Context Protocol (MCP) servers.
+It allows you to discover and call tools, list resources, and interact with MCP-compatible services.`,
+	}
+
+	cmd.PersistentFlags().StringVarP(&FormatOption, "format", "f", "table", "Output format (table, json, pretty)")
+	cmd.PersistentFlags().
+		StringVarP(&ParamsString, "params", "p", "{}", "JSON string of parameters to pass to the tool (for call command)")
+
+	return cmd
+}
diff --git a/cmd/mcptools/commands/shell.go b/cmd/mcptools/commands/shell.go
new file mode 100644
index 0000000..4822638
--- /dev/null
+++ b/cmd/mcptools/commands/shell.go
@@ -0,0 +1,347 @@
+package commands
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/f/mcptools/pkg/jsonutils"
+	"github.com/peterh/liner"
+	"github.com/spf13/cobra"
+)
+
+// ShellCmd creates the shell command.
+func ShellCmd() *cobra.Command { //nolint:gocyclo
+	return &cobra.Command{
+		Use:                "shell [command args...]",
+		Short:              "Start an interactive shell for MCP commands",
+		DisableFlagParsing: true,
+		SilenceUsage:       true,
+		Run: func(thisCmd *cobra.Command, args []string) {
+			if len(args) == 1 && (args[0] == FlagHelp || args[0] == FlagHelpShort) {
+				_ = thisCmd.Help()
+				return
+			}
+
+			cmdArgs := args
+			parsedArgs := []string{}
+
+			i := 0
+			for i < len(cmdArgs) {
+				switch {
+				case (cmdArgs[i] == FlagFormat || cmdArgs[i] == FlagFormatShort) && i+1 < len(cmdArgs):
+					FormatOption = cmdArgs[i+1]
+					i += 2
+				default:
+					parsedArgs = append(parsedArgs, cmdArgs[i])
+					i++
+				}
+			}
+
+			if len(parsedArgs) == 0 {
+				fmt.Fprintln(os.Stderr, "Error: command to execute is required when using the shell")
+				fmt.Fprintln(os.Stderr, "Example: mcp shell npx -y @modelcontextprotocol/server-filesystem ~")
+				os.Exit(1)
+			}
+
+			mcpClient, clientErr := CreateClientFunc(parsedArgs)
+			if clientErr != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
+				os.Exit(1)
+			}
+
+			_, listErr := mcpClient.ListTools()
+			if listErr != nil {
+				fmt.Fprintf(os.Stderr, "Error connecting to MCP server: %v\n", listErr)
+				os.Exit(1)
+			}
+
+			fmt.Printf("mcp > MCP Tools Shell (%s)\n", Version)
+			fmt.Println("mcp > Connected to Server:", strings.Join(parsedArgs, " "))
+			fmt.Println("\nmcp > Type '/h' for help or '/q' to quit")
+
+			line := liner.NewLiner()
+			defer func() { _ = line.Close() }()
+
+			historyFile := filepath.Join(os.Getenv("HOME"), ".mcp_history")
+			if f, err := os.Open(filepath.Clean(historyFile)); err == nil {
+				_, _ = line.ReadHistory(f)
+				_ = f.Close()
+			}
+
+			defer func() {
+				if f, err := os.Create(historyFile); err == nil {
+					_, _ = line.WriteHistory(f)
+					_ = f.Close()
+				}
+			}()
+
+			line.SetCompleter(func(line string) (c []string) {
+				commands := []string{
+					"tools",
+					"resources",
+					"prompts",
+					"call",
+					"format",
+					"help",
+					"exit",
+					"/h",
+					"/q",
+					"/help",
+					"/quit",
+				}
+				for _, cmd := range commands {
+					if strings.HasPrefix(cmd, line) {
+						c = append(c, cmd)
+					}
+				}
+				return
+			})
+
+			for {
+				input, err := line.Prompt("mcp > ")
+				if err != nil {
+					if errors.Is(err, liner.ErrPromptAborted) {
+						fmt.Println("Exiting MCP shell")
+						break
+					}
+					fmt.Fprintf(os.Stderr, "Error reading input: %v\n", err)
+					break
+				}
+
+				if input == "" {
+					continue
+				}
+
+				line.AppendHistory(input)
+
+				if input == "/q" || input == "/quit" || input == "exit" {
+					fmt.Println("Exiting MCP shell")
+					break
+				}
+
+				if input == "/h" || input == "/help" || input == "help" {
+					printShellHelp()
+					continue
+				}
+
+				parts := strings.Fields(input)
+				if len(parts) == 0 {
+					continue
+				}
+
+				command := parts[0]
+				commandArgs := parts[1:]
+
+				var resp map[string]any
+				var respErr error
+
+				switch command {
+				case "tools":
+					resp, respErr = mcpClient.ListTools()
+					if respErr != nil {
+						fmt.Fprintf(os.Stderr, "Error: %v\n", respErr)
+
+						continue
+					}
+
+					output, formatErr := jsonutils.Format(resp, FormatOption)
+					if formatErr != nil {
+						fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", formatErr)
+
+						continue
+					}
+
+					fmt.Println(output)
+
+				case "resources":
+					resp, respErr = mcpClient.ListResources()
+					if respErr != nil {
+						fmt.Fprintf(os.Stderr, "Error: %v\n", respErr)
+
+						continue
+					}
+
+					output, formatErr := jsonutils.Format(resp, FormatOption)
+					if formatErr != nil {
+						fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", formatErr)
+
+						continue
+					}
+
+					fmt.Println(output)
+
+				case "prompts":
+					resp, respErr = mcpClient.ListPrompts()
+					if respErr != nil {
+						fmt.Fprintf(os.Stderr, "Error: %v\n", respErr)
+
+						continue
+					}
+
+					output, formatErr := jsonutils.Format(resp, FormatOption)
+					if formatErr != nil {
+						fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", formatErr)
+
+						continue
+					}
+
+					fmt.Println(output)
+
+				case "call":
+					if len(commandArgs) < 1 {
+						fmt.Println("Usage: call <entity> [--params '{...}']")
+
+						continue
+					}
+
+					entityName := commandArgs[0]
+					entityType := EntityTypeTool
+
+					parts = strings.SplitN(entityName, ":", 2)
+					if len(parts) == 2 {
+						entityType = parts[0]
+						entityName = parts[1]
+					}
+
+					params := map[string]any{}
+					for ii := 1; ii < len(commandArgs); ii++ {
+						if commandArgs[ii] == FlagParams || commandArgs[ii] == FlagParamsShort {
+							if ii+1 < len(commandArgs) {
+								if jsonErr := json.Unmarshal([]byte(commandArgs[ii+1]), &params); jsonErr != nil {
+									fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
+
+									continue
+								}
+								break
+							}
+						}
+					}
+
+					var execErr error
+
+					switch entityType {
+					case EntityTypeTool:
+						resp, execErr = mcpClient.CallTool(entityName, params)
+					case EntityTypeRes:
+						resp, execErr = mcpClient.ReadResource(entityName)
+					case EntityTypePrompt:
+						resp, execErr = mcpClient.GetPrompt(entityName)
+					default:
+						fmt.Fprintf(os.Stderr, "Error: unsupported entity type: %s\n", entityType)
+						continue
+					}
+
+					if execErr != nil {
+						fmt.Fprintf(os.Stderr, "Error: %v\n", execErr)
+						continue
+					}
+
+					output, formatErr := jsonutils.Format(resp, FormatOption)
+					if formatErr != nil {
+						fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", formatErr)
+						continue
+					}
+
+					fmt.Println(output)
+
+				case "format":
+					if len(commandArgs) < 1 {
+						fmt.Printf("Current format: %s\n", FormatOption)
+						continue
+					}
+
+					newFormat := commandArgs[0]
+					if newFormat == "json" || newFormat == "j" ||
+						newFormat == "pretty" || newFormat == "p" ||
+						newFormat == "table" || newFormat == "t" {
+						FormatOption = newFormat
+						fmt.Printf("Format set to: %s\n", FormatOption)
+					} else {
+						fmt.Println("Invalid format. Use: table, json, or pretty")
+					}
+
+				default:
+					entityName := command
+					entityType := EntityTypeTool
+
+					parts = strings.SplitN(entityName, ":", 2)
+					if len(parts) == 2 {
+						entityType = parts[0]
+						entityName = parts[1]
+					}
+
+					params := map[string]any{}
+
+					if len(commandArgs) > 0 {
+						firstArg := commandArgs[0]
+						if strings.HasPrefix(firstArg, "{") && strings.HasSuffix(firstArg, "}") {
+							if jsonErr := json.Unmarshal([]byte(firstArg), &params); jsonErr != nil {
+								fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
+								continue
+							}
+						} else {
+							for iii := 0; iii < len(commandArgs); iii++ {
+								if commandArgs[iii] == FlagParams || commandArgs[iii] == FlagParamsShort {
+									if iii+1 < len(commandArgs) {
+										if jsonErr := json.Unmarshal([]byte(commandArgs[iii+1]), &params); jsonErr != nil {
+											fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
+											continue
+										}
+										break
+									}
+								}
+							}
+						}
+					}
+
+					var execErr error
+
+					switch entityType {
+					case EntityTypeTool:
+						resp, execErr = mcpClient.CallTool(entityName, params)
+					case EntityTypeRes:
+						resp, execErr = mcpClient.ReadResource(entityName)
+					case EntityTypePrompt:
+						resp, execErr = mcpClient.GetPrompt(entityName)
+					default:
+						fmt.Printf("Unknown command: %s\nType '/h' for help\n", command)
+						continue
+					}
+
+					if execErr != nil {
+						fmt.Fprintf(os.Stderr, "Error: %v\n", execErr)
+						continue
+					}
+
+					output, formatErr := jsonutils.Format(resp, FormatOption)
+					if formatErr != nil {
+						fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", formatErr)
+						continue
+					}
+
+					fmt.Println(output)
+				}
+			}
+		},
+	}
+}
+
+func printShellHelp() {
+	fmt.Println("MCP Shell Commands:")
+	fmt.Println("  tools                      List available tools")
+	fmt.Println("  resources                  List available resources")
+	fmt.Println("  prompts                    List available prompts")
+	fmt.Println("  call <entity> [--params '{...}']  Call a tool, resource, or prompt")
+	fmt.Println("  format [json|pretty|table] Get or set output format")
+	fmt.Println("Direct Tool Calling:")
+	fmt.Println("  <tool_name> {\"param\": \"value\"}  Call a tool directly with JSON parameters")
+	fmt.Println("  resource:<name>            Read a resource directly")
+	fmt.Println("  prompt:<name>              Get a prompt directly")
+	fmt.Println("Special Commands:")
+	fmt.Println("  /h, /help                  Show this help")
+	fmt.Println("  /q, /quit, exit            Exit the shell")
+}
diff --git a/cmd/mcptools/commands/test_helpers.go b/cmd/mcptools/commands/test_helpers.go
new file mode 100644
index 0000000..51e436f
--- /dev/null
+++ b/cmd/mcptools/commands/test_helpers.go
@@ -0,0 +1,57 @@
+// Package commands implements individual commands for the MCP CLI.
+package commands
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/f/mcptools/pkg/client"
+)
+
+// MockTransport implements the transport.Transport interface for testing.
+type MockTransport struct {
+	ExecuteFunc func(method string, params any) (map[string]any, error)
+}
+
+// Execute calls the mock implementation.
+func (m *MockTransport) Execute(method string, params any) (map[string]any, error) {
+	return m.ExecuteFunc(method, params)
+}
+
+// setupMockClient creates a mock client with the given execute function and returns cleanup function.
+func setupMockClient(executeFunc func(method string, params any) (map[string]any, error)) func() {
+	// Save original function and restore later
+	originalFunc := CreateClientFunc
+
+	mockTransport := &MockTransport{
+		ExecuteFunc: executeFunc,
+	}
+
+	mockClient := client.NewWithTransport(mockTransport)
+
+	// Override the function that creates clients
+	CreateClientFunc = func(_ []string) (*client.Client, error) {
+		return mockClient, nil
+	}
+
+	// Return a cleanup function
+	return func() {
+		CreateClientFunc = originalFunc
+	}
+}
+
+// assertContains checks if the output contains the expected string.
+func assertContains(t *testing.T, output string, expected string) {
+	t.Helper()
+	if !bytes.Contains([]byte(output), []byte(expected)) {
+		t.Errorf("Expected output to contain %q, got: %s", expected, output)
+	}
+}
+
+// assertEqual checks if two values are equal.
+func assertEquals(t *testing.T, output string, expected string) {
+	t.Helper()
+	if output != expected {
+		t.Errorf("Expected %v, got %v", expected, output)
+	}
+}
diff --git a/cmd/mcptools/commands/tools.go b/cmd/mcptools/commands/tools.go
new file mode 100644
index 0000000..321992e
--- /dev/null
+++ b/cmd/mcptools/commands/tools.go
@@ -0,0 +1,39 @@
+package commands
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+// ToolsCmd creates the tools command.
+func ToolsCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:                "tools [command args...]",
+		Short:              "List available tools on the MCP server",
+		DisableFlagParsing: true,
+		SilenceUsage:       true,
+		Run: func(thisCmd *cobra.Command, args []string) {
+			if len(args) == 1 && (args[0] == FlagHelp || args[0] == FlagHelpShort) {
+				_ = thisCmd.Help()
+				return
+			}
+
+			parsedArgs := ProcessFlags(args)
+
+			mcpClient, err := CreateClientFunc(parsedArgs)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+				fmt.Fprintf(os.Stderr, "Example: mcp tools npx -y @modelcontextprotocol/server-filesystem ~\n")
+				os.Exit(1)
+			}
+
+			resp, listErr := mcpClient.ListTools()
+			if formatErr := FormatAndPrintResponse(thisCmd, resp, listErr); formatErr != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
+				os.Exit(1)
+			}
+		},
+	}
+}
diff --git a/cmd/mcptools/commands/tools_test.go b/cmd/mcptools/commands/tools_test.go
new file mode 100644
index 0000000..679143a
--- /dev/null
+++ b/cmd/mcptools/commands/tools_test.go
@@ -0,0 +1,62 @@
+package commands
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestToolsCmdRun_Help(t *testing.T) {
+	// Test that the help flag displays help text
+	cmd := ToolsCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+
+	// Execute with help flag
+	cmd.SetArgs([]string{"--help"})
+	err := cmd.Execute()
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+
+	// Check that help output is not empty
+	if buf.String() == "" {
+		t.Error("Expected help output, got empty string")
+	}
+}
+
+func TestToolsCmdRun(t *testing.T) {
+	// Save original format option
+	origFormatOption := FormatOption
+	defer func() { FormatOption = origFormatOption }()
+
+	// Create a mock client that returns successful response
+	mockResponse := map[string]any{
+		"tools": []any{
+			map[string]any{
+				"name":        "test-tool",
+				"description": "A test tool",
+			},
+		},
+	}
+
+	cleanup := setupMockClient(func(method string, _ any) (map[string]any, error) {
+		if method != "tools/list" {
+			t.Errorf("Expected method 'tools/list', got %q", method)
+		}
+		return mockResponse, nil
+	})
+	defer cleanup()
+
+	// Set up command
+	cmd := ToolsCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+	cmd.SetArgs([]string{"server", "args"})
+	err := cmd.Execute()
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+	output := buf.String()
+	assertContains(t, output, "test-tool")
+	assertContains(t, output, "A test tool")
+}
diff --git a/cmd/mcptools/commands/utils.go b/cmd/mcptools/commands/utils.go
new file mode 100644
index 0000000..31bc537
--- /dev/null
+++ b/cmd/mcptools/commands/utils.go
@@ -0,0 +1,86 @@
+package commands
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/f/mcptools/pkg/alias"
+	"github.com/f/mcptools/pkg/client"
+	"github.com/f/mcptools/pkg/jsonutils"
+	"github.com/spf13/cobra"
+)
+
+// sentinel errors.
+var (
+	ErrCommandRequired = fmt.Errorf("command to execute is required when using stdio transport")
+)
+
+// CreateClientFunc is the function used to create MCP clients.
+// This can be replaced in tests to use a mock transport.
+var CreateClientFunc = func(args []string) (*client.Client, error) {
+	if len(args) == 0 {
+		return nil, ErrCommandRequired
+	}
+
+	isHTTP := func(str string) bool {
+		return strings.HasPrefix(str, "http://") || strings.HasPrefix(str, "https://")
+	}
+
+	// Check if the first argument is an alias
+	if len(args) == 1 {
+		server, found := alias.GetServerCommand(args[0])
+		if found {
+			if isHTTP(server) {
+				return client.NewHTTP(server), nil
+			}
+			cmdParts := client.ParseCommandString(server)
+			return client.NewStdio(cmdParts), nil
+		}
+	}
+
+	if len(args) == 1 && isHTTP(args[0]) {
+		return client.NewHTTP(args[0]), nil
+	}
+
+	return client.NewStdio(args), nil
+}
+
+// ProcessFlags processes command line flags, sets the format option, and returns the remaining
+// arguments. Supported format options: json, pretty, and table.
+//
+// For example, if the input arguments are ["tools", "--format", "pretty", "npx", "-y",
+// "@modelcontextprotocol/server-filesystem", "~"], it would return ["npx", "-y",
+// "@modelcontextprotocol/server-filesystem", "~"] and set the format option to "pretty".
+func ProcessFlags(args []string) []string {
+	parsedArgs := []string{}
+
+	i := 0
+	for i < len(args) {
+		switch {
+		case (args[i] == FlagFormat || args[i] == FlagFormatShort) && i+1 < len(args):
+			FormatOption = args[i+1]
+			i += 2
+		default:
+			parsedArgs = append(parsedArgs, args[i])
+			i++
+		}
+	}
+
+	return parsedArgs
+}
+
+// FormatAndPrintResponse formats and prints an MCP response in the format specified by
+// FormatOption.
+func FormatAndPrintResponse(cmd *cobra.Command, resp map[string]any, err error) error {
+	if err != nil {
+		return fmt.Errorf("error: %w", err)
+	}
+
+	output, err := jsonutils.Format(resp, FormatOption)
+	if err != nil {
+		return fmt.Errorf("error formatting output: %w", err)
+	}
+
+	fmt.Fprintln(cmd.OutOrStdout(), output)
+	return nil
+}
diff --git a/cmd/mcptools/commands/utils_test.go b/cmd/mcptools/commands/utils_test.go
new file mode 100644
index 0000000..d91486e
--- /dev/null
+++ b/cmd/mcptools/commands/utils_test.go
@@ -0,0 +1,178 @@
+package commands
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+func TestProcessFlags(t *testing.T) {
+	// Save original value to restore later
+	originalFormat := FormatOption
+	defer func() { FormatOption = originalFormat }()
+
+	// Fix fieldalignment with //nolint directive
+	tests := []struct { //nolint:govet
+		name       string
+		args       []string
+		wantArgs   []string
+		wantFormat string
+	}{
+		{
+			name:       "no flags",
+			args:       []string{"cmd", "arg1", "arg2"},
+			wantArgs:   []string{"cmd", "arg1", "arg2"},
+			wantFormat: "",
+		},
+		{
+			name:       "with long format flag",
+			args:       []string{"cmd", "--format", "json", "arg1"},
+			wantArgs:   []string{"cmd", "arg1"},
+			wantFormat: "json",
+		},
+		{
+			name:       "with short format flag",
+			args:       []string{"cmd", "-f", "pretty", "arg1"},
+			wantArgs:   []string{"cmd", "arg1"},
+			wantFormat: "pretty",
+		},
+		{
+			name:       "with format flag at end",
+			args:       []string{"cmd", "arg1", "--format", "table"},
+			wantArgs:   []string{"cmd", "arg1"},
+			wantFormat: "table",
+		},
+		{
+			name:       "with invalid format option",
+			args:       []string{"cmd", "--format", "invalid", "arg1"},
+			wantArgs:   []string{"cmd", "arg1"},
+			wantFormat: "invalid",
+		},
+		{
+			name:       "with format flag without value",
+			args:       []string{"cmd", "--format", "json"},
+			wantArgs:   []string{"cmd"},
+			wantFormat: "json",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Reset FormatOption for each test
+			FormatOption = ""
+
+			gotArgs := ProcessFlags(tt.args)
+
+			if !reflect.DeepEqual(gotArgs, tt.wantArgs) {
+				t.Errorf("ProcessFlags() gotArgs = %v, want %v", gotArgs, tt.wantArgs)
+			}
+
+			if FormatOption != tt.wantFormat {
+				t.Errorf("ProcessFlags() FormatOption = %v, want %v", FormatOption, tt.wantFormat)
+			}
+		})
+	}
+}
+
+func TestFormatAndPrintResponse(t *testing.T) {
+	// Save original value to restore later
+	originalFormat := FormatOption
+	defer func() { FormatOption = originalFormat }()
+
+	// Setup test data
+	testResp := map[string]any{
+		"name": "test",
+		"age":  30,
+		"nested": map[string]any{
+			"key": "value",
+		},
+	}
+	respJSON := `{"age":30,"name":"test","nested":{"key":"value"}}`
+	respPretty := `
+{
+  "age": 30,
+  "name": "test",
+  "nested": {
+    "key": "value"
+  }
+}`[1:] // remove first newline
+	respTable := `
+KEY     VALUE
+---     -----
+age     30
+name    test
+nested  {"key":"value"}`[1:] // remove first newline
+
+	// Fix fieldalignment with //nolint directive
+	tests := []struct { //nolint:govet
+		name      string
+		resp      map[string]any
+		err       error
+		formatOpt string
+		wantErr   bool
+		expected  string
+	}{
+		{
+			name:      "json format",
+			resp:      testResp,
+			err:       nil,
+			formatOpt: "json",
+			wantErr:   false,
+			expected:  respJSON,
+		},
+		{
+			name:      "pretty format",
+			resp:      testResp,
+			err:       nil,
+			formatOpt: "pretty",
+			wantErr:   false,
+			expected:  respPretty,
+		},
+		{
+			name:      "table format",
+			resp:      testResp,
+			err:       nil,
+			formatOpt: "table",
+			wantErr:   false,
+			expected:  respTable,
+		},
+		{
+			name:      "with error",
+			resp:      nil,
+			err:       fmt.Errorf("test error"),
+			formatOpt: "json",
+			wantErr:   true,
+			expected:  "error: test error\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a cobra command with a buffer
+			buf := new(bytes.Buffer)
+			cmd := &cobra.Command{}
+			cmd.SetOut(buf)
+
+			// Set format option
+			FormatOption = tt.formatOpt
+
+			err := FormatAndPrintResponse(cmd, tt.resp, tt.err)
+
+			// Read the captured output
+			output := buf.String()
+
+			if (err != nil) != tt.wantErr {
+				t.Errorf("FormatAndPrintResponse() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if !tt.wantErr {
+				assertEquals(t, strings.TrimSpace(output), tt.expected)
+			}
+		})
+	}
+}
diff --git a/cmd/mcptools/commands/version.go b/cmd/mcptools/commands/version.go
new file mode 100644
index 0000000..cb1505e
--- /dev/null
+++ b/cmd/mcptools/commands/version.go
@@ -0,0 +1,21 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+// Version information placeholder.
+var Version = "dev"
+
+// VersionCmd creates the version command.
+func VersionCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "version",
+		Short: "Print the version information",
+		Run: func(cmd *cobra.Command, _ []string) {
+			fmt.Fprintf(cmd.OutOrStdout(), "MCP Tools version %s\n", Version)
+		},
+	}
+}
diff --git a/cmd/mcptools/commands/version_test.go b/cmd/mcptools/commands/version_test.go
new file mode 100644
index 0000000..6888b6e
--- /dev/null
+++ b/cmd/mcptools/commands/version_test.go
@@ -0,0 +1,52 @@
+package commands
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestVersionCmd(t *testing.T) {
+	buf := new(bytes.Buffer)
+
+	oldVersion := Version
+	Version = "test-version"
+	defer func() { Version = oldVersion }()
+
+	// Execute the version command with our buffer
+	cmd := VersionCmd()
+	cmd.SetOut(buf)
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("Failed to execute version command: %v", err)
+	}
+
+	// Read captured output
+	output := buf.String()
+
+	// Check that the version is in the output
+	expectedOutput := "MCP Tools version test-version\n"
+	if output != expectedOutput {
+		t.Errorf("Expected output %q, got %q", expectedOutput, output)
+	}
+}
+
+func TestVersionCmdWorks(t *testing.T) {
+	// Test that the version command can be created and executed
+	cmd := VersionCmd()
+	if cmd == nil {
+		t.Fatal("Expected version command to be created")
+	}
+
+	// Verify the command properties
+	if cmd.Use != "version" {
+		t.Errorf("Expected Use to be 'version', got %q", cmd.Use)
+	}
+
+	if cmd.Short != "Print the version information" {
+		t.Errorf("Expected Short to be 'Print the version information', got %q", cmd.Short)
+	}
+
+	// Ensure Run function is not nil
+	if cmd.Run == nil {
+		t.Error("Expected Run function to be defined")
+	}
+}
diff --git a/cmd/mcptools/main.go b/cmd/mcptools/main.go
index f2f0c23..33669ca 100644
--- a/cmd/mcptools/main.go
+++ b/cmd/mcptools/main.go
@@ -4,22 +4,10 @@ Package main implements mcp functionality.
 package main
 
 import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log"
 	"os"
-	"path/filepath"
-	"strings"
 
-	"github.com/f/mcptools/pkg/alias"
-	"github.com/f/mcptools/pkg/client"
-	"github.com/f/mcptools/pkg/jsonutils"
-	"github.com/f/mcptools/pkg/mock"
-	"github.com/f/mcptools/pkg/proxy"
-	"github.com/peterh/liner"
+	"github.com/f/mcptools/cmd/mcptools/commands"
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 )
 
 // version information placeholders.
@@ -27,1294 +15,30 @@ var (
 	Version = "dev"
 )
 
-// flags.
-const (
-	flagFormat       = "--format"
-	flagFormatShort  = "-f"
-	flagParams       = "--params"
-	flagParamsShort  = "-p"
-	flagHelp         = "--help"
-	flagHelpShort    = "-h"
-	entityTypeTool   = "tool"
-	entityTypePrompt = "prompt"
-	entityTypeRes    = "resource"
-)
-
-var (
-	formatOption string
-	paramsString string
-)
-
-// sentinel errors.
-var (
-	errCommandRequired = fmt.Errorf("command to execute is required when using stdio transport")
-)
-
-// createClientFunc is the function used to create MCP clients.
-// This can be replaced in tests to use a mock transport.
-var createClientFunc = func(args []string) (*client.Client, error) {
-	if len(args) == 0 {
-		return nil, errCommandRequired
-	}
-
-	isHTTP := func(str string) bool {
-		return strings.HasPrefix(str, "http://") || strings.HasPrefix(str, "https://")
-	}
-
-	// Check if the first argument is an alias
-	if len(args) == 1 {
-		server, found := alias.GetServerCommand(args[0])
-		if found {
-			if isHTTP(server) {
-				return client.NewHTTP(server), nil
-			}
-			cmdParts := client.ParseCommandString(server)
-			return client.NewStdio(cmdParts), nil
-		}
-	}
-
-	if len(args) == 1 && isHTTP(args[0]) {
-		return client.NewHTTP(args[0]), nil
-	}
-
-	return client.NewStdio(args), nil
+func init() {
+	commands.Version = Version
 }
 
 func main() {
 	cobra.EnableCommandSorting = false
 
-	rootCmd := newRootCmd()
+	rootCmd := commands.RootCmd()
 	rootCmd.AddCommand(
-		newVersionCmd(),
-		newToolsCmd(),
-		newResourcesCmd(),
-		newPromptsCmd(),
-		newCallCmd(),
-		newGetPromptCmd(),
-		newReadResourceCmd(),
-		newShellCmd(),
-		newMockCmd(),
-		proxyCmd(),
-		aliasCmd(),
-		newNewCmd(),
+		commands.VersionCmd(),
+		commands.ToolsCmd(),
+		commands.ResourcesCmd(),
+		commands.PromptsCmd(),
+		commands.CallCmd(),
+		commands.GetPromptCmd(),
+		commands.ReadResourceCmd(),
+		commands.ShellCmd(),
+		commands.MockCmd(),
+		commands.ProxyCmd(),
+		commands.AliasCmd(),
+		commands.NewCmd(),
 	)
 
 	if err := rootCmd.Execute(); err != nil {
 		os.Exit(1)
 	}
 }
-
-func newRootCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "mcp",
-		Short: "MCP is a command line interface for interacting with MCP servers",
-		Long: `MCP is a command line interface for interacting with Model Context Protocol (MCP) servers.
-It allows you to discover and call tools, list resources, and interact with MCP-compatible services.`,
-	}
-
-	cmd.PersistentFlags().StringVarP(&formatOption, "format", "f", "table", "Output format (table, json, pretty)")
-	cmd.PersistentFlags().
-		StringVarP(&paramsString, "params", "p", "{}", "JSON string of parameters to pass to the tool (for call command)")
-
-	return cmd
-}
-
-func newVersionCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "version",
-		Short: "Print the version information",
-		Run: func(_ *cobra.Command, _ []string) {
-			fmt.Printf("MCP Tools version %s\n", Version)
-		},
-	}
-}
-
-func processFlags(args []string) []string {
-	parsedArgs := []string{}
-
-	i := 0
-	for i < len(args) {
-		switch {
-		case (args[i] == flagFormat || args[i] == flagFormatShort) && i+1 < len(args):
-			formatOption = args[i+1]
-			i += 2
-		default:
-			parsedArgs = append(parsedArgs, args[i])
-			i++
-		}
-	}
-
-	return parsedArgs
-}
-
-func formatAndPrintResponse(resp map[string]any, err error) error {
-	if err != nil {
-		return fmt.Errorf("error: %w", err)
-	}
-
-	output, err := jsonutils.Format(resp, formatOption)
-	if err != nil {
-		return fmt.Errorf("error formatting output: %w", err)
-	}
-
-	fmt.Println(output)
-	return nil
-}
-
-func newToolsCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:                "tools [command args...]",
-		Short:              "List available tools on the MCP server",
-		DisableFlagParsing: true,
-		SilenceUsage:       true,
-		Run: func(thisCmd *cobra.Command, args []string) {
-			if len(args) == 1 && (args[0] == flagHelp || args[0] == flagHelpShort) {
-				_ = thisCmd.Help()
-				return
-			}
-
-			parsedArgs := processFlags(args)
-
-			mcpClient, err := createClientFunc(parsedArgs)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-				fmt.Fprintf(os.Stderr, "Example: mcp tools npx -y @modelcontextprotocol/server-filesystem ~\n")
-				os.Exit(1)
-			}
-
-			resp, listErr := mcpClient.ListTools()
-			if formatErr := formatAndPrintResponse(resp, listErr); formatErr != nil {
-				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
-				os.Exit(1)
-			}
-		},
-	}
-}
-
-func newResourcesCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:                "resources [command args...]",
-		Short:              "List available resources on the MCP server",
-		DisableFlagParsing: true,
-		SilenceUsage:       true,
-		Run: func(thisCmd *cobra.Command, args []string) {
-			if len(args) == 1 && (args[0] == flagHelp || args[0] == flagHelpShort) {
-				_ = thisCmd.Help()
-				return
-			}
-
-			parsedArgs := processFlags(args)
-
-			mcpClient, err := createClientFunc(parsedArgs)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-				fmt.Fprintf(os.Stderr, "Example: mcp resources npx -y @modelcontextprotocol/server-filesystem ~\n")
-				os.Exit(1)
-			}
-
-			resp, listErr := mcpClient.ListResources()
-			if formatErr := formatAndPrintResponse(resp, listErr); formatErr != nil {
-				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
-				os.Exit(1)
-			}
-		},
-	}
-}
-
-func newPromptsCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:                "prompts [command args...]",
-		Short:              "List available prompts on the MCP server",
-		DisableFlagParsing: true,
-		SilenceUsage:       true,
-		Run: func(thisCmd *cobra.Command, args []string) {
-			if len(args) == 1 && (args[0] == flagHelp || args[0] == flagHelpShort) {
-				_ = thisCmd.Help()
-				return
-			}
-
-			parsedArgs := processFlags(args)
-
-			mcpClient, err := createClientFunc(parsedArgs)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-				fmt.Fprintf(os.Stderr, "Example: mcp prompts npx -y @modelcontextprotocol/server-filesystem ~\n")
-				os.Exit(1)
-			}
-
-			resp, listErr := mcpClient.ListPrompts()
-			if formatErr := formatAndPrintResponse(resp, listErr); formatErr != nil {
-				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
-				os.Exit(1)
-			}
-		},
-	}
-}
-
-func newCallCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:                "call entity [command args...]",
-		Short:              "Call a tool, resource, or prompt on the MCP server",
-		DisableFlagParsing: true,
-		SilenceUsage:       true,
-		Run: func(thisCmd *cobra.Command, args []string) {
-			if len(args) == 1 && (args[0] == flagHelp || args[0] == flagHelpShort) {
-				_ = thisCmd.Help()
-				return
-			}
-
-			if len(args) == 0 {
-				fmt.Fprintln(os.Stderr, "Error: entity name is required")
-				fmt.Fprintln(
-					os.Stderr,
-					"Example: mcp call read_file npx -y @modelcontextprotocol/server-filesystem ~",
-				)
-				os.Exit(1)
-			}
-
-			cmdArgs := args
-			parsedArgs := []string{}
-			entityName := ""
-
-			i := 0
-			entityExtracted := false
-
-			for i < len(cmdArgs) {
-				switch {
-				case (cmdArgs[i] == flagFormat || cmdArgs[i] == flagFormatShort) && i+1 < len(cmdArgs):
-					formatOption = cmdArgs[i+1]
-					i += 2
-				case (cmdArgs[i] == flagParams || cmdArgs[i] == flagParamsShort) && i+1 < len(cmdArgs):
-					paramsString = cmdArgs[i+1]
-					i += 2
-				case !entityExtracted:
-					entityName = cmdArgs[i]
-					entityExtracted = true
-					i++
-				default:
-					parsedArgs = append(parsedArgs, cmdArgs[i])
-					i++
-				}
-			}
-
-			if entityName == "" {
-				fmt.Fprintln(os.Stderr, "Error: entity name is required")
-				fmt.Fprintln(
-					os.Stderr,
-					"Example: mcp call read_file npx -y @modelcontextprotocol/server-filesystem ~",
-				)
-				os.Exit(1)
-			}
-
-			entityType := entityTypeTool
-
-			parts := strings.SplitN(entityName, ":", 2)
-			if len(parts) == 2 {
-				entityType = parts[0]
-				entityName = parts[1]
-			}
-
-			if len(parsedArgs) == 0 {
-				fmt.Fprintln(os.Stderr, "Error: command to execute is required when using stdio transport")
-				fmt.Fprintln(
-					os.Stderr,
-					"Example: mcp call read_file npx -y @modelcontextprotocol/server-filesystem ~",
-				)
-				os.Exit(1)
-			}
-
-			var params map[string]any
-			if paramsString != "" {
-				if jsonErr := json.Unmarshal([]byte(paramsString), &params); jsonErr != nil {
-					fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
-					os.Exit(1)
-				}
-			}
-
-			mcpClient, clientErr := createClientFunc(parsedArgs)
-			if clientErr != nil {
-				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
-				os.Exit(1)
-			}
-
-			var resp map[string]any
-			var execErr error
-
-			switch entityType {
-			case entityTypeTool:
-				resp, execErr = mcpClient.CallTool(entityName, params)
-			case entityTypeRes:
-				resp, execErr = mcpClient.ReadResource(entityName)
-			case entityTypePrompt:
-				resp, execErr = mcpClient.GetPrompt(entityName)
-			default:
-				fmt.Fprintf(os.Stderr, "Error: unsupported entity type: %s\n", entityType)
-				os.Exit(1)
-			}
-
-			if formatErr := formatAndPrintResponse(resp, execErr); formatErr != nil {
-				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
-				os.Exit(1)
-			}
-		},
-	}
-}
-
-func newGetPromptCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:                "get-prompt prompt [command args...]",
-		Short:              "Get a prompt on the MCP server",
-		DisableFlagParsing: true,
-		SilenceUsage:       true,
-		Run: func(thisCmd *cobra.Command, args []string) {
-			if len(args) == 1 && (args[0] == flagHelp || args[0] == flagHelpShort) {
-				_ = thisCmd.Help()
-				return
-			}
-
-			if len(args) == 0 {
-				fmt.Fprintln(os.Stderr, "Error: prompt name is required")
-				fmt.Fprintln(
-					os.Stderr,
-					"Example: mcp get-prompt read_file npx -y @modelcontextprotocol/server-filesystem ~",
-				)
-				os.Exit(1)
-			}
-
-			cmdArgs := args
-			parsedArgs := []string{}
-			promptName := ""
-
-			i := 0
-			promptExtracted := false
-
-			for i < len(cmdArgs) {
-				switch {
-				case (cmdArgs[i] == flagFormat || cmdArgs[i] == flagFormatShort) && i+1 < len(cmdArgs):
-					formatOption = cmdArgs[i+1]
-					i += 2
-				case (cmdArgs[i] == flagParams || cmdArgs[i] == flagParamsShort) && i+1 < len(cmdArgs):
-					paramsString = cmdArgs[i+1]
-					i += 2
-				case !promptExtracted:
-					promptName = cmdArgs[i]
-					promptExtracted = true
-					i++
-				default:
-					parsedArgs = append(parsedArgs, cmdArgs[i])
-					i++
-				}
-			}
-
-			if promptName == "" {
-				fmt.Fprintln(os.Stderr, "Error: prompt name is required")
-				fmt.Fprintln(
-					os.Stderr,
-					"Example: mcp get-prompt read_file npx -y @modelcontextprotocol/server-filesystem ~",
-				)
-				os.Exit(1)
-			}
-
-			var params map[string]any
-			if paramsString != "" {
-				if jsonErr := json.Unmarshal([]byte(paramsString), &params); jsonErr != nil {
-					fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
-					os.Exit(1)
-				}
-			}
-
-			mcpClient, clientErr := createClientFunc(parsedArgs)
-			if clientErr != nil {
-				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
-				os.Exit(1)
-			}
-
-			resp, execErr := mcpClient.GetPrompt(promptName)
-			if formatErr := formatAndPrintResponse(resp, execErr); formatErr != nil {
-				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
-				os.Exit(1)
-			}
-		},
-	}
-}
-
-func newReadResourceCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:                "read-resource resource [command args...]",
-		Short:              "Read a resource on the MCP server",
-		DisableFlagParsing: true,
-		SilenceUsage:       true,
-		Run: func(thisCmd *cobra.Command, args []string) {
-			if len(args) == 1 && (args[0] == flagHelp || args[0] == flagHelpShort) {
-				_ = thisCmd.Help()
-				return
-			}
-
-			if len(args) == 0 {
-				fmt.Fprintln(os.Stderr, "Error: resource name is required")
-				fmt.Fprintln(
-					os.Stderr,
-					"Example: mcp read-resource npx -y @modelcontextprotocol/server-filesystem ~",
-				)
-				os.Exit(1)
-			}
-
-			cmdArgs := args
-			parsedArgs := []string{}
-			resourceName := ""
-
-			i := 0
-			resourceExtracted := false
-
-			for i < len(cmdArgs) {
-				switch {
-				case (cmdArgs[i] == flagFormat || cmdArgs[i] == flagFormatShort) && i+1 < len(cmdArgs):
-					formatOption = cmdArgs[i+1]
-					i += 2
-				case (cmdArgs[i] == flagParams || cmdArgs[i] == flagParamsShort) && i+1 < len(cmdArgs):
-					paramsString = cmdArgs[i+1]
-					i += 2
-				case !resourceExtracted:
-					resourceName = cmdArgs[i]
-					resourceExtracted = true
-					i++
-				default:
-					parsedArgs = append(parsedArgs, cmdArgs[i])
-					i++
-				}
-			}
-
-			if resourceName == "" {
-				fmt.Fprintln(os.Stderr, "Error: resource name is required")
-				fmt.Fprintln(
-					os.Stderr,
-					"Example: mcp read-resource npx -y @modelcontextprotocol/server-filesystem ~",
-				)
-				os.Exit(1)
-			}
-
-			var params map[string]any
-			if len(parsedArgs) > 0 {
-				if jsonErr := json.Unmarshal([]byte(strings.Join(parsedArgs, " ")), &params); jsonErr != nil {
-					fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
-					os.Exit(1)
-				}
-			}
-
-			mcpClient, clientErr := createClientFunc(parsedArgs)
-			if clientErr != nil {
-				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
-				os.Exit(1)
-			}
-
-			resp, execErr := mcpClient.ReadResource(resourceName)
-			if formatErr := formatAndPrintResponse(resp, execErr); formatErr != nil {
-				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
-				os.Exit(1)
-			}
-		},
-	}
-}
-
-func newShellCmd() *cobra.Command { //nolint:gocyclo
-	return &cobra.Command{
-		Use:                "shell [command args...]",
-		Short:              "Start an interactive shell for MCP commands",
-		DisableFlagParsing: true,
-		SilenceUsage:       true,
-		Run: func(thisCmd *cobra.Command, args []string) {
-			if len(args) == 1 && (args[0] == flagHelp || args[0] == flagHelpShort) {
-				_ = thisCmd.Help()
-				return
-			}
-
-			cmdArgs := args
-			parsedArgs := []string{}
-
-			i := 0
-			for i < len(cmdArgs) {
-				switch {
-				case (cmdArgs[i] == flagFormat || cmdArgs[i] == flagFormatShort) && i+1 < len(cmdArgs):
-					formatOption = cmdArgs[i+1]
-					i += 2
-				default:
-					parsedArgs = append(parsedArgs, cmdArgs[i])
-					i++
-				}
-			}
-
-			if len(parsedArgs) == 0 {
-				fmt.Fprintln(os.Stderr, "Error: command to execute is required when using the shell")
-				fmt.Fprintln(os.Stderr, "Example: mcp shell npx -y @modelcontextprotocol/server-filesystem ~")
-				os.Exit(1)
-			}
-
-			mcpClient, clientErr := createClientFunc(parsedArgs)
-			if clientErr != nil {
-				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
-				os.Exit(1)
-			}
-
-			_, listErr := mcpClient.ListTools()
-			if listErr != nil {
-				fmt.Fprintf(os.Stderr, "Error connecting to MCP server: %v\n", listErr)
-				os.Exit(1)
-			}
-
-			fmt.Printf("mcp > MCP Tools Shell (%s)\n", Version)
-			fmt.Println("mcp > Connected to Server:", strings.Join(parsedArgs, " "))
-			fmt.Println("\nmcp > Type '/h' for help or '/q' to quit")
-
-			line := liner.NewLiner()
-			defer func() { _ = line.Close() }()
-
-			historyFile := filepath.Join(os.Getenv("HOME"), ".mcp_history")
-			if f, err := os.Open(filepath.Clean(historyFile)); err == nil {
-				_, _ = line.ReadHistory(f)
-				_ = f.Close()
-			}
-
-			defer func() {
-				if f, err := os.Create(historyFile); err == nil {
-					_, _ = line.WriteHistory(f)
-					_ = f.Close()
-				}
-			}()
-
-			line.SetCompleter(func(line string) (c []string) {
-				commands := []string{
-					"tools",
-					"resources",
-					"prompts",
-					"call",
-					"format",
-					"help",
-					"exit",
-					"/h",
-					"/q",
-					"/help",
-					"/quit",
-				}
-				for _, cmd := range commands {
-					if strings.HasPrefix(cmd, line) {
-						c = append(c, cmd)
-					}
-				}
-				return
-			})
-
-			for {
-				input, err := line.Prompt("mcp > ")
-				if err != nil {
-					if errors.Is(err, liner.ErrPromptAborted) {
-						fmt.Println("Exiting MCP shell")
-						break
-					}
-					fmt.Fprintf(os.Stderr, "Error reading input: %v\n", err)
-					break
-				}
-
-				if input == "" {
-					continue
-				}
-
-				line.AppendHistory(input)
-
-				if input == "/q" || input == "/quit" || input == "exit" {
-					fmt.Println("Exiting MCP shell")
-					break
-				}
-
-				if input == "/h" || input == "/help" || input == "help" {
-					printShellHelp()
-					continue
-				}
-
-				parts := strings.Fields(input)
-				if len(parts) == 0 {
-					continue
-				}
-
-				command := parts[0]
-				commandArgs := parts[1:]
-
-				var resp map[string]any
-				var respErr error
-
-				switch command {
-				case "tools":
-					resp, respErr = mcpClient.ListTools()
-					if respErr != nil {
-						fmt.Fprintf(os.Stderr, "Error: %v\n", respErr)
-
-						continue
-					}
-
-					output, formatErr := jsonutils.Format(resp, formatOption)
-					if formatErr != nil {
-						fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", formatErr)
-
-						continue
-					}
-
-					fmt.Println(output)
-
-				case "resources":
-					resp, respErr = mcpClient.ListResources()
-					if respErr != nil {
-						fmt.Fprintf(os.Stderr, "Error: %v\n", respErr)
-
-						continue
-					}
-
-					output, formatErr := jsonutils.Format(resp, formatOption)
-					if formatErr != nil {
-						fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", formatErr)
-
-						continue
-					}
-
-					fmt.Println(output)
-
-				case "prompts":
-					resp, respErr = mcpClient.ListPrompts()
-					if respErr != nil {
-						fmt.Fprintf(os.Stderr, "Error: %v\n", respErr)
-
-						continue
-					}
-
-					output, formatErr := jsonutils.Format(resp, formatOption)
-					if formatErr != nil {
-						fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", formatErr)
-
-						continue
-					}
-
-					fmt.Println(output)
-
-				case "call":
-					if len(commandArgs) < 1 {
-						fmt.Println("Usage: call <entity> [--params '{...}']")
-
-						continue
-					}
-
-					entityName := commandArgs[0]
-					entityType := entityTypeTool
-
-					parts = strings.SplitN(entityName, ":", 2)
-					if len(parts) == 2 {
-						entityType = parts[0]
-						entityName = parts[1]
-					}
-
-					params := map[string]any{}
-					for ii := 1; ii < len(commandArgs); ii++ {
-						if commandArgs[ii] == flagParams || commandArgs[ii] == flagParamsShort {
-							if ii+1 < len(commandArgs) {
-								if jsonErr := json.Unmarshal([]byte(commandArgs[ii+1]), &params); jsonErr != nil {
-									fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
-
-									continue
-								}
-								break
-							}
-						}
-					}
-
-					var execErr error
-
-					switch entityType {
-					case entityTypeTool:
-						resp, execErr = mcpClient.CallTool(entityName, params)
-					case entityTypeRes:
-						resp, execErr = mcpClient.ReadResource(entityName)
-					case entityTypePrompt:
-						resp, execErr = mcpClient.GetPrompt(entityName)
-					default:
-						fmt.Fprintf(os.Stderr, "Error: unsupported entity type: %s\n", entityType)
-						continue
-					}
-
-					if execErr != nil {
-						fmt.Fprintf(os.Stderr, "Error: %v\n", execErr)
-						continue
-					}
-
-					output, formatErr := jsonutils.Format(resp, formatOption)
-					if formatErr != nil {
-						fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", formatErr)
-						continue
-					}
-
-					fmt.Println(output)
-
-				case "format":
-					if len(commandArgs) < 1 {
-						fmt.Printf("Current format: %s\n", formatOption)
-						continue
-					}
-
-					newFormat := commandArgs[0]
-					if newFormat == "json" || newFormat == "j" ||
-						newFormat == "pretty" || newFormat == "p" ||
-						newFormat == "table" || newFormat == "t" {
-						formatOption = newFormat
-						fmt.Printf("Format set to: %s\n", formatOption)
-					} else {
-						fmt.Println("Invalid format. Use: table, json, or pretty")
-					}
-
-				default:
-					entityName := command
-					entityType := entityTypeTool
-
-					parts = strings.SplitN(entityName, ":", 2)
-					if len(parts) == 2 {
-						entityType = parts[0]
-						entityName = parts[1]
-					}
-
-					params := map[string]any{}
-
-					if len(commandArgs) > 0 {
-						firstArg := commandArgs[0]
-						if strings.HasPrefix(firstArg, "{") && strings.HasSuffix(firstArg, "}") {
-							if jsonErr := json.Unmarshal([]byte(firstArg), &params); jsonErr != nil {
-								fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
-								continue
-							}
-						} else {
-							for iii := 0; iii < len(commandArgs); iii++ {
-								if commandArgs[iii] == flagParams || commandArgs[iii] == flagParamsShort {
-									if iii+1 < len(commandArgs) {
-										if jsonErr := json.Unmarshal([]byte(commandArgs[iii+1]), &params); jsonErr != nil {
-											fmt.Fprintf(os.Stderr, "Error: invalid JSON for params: %v\n", jsonErr)
-											continue
-										}
-										break
-									}
-								}
-							}
-						}
-					}
-
-					var execErr error
-
-					switch entityType {
-					case entityTypeTool:
-						resp, execErr = mcpClient.CallTool(entityName, params)
-					case entityTypeRes:
-						resp, execErr = mcpClient.ReadResource(entityName)
-					case entityTypePrompt:
-						resp, execErr = mcpClient.GetPrompt(entityName)
-					default:
-						fmt.Printf("Unknown command: %s\nType '/h' for help\n", command)
-						continue
-					}
-
-					if execErr != nil {
-						fmt.Fprintf(os.Stderr, "Error: %v\n", execErr)
-						continue
-					}
-
-					output, formatErr := jsonutils.Format(resp, formatOption)
-					if formatErr != nil {
-						fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", formatErr)
-						continue
-					}
-
-					fmt.Println(output)
-				}
-			}
-		},
-	}
-}
-
-func printShellHelp() {
-	fmt.Println("MCP Shell Commands:")
-	fmt.Println("  tools                      List available tools")
-	fmt.Println("  resources                  List available resources")
-	fmt.Println("  prompts                    List available prompts")
-	fmt.Println("  call <entity> [--params '{...}']  Call a tool, resource, or prompt")
-	fmt.Println("  format [json|pretty|table] Get or set output format")
-	fmt.Println("Direct Tool Calling:")
-	fmt.Println("  <tool_name> {\"param\": \"value\"}  Call a tool directly with JSON parameters")
-	fmt.Println("  resource:<name>            Read a resource directly")
-	fmt.Println("  prompt:<name>              Get a prompt directly")
-	fmt.Println("Special Commands:")
-	fmt.Println("  /h, /help                  Show this help")
-	fmt.Println("  /q, /quit, exit            Exit the shell")
-}
-
-func newMockCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "mock [type] [name] [description] [content]...",
-		Short: "Create a mock MCP server with tools, prompts, and resources",
-		Long: `Create a mock MCP server with tools, prompts, and resources.
-This is useful for testing MCP clients without implementing a full server.
-
-The mock server implements the MCP protocol with:
-- Full initialization handshake (initialize method)
-- Support for notifications/initialized notification
-- Tool listing with standardized schema format
-- Tool calling with simple responses
-- Resource listing and reading with proper format
-- Prompt listing and retrieving with proper format
-- Standard error codes (-32601 for method not found)
-- Detailed request/response logging to ~/.mcpt/logs/mock.log
-
-Available types:
-- tool <name> <description>
-- prompt <name> <description> <template>
-- resource <uri> <description> <content>
-
-Example:
-  mcp mock tool hello_world "when user says hello world, run this tool"
-  mcp mock tool hello_world "A greeting tool" \
-         prompt welcome "A welcome prompt" "Hello {{name}}, welcome to {{location}}!" \
-         resource docs:readme "Documentation" "# Mock MCP Server\nThis is a mock server"`,
-		Args: cobra.MinimumNArgs(2),
-		Run: func(_ *cobra.Command, args []string) {
-			tools := make(map[string]string)
-			prompts := make(map[string]map[string]string)
-			resources := make(map[string]map[string]string)
-
-			i := 0
-			for i < len(args) {
-				entityType := args[i]
-				i++
-
-				switch entityType {
-				case entityTypeTool:
-					if i+1 >= len(args) {
-						fmt.Fprintln(os.Stderr, "Error: each tool must have both a name and description")
-						fmt.Fprintln(os.Stderr, "Example: mcp mock tool hello_world \"when user says hello world, run this tool\"")
-						os.Exit(1)
-					}
-
-					toolName := args[i]
-					toolDescription := args[i+1]
-					tools[toolName] = toolDescription
-					fmt.Fprintf(os.Stderr, "Added tool: %s - %s\n", toolName, toolDescription)
-					i += 2
-
-				case entityTypePrompt:
-					if i+2 >= len(args) {
-						fmt.Fprintln(os.Stderr, "Error: each prompt must have a name, description, and template")
-						fmt.Fprintln(os.Stderr, "Example: mcp mock prompt welcome \"Welcome message\" \"Hello {{name}}!\"")
-						os.Exit(1)
-					}
-
-					promptName := args[i]
-					promptDescription := args[i+1]
-					promptTemplate := args[i+2]
-
-					prompts[promptName] = map[string]string{
-						"description": promptDescription,
-						"template":    promptTemplate,
-					}
-
-					fmt.Fprintf(os.Stderr, "Added prompt: %s - %s\n", promptName, promptDescription)
-					i += 3
-
-				case entityTypeRes:
-					if i+2 >= len(args) {
-						fmt.Fprintln(os.Stderr, "Error: each resource must have a URI, description, and content")
-						fmt.Fprintln(os.Stderr, "Example: mcp mock resource docs:readme \"Documentation\" \"# README\"")
-						os.Exit(1)
-					}
-
-					resourceURI := args[i]
-					resourceDescription := args[i+1]
-					resourceContent := args[i+2]
-
-					resources[resourceURI] = map[string]string{
-						"description": resourceDescription,
-						"content":     resourceContent,
-					}
-
-					fmt.Fprintf(os.Stderr, "Added resource: %s - %s\n", resourceURI, resourceDescription)
-					i += 3
-
-				default:
-					fmt.Fprintf(os.Stderr, "Error: unknown entity type: %s\n", entityType)
-					fmt.Fprintln(os.Stderr, "Available types: tool, prompt, resource")
-					os.Exit(1)
-				}
-			}
-
-			if len(tools) == 0 && len(prompts) == 0 && len(resources) == 0 {
-				fmt.Fprintln(os.Stderr, "Error: at least one tool, prompt, or resource must be specified")
-				os.Exit(1)
-			}
-
-			fmt.Fprintf(os.Stderr, "Starting mock MCP server with %d tool(s), %d prompt(s), and %d resource(s)\n",
-				len(tools), len(prompts), len(resources))
-			fmt.Fprintf(os.Stderr, "Use Ctrl+C to exit\n")
-
-			if err := mock.RunMockServer(tools, prompts, resources); err != nil {
-				fmt.Fprintf(os.Stderr, "Error running mock server: %v\n", err)
-				os.Exit(1)
-			}
-		},
-	}
-
-	return cmd
-}
-
-func proxyCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "proxy",
-		Short: "Proxy MCP tool requests to shell scripts",
-		Long: `Proxy MCP tool requests to shell scripts.
-
-This command allows you to register shell scripts as MCP tools and proxy MCP requests to them.
-The scripts will receive tool parameters as environment variables.
-
-Examples:
-  # Register a shell script as an MCP tool
-  mcp proxy tool add_operation "Adds a and b" "a:int,b:int" ./add.sh
-
-  # Register an inline command as an MCP tool
-  mcp proxy tool add_operation "Adds a and b" "a:int,b:int" -e 'echo "total is $a + $b = $(($a+$b))"'
-
-  # Start a proxy server with the registered tools
-  mcp proxy start`,
-	}
-
-	cmd.AddCommand(proxyToolCmd())
-	cmd.AddCommand(proxyStartCmd())
-
-	return cmd
-}
-
-// loadProxyConfig loads the proxy configuration from the config file.
-func loadProxyConfig() (map[string]map[string]string, error) {
-	// Initialize config
-	viper.SetConfigName("proxy_config")
-	viper.SetConfigType("json")
-	viper.AddConfigPath("$HOME/.mcpt")
-
-	// Create config directory if it doesn't exist
-	configDir := os.ExpandEnv("$HOME/.mcpt")
-	if err := os.MkdirAll(configDir, 0o750); err != nil {
-		return nil, fmt.Errorf("error creating config directory: %w", err)
-	}
-
-	// Load existing config if it exists
-	var config map[string]map[string]string
-	var configFileNotFound viper.ConfigFileNotFoundError
-	err := viper.ReadInConfig()
-	if err != nil {
-		if errors.As(err, &configFileNotFound) {
-			// Config file not found, create a new one
-			config = make(map[string]map[string]string)
-		} else {
-			return nil, fmt.Errorf("error reading config: %w", err)
-		}
-	} else {
-		// Config file found, unmarshal it
-		config = make(map[string]map[string]string)
-		unmarshalErr := viper.Unmarshal(&config)
-		if unmarshalErr != nil {
-			return nil, fmt.Errorf("error unmarshaling config: %w", unmarshalErr)
-		}
-	}
-
-	return config, nil
-}
-
-// saveProxyConfig saves the proxy configuration to the config file.
-func saveProxyConfig(config map[string]map[string]string) error {
-	configPath := os.ExpandEnv("$HOME/.mcpt/proxy_config.json")
-	configJSON, err := json.MarshalIndent(config, "", "  ")
-	if err != nil {
-		return fmt.Errorf("error marshaling config: %w", err)
-	}
-
-	writeErr := os.WriteFile(configPath, configJSON, 0o600)
-	if writeErr != nil {
-		return fmt.Errorf("error writing config: %w", writeErr)
-	}
-
-	return nil
-}
-
-func proxyToolCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "tool [name] [description] [parameters] [script]",
-		Short: "Register a shell script as an MCP tool",
-		Long: `Register a shell script or inline command as an MCP tool that can be called via the MCP protocol.
-Parameters should be specified in the format "name:type,name:type,..." where type can be:
-- string: Text values
-- int: Integer numbers
-- float: Floating-point numbers
-- bool: Boolean values (true/false)
-
-The script or command will receive parameters as environment variables.
-
-You can either provide a script file path or use the -e flag to specify an inline command.
-Example with script:
-  mcp proxy tool add_operation "Adds a and b" "a:int,b:int" ./add.sh
-
-Example with inline command:
-  mcp proxy tool add_op "Adds given numbers" "a:int,b:int" -e "echo \"total is $a + $b = ${$a+$b}\""
-
-To unregister a tool, use the --unregister flag:
-  mcp proxy tool --unregister tool_name`,
-		Args: func(cmd *cobra.Command, args []string) error {
-			unregister, _ := cmd.Flags().GetBool("unregister")
-			if unregister {
-				if len(args) != 1 {
-					return fmt.Errorf("unregister requires exactly one argument: the tool name")
-				}
-				return nil
-			}
-			return cobra.RangeArgs(3, 4)(cmd, args)
-		},
-		RunE: func(cmd *cobra.Command, args []string) error {
-			unregister, _ := cmd.Flags().GetBool("unregister")
-			if unregister {
-				name := args[0]
-				// Load existing config
-				config, loadErr := loadProxyConfig()
-				if loadErr != nil {
-					return fmt.Errorf("error loading config: %w", loadErr)
-				}
-
-				// Check if tool exists
-				if _, exists := config[name]; !exists {
-					return fmt.Errorf("tool %s not found", name)
-				}
-
-				// Remove the tool from config
-				delete(config, name)
-
-				// Save updated config
-				if saveErr := saveProxyConfig(config); saveErr != nil {
-					return fmt.Errorf("error saving config: %w", saveErr)
-				}
-
-				fmt.Printf("Unregistered tool: %s\n", name)
-				return nil
-			}
-
-			name := args[0]
-			description := args[1]
-			parameters := args[2]
-			scriptPath := ""
-			if len(args) > 3 {
-				scriptPath = args[3]
-			}
-
-			// Get the inline command from the -e flag
-			command, _ := cmd.Flags().GetString("execute")
-
-			// Either script path or command must be provided
-			if scriptPath == "" && command == "" {
-				return fmt.Errorf("either script path or command (-e) must be provided")
-			}
-
-			// Load existing config
-			config, loadErr := loadProxyConfig()
-			if loadErr != nil {
-				return fmt.Errorf("error loading config: %w", loadErr)
-			}
-
-			// Add the new tool to config
-			config[name] = map[string]string{
-				"description": description,
-				"parameters":  parameters,
-				"script":      scriptPath,
-				"command":     command,
-			}
-
-			// Save updated config
-			if saveErr := saveProxyConfig(config); saveErr != nil {
-				return fmt.Errorf("error saving config: %w", saveErr)
-			}
-
-			fmt.Printf("Registered tool: %s\n", name)
-			return nil
-		},
-	}
-
-	cmd.Flags().StringP("execute", "e", "", "Inline command to execute instead of a script file")
-	cmd.Flags().Bool("unregister", false, "Unregister a tool")
-	return cmd
-}
-
-func proxyStartCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "start",
-		Short: "Start a proxy server with registered tools",
-		Long: `Start a proxy server that forwards MCP tool requests to shell scripts.
-
-The server reads tool configurations from $HOME/.mcpt/proxy_config.json.
-
-Example:
-  mcp proxy start`,
-		Run: func(_ *cobra.Command, _ []string) {
-			// Load tool configurations
-			viper.SetConfigName("proxy_config")
-			viper.SetConfigType("json")
-			viper.AddConfigPath("$HOME/.mcpt")
-
-			if err := viper.ReadInConfig(); err != nil {
-				log.Fatalf("Error reading config: %v", err)
-			}
-
-			var config map[string]map[string]string
-			if err := viper.Unmarshal(&config); err != nil {
-				log.Fatalf("Error unmarshaling config: %v", err)
-			}
-
-			// Run proxy server
-			fmt.Fprintln(os.Stderr, "Starting proxy server...")
-			if err := proxy.RunProxyServer(config); err != nil {
-				log.Fatalf("Error running proxy server: %v", err)
-			}
-		},
-	}
-
-	return cmd
-}
-
-func aliasCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "alias",
-		Short: "Manage MCP server aliases",
-		Long: `Manage aliases for MCP servers.
-
-This command allows you to register MCP server commands with a friendly name and
-reuse them later.
-
-Aliases are stored in $HOME/.mcpt/aliases.json.
-
-Examples:
-  # Add a new server alias
-  mcp alias add myfs npx -y @modelcontextprotocol/server-filesystem ~/
-
-  # List all registered server aliases
-  mcp alias list
-
-  # Remove a server alias
-  mcp alias remove myfs
-
-  # Use an alias with any MCP command
-  mcp tools myfs`,
-	}
-
-	cmd.AddCommand(aliasAddCmd())
-	cmd.AddCommand(aliasListCmd())
-	cmd.AddCommand(aliasRemoveCmd())
-
-	return cmd
-}
-
-func aliasAddCmd() *cobra.Command {
-	addCmd := &cobra.Command{
-		Use:                "add [alias] [command args...]",
-		Short:              "Add a new MCP server alias",
-		DisableFlagParsing: true,
-		Long: `Add a new alias for an MCP server command.
-
-The alias will be registered and can be used in place of the server command.
-
-Example:
-  mcp alias add myfs npx -y @modelcontextprotocol/server-filesystem ~/`,
-		Args: cobra.MinimumNArgs(2),
-		RunE: func(thisCmd *cobra.Command, args []string) error {
-			if len(args) == 1 && (args[0] == flagHelp || args[0] == flagHelpShort) {
-				_ = thisCmd.Help()
-				return nil
-			}
-
-			aliasName := args[0]
-			serverCommand := strings.Join(args[1:], " ")
-
-			aliases, err := alias.Load()
-			if err != nil {
-				return fmt.Errorf("error loading aliases: %w", err)
-			}
-
-			aliases[aliasName] = alias.ServerAlias{
-				Command: serverCommand,
-			}
-
-			if saveErr := alias.Save(aliases); saveErr != nil {
-				return fmt.Errorf("error saving aliases: %w", saveErr)
-			}
-
-			fmt.Printf("Alias '%s' registered for command: %s\n", aliasName, serverCommand)
-			return nil
-		},
-	}
-	return addCmd
-}
-
-func aliasListCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "list",
-		Short: "List all registered MCP server aliases",
-		RunE: func(_ *cobra.Command, _ []string) error {
-			// Load existing aliases
-			aliases, err := alias.Load()
-			if err != nil {
-				return fmt.Errorf("error loading aliases: %w", err)
-			}
-
-			if len(aliases) == 0 {
-				fmt.Println("No aliases registered.")
-				return nil
-			}
-
-			fmt.Println("Registered MCP server aliases:")
-			for name, a := range aliases {
-				fmt.Printf("  %s: %s\n", name, a.Command)
-			}
-
-			return nil
-		},
-	}
-}
-
-func aliasRemoveCmd() *cobra.Command {
-	return &cobra.Command{
-		Use:   "remove <name>",
-		Short: "Remove an MCP server alias",
-		Long: `Remove a registered alias for an MCP server command.
-
-Example:
-  mcp alias remove myfs`,
-		Args: cobra.ExactArgs(1),
-		RunE: func(thisCmd *cobra.Command, args []string) error {
-			if len(args) == 1 && (args[0] == flagHelp || args[0] == flagHelpShort) {
-				_ = thisCmd.Help()
-				return nil
-			}
-
-			aliasName := args[0]
-
-			aliases, err := alias.Load()
-			if err != nil {
-				return fmt.Errorf("error loading aliases: %w", err)
-			}
-
-			if _, exists := aliases[aliasName]; !exists {
-				return fmt.Errorf("alias '%s' does not exist", aliasName)
-			}
-
-			delete(aliases, aliasName)
-
-			if saveErr := alias.Save(aliases); saveErr != nil {
-				return fmt.Errorf("error saving aliases: %w", saveErr)
-			}
-
-			fmt.Printf("Alias '%s' removed.\n", aliasName)
-			return nil
-		},
-	}
-}
diff --git a/cmd/mcptools/main_test.go b/cmd/mcptools/main_test.go
index 81847d7..75b2180 100644
--- a/cmd/mcptools/main_test.go
+++ b/cmd/mcptools/main_test.go
@@ -11,6 +11,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/f/mcptools/cmd/mcptools/commands"
 	"github.com/f/mcptools/pkg/transport"
 )
 
@@ -366,7 +367,7 @@ func TestProxyToolRegistration(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			cmd := proxyToolCmd()
+			cmd := commands.ProxyToolCmd()
 			err := cmd.RunE(cmd, tc.args)
 
 			if tc.expectError {
@@ -382,7 +383,7 @@ func TestProxyToolRegistration(t *testing.T) {
 			}
 
 			// Verify the tool was registered in the config
-			config, err := loadProxyConfig()
+			config, err := commands.LoadProxyConfig()
 			if err != nil {
 				t.Fatalf("Error loading config: %v", err)
 			}
@@ -403,7 +404,7 @@ func TestProxyToolUnregistration(t *testing.T) {
 	}
 
 	// First register a tool
-	cmd := proxyToolCmd()
+	cmd := commands.ProxyToolCmd()
 	err := cmd.RunE(cmd, []string{
 		"test_tool",
 		"Test tool",
@@ -425,7 +426,7 @@ func TestProxyToolUnregistration(t *testing.T) {
 	}
 
 	// Verify the tool was removed from the config
-	config, err := loadProxyConfig()
+	config, err := commands.LoadProxyConfig()
 	if err != nil {
 		t.Fatalf("Error loading config: %v", err)
 	}