From f065cd408f4326c526358eec81cd630a9e1e41b7 Mon Sep 17 00:00:00 2001
From: ayakut16 <alperenyakut@gmail.com>
Date: Fri, 4 Apr 2025 12:18:22 +0100
Subject: [PATCH 1/8] refactor: move commands in their own files

---
 cmd/mcptools/commands/alias.go         |  147 +++
 cmd/mcptools/commands/call.go          |  120 +++
 cmd/mcptools/commands/get_prompt.go    |   88 ++
 cmd/mcptools/commands/mock.go          |  126 +++
 cmd/mcptools/{ => commands}/new.go     |   12 +-
 cmd/mcptools/commands/prompts.go       |   39 +
 cmd/mcptools/commands/proxy.go         |  234 +++++
 cmd/mcptools/commands/read_resource.go |   89 ++
 cmd/mcptools/commands/resources.go     |   39 +
 cmd/mcptools/commands/root.go          |   49 +
 cmd/mcptools/commands/shell.go         |  347 +++++++
 cmd/mcptools/commands/tools.go         |   39 +
 cmd/mcptools/commands/utils.go         |   85 ++
 cmd/mcptools/commands/version.go       |   21 +
 cmd/mcptools/commands/version_test.go  |   63 ++
 cmd/mcptools/main.go                   | 1308 +-----------------------
 cmd/mcptools/main_test.go              |    9 +-
 17 files changed, 1512 insertions(+), 1303 deletions(-)
 create mode 100644 cmd/mcptools/commands/alias.go
 create mode 100644 cmd/mcptools/commands/call.go
 create mode 100644 cmd/mcptools/commands/get_prompt.go
 create mode 100644 cmd/mcptools/commands/mock.go
 rename cmd/mcptools/{ => commands}/new.go (97%)
 create mode 100644 cmd/mcptools/commands/prompts.go
 create mode 100644 cmd/mcptools/commands/proxy.go
 create mode 100644 cmd/mcptools/commands/read_resource.go
 create mode 100644 cmd/mcptools/commands/resources.go
 create mode 100644 cmd/mcptools/commands/root.go
 create mode 100644 cmd/mcptools/commands/shell.go
 create mode 100644 cmd/mcptools/commands/tools.go
 create mode 100644 cmd/mcptools/commands/utils.go
 create mode 100644 cmd/mcptools/commands/version.go
 create mode 100644 cmd/mcptools/commands/version_test.go

diff --git a/cmd/mcptools/commands/alias.go b/cmd/mcptools/commands/alias.go
new file mode 100644
index 0000000..837428f
--- /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.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/commands/call.go b/cmd/mcptools/commands/call.go
new file mode 100644
index 0000000..a29d9c0
--- /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(resp, execErr); formatErr != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
+				os.Exit(1)
+			}
+		},
+	}
+}
diff --git a/cmd/mcptools/commands/get_prompt.go b/cmd/mcptools/commands/get_prompt.go
new file mode 100644
index 0000000..db3040d
--- /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(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..4c7fd26
--- /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(resp, listErr); formatErr != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
+				os.Exit(1)
+			}
+		},
+	}
+}
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..ae26e82
--- /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(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..3c2ae04
--- /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(resp, listErr); formatErr != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
+				os.Exit(1)
+			}
+		},
+	}
+}
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/tools.go b/cmd/mcptools/commands/tools.go
new file mode 100644
index 0000000..ab00689
--- /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(resp, listErr); formatErr != nil {
+				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
+				os.Exit(1)
+			}
+		},
+	}
+}
diff --git a/cmd/mcptools/commands/utils.go b/cmd/mcptools/commands/utils.go
new file mode 100644
index 0000000..7519beb
--- /dev/null
+++ b/cmd/mcptools/commands/utils.go
@@ -0,0 +1,85 @@
+package commands
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/f/mcptools/pkg/alias"
+	"github.com/f/mcptools/pkg/client"
+	"github.com/f/mcptools/pkg/jsonutils"
+)
+
+// 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(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
+}
diff --git a/cmd/mcptools/commands/version.go b/cmd/mcptools/commands/version.go
new file mode 100644
index 0000000..10dac39
--- /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(_ *cobra.Command, _ []string) {
+			fmt.Printf("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..be2593a
--- /dev/null
+++ b/cmd/mcptools/commands/version_test.go
@@ -0,0 +1,63 @@
+package commands
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"testing"
+)
+
+func TestVersionCmd(t *testing.T) {
+	// Save original stdout and restore it at the end
+	originalStdout := os.Stdout
+	defer func() { os.Stdout = originalStdout }()
+
+	// Create a pipe to capture stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	// Set a test version
+	oldVersion := Version
+	Version = "test-version"
+	defer func() { Version = oldVersion }()
+
+	// Execute the version command
+	cmd := NewVersionCmd()
+	cmd.Execute()
+
+	// Close the write end of the pipe to read from it
+	w.Close()
+
+	// Read captured output
+	var buf bytes.Buffer
+	io.Copy(&buf, r)
+	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 := NewVersionCmd()
+	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")
+	}
+}
\ No newline at end of file
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)
 	}

From e0e0d64098df14458d7937f16da1b5df29aa1940 Mon Sep 17 00:00:00 2001
From: ayakut16 <alperenyakut@gmail.com>
Date: Fri, 4 Apr 2025 21:27:41 +0100
Subject: [PATCH 2/8] Add tests for commands

---
 cmd/mcptools/commands/alias.go          |  12 +-
 cmd/mcptools/commands/alias_test.go     | 167 ++++++++++++++++++++++
 cmd/mcptools/commands/call.go           |   2 +-
 cmd/mcptools/commands/call_test.go      | 103 ++++++++++++++
 cmd/mcptools/commands/get_prompt.go     |   2 +-
 cmd/mcptools/commands/prompts.go        |   2 +-
 cmd/mcptools/commands/prompts_test.go   |  62 +++++++++
 cmd/mcptools/commands/read_resource.go  |   2 +-
 cmd/mcptools/commands/resources.go      |   2 +-
 cmd/mcptools/commands/resources_test.go |  64 +++++++++
 cmd/mcptools/commands/test_helpers.go   |  57 ++++++++
 cmd/mcptools/commands/tools.go          |   2 +-
 cmd/mcptools/commands/tools_test.go     |  62 +++++++++
 cmd/mcptools/commands/utils.go          |   5 +-
 cmd/mcptools/commands/utils_test.go     | 178 ++++++++++++++++++++++++
 cmd/mcptools/commands/version.go        |   4 +-
 cmd/mcptools/commands/version_test.go   |  29 ++--
 17 files changed, 719 insertions(+), 36 deletions(-)
 create mode 100644 cmd/mcptools/commands/alias_test.go
 create mode 100644 cmd/mcptools/commands/call_test.go
 create mode 100644 cmd/mcptools/commands/prompts_test.go
 create mode 100644 cmd/mcptools/commands/resources_test.go
 create mode 100644 cmd/mcptools/commands/test_helpers.go
 create mode 100644 cmd/mcptools/commands/tools_test.go
 create mode 100644 cmd/mcptools/commands/utils_test.go

diff --git a/cmd/mcptools/commands/alias.go b/cmd/mcptools/commands/alias.go
index 837428f..dc934c6 100644
--- a/cmd/mcptools/commands/alias.go
+++ b/cmd/mcptools/commands/alias.go
@@ -75,7 +75,7 @@ Example:
 				return fmt.Errorf("error saving aliases: %w", saveErr)
 			}
 
-			fmt.Printf("Alias '%s' registered for command: %s\n", aliasName, serverCommand)
+			fmt.Fprintf(thisCmd.OutOrStdout(), "Alias '%s' registered for command: %s\n", aliasName, serverCommand)
 			return nil
 		},
 	}
@@ -86,7 +86,7 @@ func aliasListCmd() *cobra.Command {
 	return &cobra.Command{
 		Use:   "list",
 		Short: "List all registered MCP server aliases",
-		RunE: func(_ *cobra.Command, _ []string) error {
+		RunE: func(cmd *cobra.Command, _ []string) error {
 			// Load existing aliases
 			aliases, err := alias.Load()
 			if err != nil {
@@ -94,13 +94,13 @@ func aliasListCmd() *cobra.Command {
 			}
 
 			if len(aliases) == 0 {
-				fmt.Println("No aliases registered.")
+				fmt.Fprintln(cmd.OutOrStdout(), "No aliases registered.")
 				return nil
 			}
 
-			fmt.Println("Registered MCP server aliases:")
+			fmt.Fprintln(cmd.OutOrStdout(), "Registered MCP server aliases:")
 			for name, a := range aliases {
-				fmt.Printf("  %s: %s\n", name, a.Command)
+				fmt.Fprintf(cmd.OutOrStdout(), "  %s: %s\n", name, a.Command)
 			}
 
 			return nil
@@ -140,7 +140,7 @@ Example:
 				return fmt.Errorf("error saving aliases: %w", saveErr)
 			}
 
-			fmt.Printf("Alias '%s' removed.\n", aliasName)
+			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
index a29d9c0..83133c0 100644
--- a/cmd/mcptools/commands/call.go
+++ b/cmd/mcptools/commands/call.go
@@ -111,7 +111,7 @@ func CallCmd() *cobra.Command {
 				os.Exit(1)
 			}
 
-			if formatErr := FormatAndPrintResponse(resp, execErr); formatErr != nil {
+			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
index db3040d..a39ed95 100644
--- a/cmd/mcptools/commands/get_prompt.go
+++ b/cmd/mcptools/commands/get_prompt.go
@@ -79,7 +79,7 @@ func GetPromptCmd() *cobra.Command {
 			}
 
 			resp, execErr := mcpClient.GetPrompt(promptName)
-			if formatErr := FormatAndPrintResponse(resp, execErr); formatErr != nil {
+			if formatErr := FormatAndPrintResponse(thisCmd, resp, execErr); formatErr != nil {
 				fmt.Fprintf(os.Stderr, "%v\n", formatErr)
 				os.Exit(1)
 			}
diff --git a/cmd/mcptools/commands/prompts.go b/cmd/mcptools/commands/prompts.go
index 4c7fd26..c15b79a 100644
--- a/cmd/mcptools/commands/prompts.go
+++ b/cmd/mcptools/commands/prompts.go
@@ -30,7 +30,7 @@ func PromptsCmd() *cobra.Command {
 			}
 
 			resp, listErr := mcpClient.ListPrompts()
-			if formatErr := FormatAndPrintResponse(resp, listErr); formatErr != nil {
+			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/read_resource.go b/cmd/mcptools/commands/read_resource.go
index ae26e82..d4cd2ac 100644
--- a/cmd/mcptools/commands/read_resource.go
+++ b/cmd/mcptools/commands/read_resource.go
@@ -80,7 +80,7 @@ func ReadResourceCmd() *cobra.Command {
 			}
 
 			resp, execErr := mcpClient.ReadResource(resourceName)
-			if formatErr := FormatAndPrintResponse(resp, execErr); formatErr != nil {
+			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
index 3c2ae04..9a79d1c 100644
--- a/cmd/mcptools/commands/resources.go
+++ b/cmd/mcptools/commands/resources.go
@@ -30,7 +30,7 @@ func ResourcesCmd() *cobra.Command {
 			}
 
 			resp, listErr := mcpClient.ListResources()
-			if formatErr := FormatAndPrintResponse(resp, listErr); formatErr != nil {
+			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/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
index ab00689..321992e 100644
--- a/cmd/mcptools/commands/tools.go
+++ b/cmd/mcptools/commands/tools.go
@@ -30,7 +30,7 @@ func ToolsCmd() *cobra.Command {
 			}
 
 			resp, listErr := mcpClient.ListTools()
-			if formatErr := FormatAndPrintResponse(resp, listErr); formatErr != nil {
+			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
index 7519beb..31bc537 100644
--- a/cmd/mcptools/commands/utils.go
+++ b/cmd/mcptools/commands/utils.go
@@ -7,6 +7,7 @@ import (
 	"github.com/f/mcptools/pkg/alias"
 	"github.com/f/mcptools/pkg/client"
 	"github.com/f/mcptools/pkg/jsonutils"
+	"github.com/spf13/cobra"
 )
 
 // sentinel errors.
@@ -70,7 +71,7 @@ func ProcessFlags(args []string) []string {
 
 // FormatAndPrintResponse formats and prints an MCP response in the format specified by
 // FormatOption.
-func FormatAndPrintResponse(resp map[string]any, err error) error {
+func FormatAndPrintResponse(cmd *cobra.Command, resp map[string]any, err error) error {
 	if err != nil {
 		return fmt.Errorf("error: %w", err)
 	}
@@ -80,6 +81,6 @@ func FormatAndPrintResponse(resp map[string]any, err error) error {
 		return fmt.Errorf("error formatting output: %w", err)
 	}
 
-	fmt.Println(output)
+	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
index 10dac39..cb1505e 100644
--- a/cmd/mcptools/commands/version.go
+++ b/cmd/mcptools/commands/version.go
@@ -14,8 +14,8 @@ func VersionCmd() *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)
+		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
index be2593a..6888b6e 100644
--- a/cmd/mcptools/commands/version_test.go
+++ b/cmd/mcptools/commands/version_test.go
@@ -2,35 +2,24 @@ package commands
 
 import (
 	"bytes"
-	"io"
-	"os"
 	"testing"
 )
 
 func TestVersionCmd(t *testing.T) {
-	// Save original stdout and restore it at the end
-	originalStdout := os.Stdout
-	defer func() { os.Stdout = originalStdout }()
+	buf := new(bytes.Buffer)
 
-	// Create a pipe to capture stdout
-	r, w, _ := os.Pipe()
-	os.Stdout = w
-
-	// Set a test version
 	oldVersion := Version
 	Version = "test-version"
 	defer func() { Version = oldVersion }()
 
-	// Execute the version command
-	cmd := NewVersionCmd()
-	cmd.Execute()
-
-	// Close the write end of the pipe to read from it
-	w.Close()
+	// 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
-	var buf bytes.Buffer
-	io.Copy(&buf, r)
 	output := buf.String()
 
 	// Check that the version is in the output
@@ -42,7 +31,7 @@ func TestVersionCmd(t *testing.T) {
 
 func TestVersionCmdWorks(t *testing.T) {
 	// Test that the version command can be created and executed
-	cmd := NewVersionCmd()
+	cmd := VersionCmd()
 	if cmd == nil {
 		t.Fatal("Expected version command to be created")
 	}
@@ -60,4 +49,4 @@ func TestVersionCmdWorks(t *testing.T) {
 	if cmd.Run == nil {
 		t.Error("Expected Run function to be defined")
 	}
-}
\ No newline at end of file
+}

From 5f32ce00761d1e93d0cc67b82374f78f0fd9e3c2 Mon Sep 17 00:00:00 2001
From: ayakut16 <alperenyakut@gmail.com>
Date: Sat, 5 Apr 2025 21:01:38 +0100
Subject: [PATCH 3/8] Send initialize request and initialized notification
 before running a command.

---
 pkg/transport/stdio.go     | 174 ++++++++++++++++++++++++++++---------
 pkg/transport/transport.go |   6 +-
 2 files changed, 139 insertions(+), 41 deletions(-)

diff --git a/pkg/transport/stdio.go b/pkg/transport/stdio.go
index f774d36..de433e2 100644
--- a/pkg/transport/stdio.go
+++ b/pkg/transport/stdio.go
@@ -1,6 +1,7 @@
 package transport
 
 import (
+	"bufio"
 	"bytes"
 	"encoding/json"
 	"fmt"
@@ -31,12 +32,27 @@ func NewStdio(command []string) *Stdio {
 // Execute implements the Transport interface by spawning a subprocess
 // and communicating with it via JSON-RPC over stdin/stdout.
 func (t *Stdio) Execute(method string, params any) (map[string]any, error) {
-	if len(t.command) == 0 {
-		return nil, fmt.Errorf("no command specified for stdio transport")
+	stdin, stdout, cmd, stderrBuf, err := t.setupCommand()
+	if err != nil {
+		return nil, err
 	}
 
 	if t.debug {
-		fmt.Fprintf(os.Stderr, "DEBUG: Executing command: %v\n", t.command)
+		fmt.Fprintf(os.Stderr, "DEBUG: Starting initialization\n")
+	}
+
+	if initErr := t.initialize(stdin, stdout); initErr != nil {
+		if t.debug {
+			fmt.Fprintf(os.Stderr, "DEBUG: Initialization failed: %v\n", initErr)
+			if stderrBuf.Len() > 0 {
+				fmt.Fprintf(os.Stderr, "DEBUG: stderr during init: %s\n", stderrBuf.String())
+			}
+		}
+		return nil, initErr
+	}
+
+	if t.debug {
+		fmt.Fprintf(os.Stderr, "DEBUG: Initialization successful, sending method request\n")
 	}
 
 	request := Request{
@@ -47,77 +63,155 @@ func (t *Stdio) Execute(method string, params any) (map[string]any, error) {
 	}
 	t.nextID++
 
-	requestJSON, err := json.Marshal(request)
+	if sendErr := t.sendRequest(stdin, request); sendErr != nil {
+		return nil, sendErr
+	}
+	_ = stdin.Close()
+
+	response, err := t.readResponse(stdout)
 	if err != nil {
-		return nil, fmt.Errorf("error marshaling request: %w", err)
+		return nil, err
 	}
 
-	requestJSON = append(requestJSON, '\n')
+	waitErr := cmd.Wait()
 
 	if t.debug {
-		fmt.Fprintf(os.Stderr, "DEBUG: Sending request: %s\n", string(requestJSON))
+		fmt.Fprintf(os.Stderr, "DEBUG: Command completed with err: %v\n", waitErr)
+		if stderrBuf.Len() > 0 {
+			fmt.Fprintf(os.Stderr, "DEBUG: stderr output:\n%s\n", stderrBuf.String())
+		}
 	}
 
-	cmd := exec.Command(t.command[0], t.command[1:]...) // #nosec G204
+	if waitErr != nil && stderrBuf.Len() > 0 {
+		return nil, fmt.Errorf("command error: %w, stderr: %s", waitErr, stderrBuf.String())
+	}
+
+	return response.Result, nil
+}
 
-	stdin, stdinErr := cmd.StdinPipe()
-	if stdinErr != nil {
-		return nil, fmt.Errorf("error getting stdin pipe: %w", stdinErr)
+// setupCommand prepares and starts the command, returning the stdin/stdout pipes and any error.
+func (t *Stdio) setupCommand() (stdin io.WriteCloser, stdout io.ReadCloser, cmd *exec.Cmd, stderrBuf *bytes.Buffer, err error) {
+	if len(t.command) == 0 {
+		return nil, nil, nil, nil, fmt.Errorf("no command specified for stdio transport")
 	}
 
-	stdout, stdoutErr := cmd.StdoutPipe()
-	if stdoutErr != nil {
-		return nil, fmt.Errorf("error getting stdout pipe: %w", stdoutErr)
+	if t.debug {
+		fmt.Fprintf(os.Stderr, "DEBUG: Executing command: %v\n", t.command)
 	}
 
-	var stderrBuf bytes.Buffer
-	cmd.Stderr = &stderrBuf
+	cmd = exec.Command(t.command[0], t.command[1:]...) // #nosec G204
+
+	stdin, err = cmd.StdinPipe()
+	if err != nil {
+		return nil, nil, nil, nil, fmt.Errorf("error getting stdin pipe: %w", err)
+	}
 
-	if startErr := cmd.Start(); startErr != nil {
-		return nil, fmt.Errorf("error starting command: %w", startErr)
+	stdout, err = cmd.StdoutPipe()
+	if err != nil {
+		return nil, nil, nil, nil, fmt.Errorf("error getting stdout pipe: %w", err)
 	}
 
-	if _, writeErr := stdin.Write(requestJSON); writeErr != nil {
-		return nil, fmt.Errorf("error writing to stdin: %w", writeErr)
+	stderrBuf = &bytes.Buffer{}
+	cmd.Stderr = stderrBuf
+
+	if err = cmd.Start(); err != nil {
+		return nil, nil, nil, nil, fmt.Errorf("error starting command: %w", err)
+	}
+
+	return stdin, stdout, cmd, stderrBuf, nil
+}
+
+// initialize sends the initialization request and waits for response and then sends the initialized
+// notification.
+func (t *Stdio) initialize(stdin io.WriteCloser, stdout io.ReadCloser) error {
+	initRequest := Request{
+		JSONRPC: "2.0",
+		Method:  "initialize",
+		ID:      t.nextID,
+		Params: map[string]any{
+			"clientInfo": map[string]any{
+				"name":    "f/mcptools",
+				"version": "beta",
+			},
+			"protocolVersion": protocolVersion,
+			"capabilities":    map[string]any{},
+		},
+	}
+	t.nextID++
+
+	if err := t.sendRequest(stdin, initRequest); err != nil {
+		return fmt.Errorf("init request failed: %w", err)
 	}
-	_ = stdin.Close()
+
+	_, err := t.readResponse(stdout)
+	if err != nil {
+		return fmt.Errorf("init response failed: %w", err)
+	}
+
+	initNotification := Request{
+		JSONRPC: "2.0",
+		Method:  "notifications/initialized",
+	}
+
+	if sendErr := t.sendRequest(stdin, initNotification); sendErr != nil {
+		return fmt.Errorf("init notification failed: %w", sendErr)
+	}
+
+	return nil
+}
+
+// sendRequest sends a JSON-RPC request and returns the marshaled request.
+func (t *Stdio) sendRequest(stdin io.WriteCloser, request Request) error {
+	requestJSON, err := json.Marshal(request)
+	if err != nil {
+		return fmt.Errorf("error marshaling request: %w", err)
+	}
+	requestJSON = append(requestJSON, '\n')
 
 	if t.debug {
-		fmt.Fprintf(os.Stderr, "DEBUG: Wrote request to stdin\n")
+		fmt.Fprintf(os.Stderr, "DEBUG: Preparing to send request: %s\n", string(requestJSON))
 	}
 
-	var respBytes bytes.Buffer
-	if _, copyErr := io.Copy(&respBytes, stdout); copyErr != nil {
-		return nil, fmt.Errorf("error reading from stdout: %w", copyErr)
+	writer := bufio.NewWriter(stdin)
+	n, err := writer.Write(requestJSON)
+	if err != nil {
+		return fmt.Errorf("error writing bytes to stdin: %w", err)
 	}
 
 	if t.debug {
-		fmt.Fprintf(os.Stderr, "DEBUG: Read from stdout: %s\n", respBytes.String())
+		fmt.Fprintf(os.Stderr, "DEBUG: Wrote %d bytes\n", n)
 	}
 
-	waitErr := cmd.Wait()
+	if flushErr := writer.Flush(); flushErr != nil {
+		return fmt.Errorf("error flushing bytes to stdin: %w", flushErr)
+	}
 
 	if t.debug {
-		fmt.Fprintf(os.Stderr, "DEBUG: Command completed with err: %v\n", waitErr)
-		if stderrBuf.Len() > 0 {
-			fmt.Fprintf(os.Stderr, "DEBUG: stderr output: %s\n", stderrBuf.String())
-		}
+		fmt.Fprintf(os.Stderr, "DEBUG: Successfully flushed bytes\n")
 	}
 
-	if waitErr != nil && stderrBuf.Len() > 0 {
-		return nil, fmt.Errorf("command error: %w, stderr: %s", waitErr, stderrBuf.String())
+	return nil
+}
+
+// readResponse reads and parses a JSON-RPC response.
+func (t *Stdio) readResponse(stdout io.ReadCloser) (*Response, error) {
+	reader := bufio.NewReader(stdout)
+	line, err := reader.ReadBytes('\n')
+	if err != nil {
+		return nil, fmt.Errorf("error reading from stdout: %w", err)
 	}
 
-	if respBytes.Len() == 0 {
-		if stderrBuf.Len() > 0 {
-			return nil, fmt.Errorf("no response from command, stderr: %s", stderrBuf.String())
-		}
+	if t.debug {
+		fmt.Fprintf(os.Stderr, "DEBUG: Read from stdout: %s", string(line))
+	}
+
+	if len(line) == 0 {
 		return nil, fmt.Errorf("no response from command")
 	}
 
 	var response Response
-	if unmarshalErr := json.Unmarshal(respBytes.Bytes(), &response); unmarshalErr != nil {
-		return nil, fmt.Errorf("error unmarshaling response: %w, response: %s", unmarshalErr, respBytes.String())
+	if unmarshalErr := json.Unmarshal(line, &response); unmarshalErr != nil {
+		return nil, fmt.Errorf("error unmarshaling response: %w, response: %s", unmarshalErr, string(line))
 	}
 
 	if response.Error != nil {
@@ -128,5 +222,5 @@ func (t *Stdio) Execute(method string, params any) (map[string]any, error) {
 		fmt.Fprintf(os.Stderr, "DEBUG: Successfully parsed response\n")
 	}
 
-	return response.Result, nil
+	return &response, nil
 }
diff --git a/pkg/transport/transport.go b/pkg/transport/transport.go
index 6341aab..b27b7a8 100644
--- a/pkg/transport/transport.go
+++ b/pkg/transport/transport.go
@@ -6,6 +6,10 @@ import (
 	"io"
 )
 
+const (
+	protocolVersion = "2024-11-05"
+)
+
 // Transport defines the interface for communicating with MCP servers.
 // Implementations should handle the specifics of communication protocols.
 type Transport interface {
@@ -17,7 +21,7 @@ type Request struct {
 	Params  any    `json:"params,omitempty"`
 	JSONRPC string `json:"jsonrpc"`
 	Method  string `json:"method"`
-	ID      int    `json:"id"`
+	ID      int    `json:"id,omitempty"`
 }
 
 // Response represents a JSON-RPC 2.0 response.

From 55119072c3006ce1ba9b0ffc830bce0909c1fd5f Mon Sep 17 00:00:00 2001
From: Cian Johnston <public@cianjohnston.ie>
Date: Sun, 6 Apr 2025 16:42:04 +0100
Subject: [PATCH 4/8] fix(pkg/jsonutils): add description to resource list,
 unskip test

---
 cmd/mcptools/commands/resources_test.go | 10 ++++----
 pkg/jsonutils/jsonutils.go              | 32 +++++++++++++++++--------
 2 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/cmd/mcptools/commands/resources_test.go b/cmd/mcptools/commands/resources_test.go
index 19f23bf..0ffda6f 100644
--- a/cmd/mcptools/commands/resources_test.go
+++ b/cmd/mcptools/commands/resources_test.go
@@ -25,13 +25,13 @@ func TestResourcesCmdRun_Help(t *testing.T) {
 }
 
 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",
+				"uri":         "test://resource",
+				"mimeType":    "text/plain",
+				"name":        "TestResource",
 				"description": "Test resource description",
 			},
 		},
@@ -59,6 +59,8 @@ func TestResourcesCmdRun_Success(t *testing.T) {
 
 	// Verify output contains expected content
 	output := buf.String()
-	assertContains(t, output, "test-resource")
+	assertContains(t, output, "TestResource")
+	assertContains(t, output, "test://resource")
+	assertContains(t, output, "text/plain")
 	assertContains(t, output, "Test resource description")
 }
diff --git a/pkg/jsonutils/jsonutils.go b/pkg/jsonutils/jsonutils.go
index dc9d80c..57ef3d8 100644
--- a/pkg/jsonutils/jsonutils.go
+++ b/pkg/jsonutils/jsonutils.go
@@ -622,17 +622,24 @@ func formatResourcesList(resources any) (string, error) {
 	w := tabwriter.NewWriter(&buf, 0, 0, 2, ' ', 0)
 	useColors := isTerminal()
 
+	// NOTE: Ensure that the column headers are the same length,
+	//       including the color escape sequences!
 	if useColors {
-		fmt.Fprintf(w, "%s%sNAME%s\t%sTYPE%s\t%sURI%s\n",
-			ColorBold, ColorCyan, ColorReset,
+		fmt.Fprintf(w, "%sNAME%s\t%sMIMETYPE%s\t%sURI%s\t%sDESCRIPTION%s\n",
+			ColorCyan, ColorReset,
+			ColorCyan, ColorReset,
+			ColorCyan, ColorReset,
+			ColorCyan, ColorReset)
+		fmt.Fprintf(w, "%s----%s\t%s--------%s\t%s---%s\t%s----------%s\n",
+			ColorCyan, ColorReset,
+			ColorCyan, ColorReset,
 			ColorCyan, ColorReset,
 			ColorCyan, ColorReset)
 	} else {
-		fmt.Fprintln(w, "NAME\tTYPE\tURI")
+		fmt.Fprintln(w, "NAME\tMIMETYPE\tURI\tDESCRIPTION")
+		fmt.Fprintln(w, "----\t--------\t---\t-----------")
 	}
 
-	fmt.Fprintln(w, "----\t----\t---")
-
 	for _, r := range resourcesSlice {
 		resource, ok1 := r.(map[string]any)
 		if !ok1 {
@@ -640,17 +647,22 @@ func formatResourcesList(resources any) (string, error) {
 		}
 
 		name, _ := resource["name"].(string)
-		resType, _ := resource["type"].(string)
+		mimeType, _ := resource["mimeType"].(string)
 		uri, _ := resource["uri"].(string)
+		desc, _ := resource["description"].(string)
+		if len(desc) > 50 {
+			desc = desc[:47] + "..."
+		}
 
 		// Use the entire URI instead of truncating
 		if useColors {
-			fmt.Fprintf(w, "%s%s%s\t%s%s\t%s%s%s\n",
+			fmt.Fprintf(w, "%s%s%s\t%s%s%s\t%s%s%s\t%s\n",
 				ColorGreen, name, ColorReset,
-				resType, ColorReset,
-				ColorYellow, uri, ColorReset)
+				ColorGreen, mimeType, ColorReset,
+				ColorYellow, uri, ColorReset,
+				desc)
 		} else {
-			fmt.Fprintf(w, "%s\t%s\t%s\n", name, resType, uri)
+			fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", name, mimeType, uri, desc)
 		}
 	}
 

From a2ce58fc86f72bf9b801ad9975e3b4a6c27c9290 Mon Sep 17 00:00:00 2001
From: Cian Johnston <public@cianjohnston.ie>
Date: Sun, 6 Apr 2025 17:18:48 +0100
Subject: [PATCH 5/8] fix(cmd/mcptools/commands): stop attempting to unmarshal
 MCP server args as JSON

---
 cmd/mcptools/commands/read_resource.go | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/cmd/mcptools/commands/read_resource.go b/cmd/mcptools/commands/read_resource.go
index d4cd2ac..735c681 100644
--- a/cmd/mcptools/commands/read_resource.go
+++ b/cmd/mcptools/commands/read_resource.go
@@ -1,10 +1,8 @@
 package commands
 
 import (
-	"encoding/json"
 	"fmt"
 	"os"
-	"strings"
 
 	"github.com/spf13/cobra"
 )
@@ -65,14 +63,6 @@ func ReadResourceCmd() *cobra.Command {
 				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)

From 96b402f7832f29db64873f5f7fbc57620d6a4a73 Mon Sep 17 00:00:00 2001
From: Cian Johnston <public@cianjohnston.ie>
Date: Sun, 6 Apr 2025 17:19:19 +0100
Subject: [PATCH 6/8] chore(cmd/mcptools/commands): add test for read-resorurce
 command

---
 cmd/mcptools/commands/read_resource_test.go | 72 +++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 cmd/mcptools/commands/read_resource_test.go

diff --git a/cmd/mcptools/commands/read_resource_test.go b/cmd/mcptools/commands/read_resource_test.go
new file mode 100644
index 0000000..39738ed
--- /dev/null
+++ b/cmd/mcptools/commands/read_resource_test.go
@@ -0,0 +1,72 @@
+package commands
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestResourceReadCmd_RunHelp(t *testing.T) {
+	// Given: the read resource command is run
+	cmd := ReadResourceCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+
+	// When: the command is run with the help flag
+	cmd.SetArgs([]string{"--help"})
+
+	// Then: no error is returned.
+	err := cmd.Execute()
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+
+	// Then: the help output is not empty.
+	if buf.String() == "" {
+		t.Error("Expected help output to not be empty.")
+	}
+}
+
+func TestReadResourceCmdRun_Success(t *testing.T) {
+	t.Setenv("COLS", "120")
+	// Given: the read resource command is run
+	cmd := ReadResourceCmd()
+	buf := new(bytes.Buffer)
+	cmd.SetOut(buf)
+	// NOTE: we currently truncate output in tabular output.
+	cmd.SetArgs([]string{"server", "-f", "json", "arg"})
+
+	// Given: a mock client that returns a successful read resource response
+	mockResponse := map[string]any{
+		"result": map[string]any{
+			"contents": []any{
+				map[string]any{
+					"uri":      "test://foo",
+					"mimeType": "text/plain",
+					"text":     "bar",
+				},
+			},
+		},
+	}
+
+	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()
+
+	// When: the command is executed
+	err := cmd.Execute()
+
+	// Then: no error is returned
+	if err != nil {
+		t.Errorf("cmd.Execute() error = %v", err)
+	}
+
+	// Then: the expected content is returned
+	output := buf.String()
+	assertContains(t, output, "test://foo")
+	assertContains(t, output, "text/plain")
+	assertContains(t, output, "bar")
+}

From efc311ba50969620d828648e6a0a088092e2ec12 Mon Sep 17 00:00:00 2001
From: Cian Johnston <public@cianjohnston.ie>
Date: Sun, 6 Apr 2025 17:19:38 +0100
Subject: [PATCH 7/8] fix(pkg/jsonutils): fix output alignment of
 formatGenericMap()

---
 pkg/jsonutils/jsonutils.go | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/pkg/jsonutils/jsonutils.go b/pkg/jsonutils/jsonutils.go
index dc9d80c..b23c3fd 100644
--- a/pkg/jsonutils/jsonutils.go
+++ b/pkg/jsonutils/jsonutils.go
@@ -766,15 +766,17 @@ func formatGenericMap(data map[string]any) (string, error) {
 	useColors := isTerminal()
 
 	if useColors {
-		fmt.Fprintf(w, "%s%sKEY%s\t%sVALUE%s\n",
-			ColorBold, ColorCyan, ColorReset,
+		fmt.Fprintf(w, "%sKEY%s\t%sVALUE%s\n",
+			ColorCyan, ColorReset,
+			ColorCyan, ColorReset)
+		fmt.Fprintf(w, "%s---%s\t%s-----%s\n",
+			ColorCyan, ColorReset,
 			ColorCyan, ColorReset)
 	} else {
 		fmt.Fprintln(w, "KEY\tVALUE")
+		fmt.Fprintln(w, "---\t-----")
 	}
 
-	fmt.Fprintln(w, "---\t-----")
-
 	keys := make([]string, 0, len(data))
 	for k := range data {
 		keys = append(keys, k)

From 2e8211e5701fa1afa031d925e245427369bee57f Mon Sep 17 00:00:00 2001
From: Cian Johnston <public@cianjohnston.ie>
Date: Sun, 6 Apr 2025 17:59:43 +0100
Subject: [PATCH 8/8] gofumpt

---
 cmd/mcptools/commands/read_resource_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/cmd/mcptools/commands/read_resource_test.go b/cmd/mcptools/commands/read_resource_test.go
index 39738ed..4b5ac5e 100644
--- a/cmd/mcptools/commands/read_resource_test.go
+++ b/cmd/mcptools/commands/read_resource_test.go
@@ -58,7 +58,6 @@ func TestReadResourceCmdRun_Success(t *testing.T) {
 
 	// When: the command is executed
 	err := cmd.Execute()
-
 	// Then: no error is returned
 	if err != nil {
 		t.Errorf("cmd.Execute() error = %v", err)