Add -N/--new and -e/--editor options to edit command

Adds two new arguments to enhance the edit command functionality:
- -N/--new: Interactive creation of new server configurations
- -e/--editor: Opens global config file in external editor

Also fixes help formatting and config path reference bug.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: niechen

src/mcpm/commands/edit.py

@@ -2,6 +2,8 @@
 Edit command for modifying server configurations
 """
 
+import os
+import subprocess
 import sys
 from typing import Any, Dict, Optional
 
@@ -19,8 +21,10 @@
 
 
 @click.command(name="edit", context_settings=dict(help_option_names=["-h", "--help"]))
-@click.argument("server_name")
-def edit(server_name):
+@click.argument("server_name", required=False)
+@click.option("-N", "--new", is_flag=True, help="Create a new server configuration")
+@click.option("-e", "--editor", is_flag=True, help="Open global config in external editor")
+def edit(server_name, new, editor):
     """Edit a server configuration.
 
     Opens an interactive form editor that allows you to:
@@ -30,15 +34,33 @@ def edit(server_name):
     
     Examples:
     
-    \\b
-        mcpm edit time                                    # Interactive form
+        mcpm edit time                                    # Edit existing server
         mcpm edit agentkit                                # Edit agentkit server
-        mcpm edit remote-api                              # Edit remote server
+        mcpm edit -N                                      # Create new server
+        mcpm edit -e                                      # Open global config in editor
     """
+    # Handle editor mode
+    if editor:
+        _open_global_config_in_editor()
+        return 0
+    
+    # Handle new server mode
+    if new:
+        if server_name:
+            print_error("Cannot specify both server name and --new flag", "Use either 'mcpm edit <server>' or 'mcpm edit --new'")
+            raise click.ClickException("Cannot specify both server name and --new flag")
+        _create_new_server()
+        return 0
+    
+    # Require server name for editing existing servers
+    if not server_name:
+        print_error("Server name is required", "Use 'mcpm edit <server>', 'mcpm edit --new', or 'mcpm edit --editor'")
+        raise click.ClickException("Server name is required")
+        
     # Get the existing server
     server_config = global_config_manager.get_server(server_name)
     if not server_config:
-        print_error(f"Server '{server_name}' not found", "Run 'mcpm ls' to see available servers")
+        print_error(f"Server '{server_name}' not found", "Run 'mcpm ls' to see available servers or use 'mcpm edit --new' to create one")
         raise click.ClickException(f"Server '{server_name}' not found")
 
     # Display current configuration
@@ -287,4 +309,226 @@ def apply_interactive_changes(server_config, interactive_result):
                     key, value = header_pair.split("=", 1)
                     server_config.headers[key.strip()] = value.strip()
 
-    return True
+    return True
+
+
+def _open_global_config_in_editor():
+    """Open the global MCPM configuration file in the default editor."""
+    try:
+        # Get the global config file path
+        config_path = global_config_manager.config_path
+        
+        if not os.path.exists(config_path):
+            console.print("[yellow]No global configuration file found.[/]")
+            console.print("[dim]Install a server first with 'mcpm install <server>' to create the config file.[/]")
+            return
+            
+        console.print("[bold green]Opening global MCPM configuration in your default editor...[/]")
+
+        # Use appropriate command based on platform
+        if os.name == "nt":  # Windows
+            os.startfile(config_path)
+        elif os.name == "posix":  # macOS and Linux
+            subprocess.run(["open", config_path] if os.uname().sysname == "Darwin" else ["xdg-open", config_path])
+
+        console.print(f"[italic]Global config file: {config_path}[/]")
+        console.print("[dim]After editing, restart any running MCP servers for changes to take effect.[/]")
+    except Exception as e:
+        print_error("Error opening editor", str(e))
+        console.print(f"You can manually edit the file at: {config_path}")
+
+
+def _create_new_server():
+    """Create a new server configuration interactively."""
+    console.print("[bold green]Create New Server Configuration[/]")
+    console.print("[dim]Type your answers, press Enter to confirm each field, ESC to cancel[/]")
+    console.print()
+
+    try:
+        result = _interactive_new_server_form()
+
+        if result is None:
+            console.print("[yellow]Interactive editing not available in this environment[/]")
+            console.print("[dim]This command requires a terminal for interactive input[/]")
+            return 1
+
+        if result.get("cancelled", True):
+            console.print("[yellow]Server creation cancelled[/]")
+            return 0
+
+        # Check if server name already exists
+        server_name = result["answers"]["name"]
+        if global_config_manager.get_server(server_name):
+            console.print(f"[red]Error: Server '[bold]{server_name}[/]' already exists[/]")
+            return 1
+
+        # Create the server config based on type
+        server_type = result["answers"]["type"]
+        if server_type == "stdio":
+            server_config = STDIOServerConfig(
+                name=server_name,
+                command=result["answers"]["command"],
+                args=[arg.strip() for arg in result["answers"]["args"].split(",") if arg.strip()] if result["answers"]["args"] else [],
+                env={}
+            )
+            
+            # Parse environment variables
+            if result["answers"]["env"]:
+                for env_pair in result["answers"]["env"].split(","):
+                    if "=" in env_pair:
+                        key, value = env_pair.split("=", 1)
+                        server_config.env[key.strip()] = value.strip()
+        else:  # remote
+            server_config = RemoteServerConfig(
+                name=server_name,
+                url=result["answers"]["url"],
+                headers={}
+            )
+            
+            # Parse headers
+            if result["answers"]["headers"]:
+                for header_pair in result["answers"]["headers"].split(","):
+                    if "=" in header_pair:
+                        key, value = header_pair.split("=", 1)
+                        server_config.headers[key.strip()] = value.strip()
+
+        # Save the new server
+        try:
+            global_config_manager.add_server(server_config)
+            console.print(f"[green]✅ Successfully created server '[cyan]{server_name}[/]'[/]")
+        except Exception as e:
+            print_error("Failed to save new server", str(e))
+            raise click.ClickException(f"Failed to save new server: {e}")
+
+        return 0
+
+    except Exception as e:
+        console.print(f"[red]Error creating new server: {e}[/]")
+        return 1
+
+
+def _interactive_new_server_form() -> Optional[Dict[str, Any]]:
+    """Interactive form for creating a new server."""
+    # Check if we're in a terminal that supports interactive input
+    if not sys.stdin.isatty():
+        return None
+
+    try:
+        # Clear any remaining command line arguments to avoid conflicts
+        original_argv = sys.argv[:]
+        sys.argv = [sys.argv[0]]  # Keep only script name
+
+        try:
+            answers = {}
+            
+            # Server name - required
+            answers["name"] = inquirer.text(
+                message="Server name:",
+                validate=lambda text: len(text.strip()) > 0 and not text.strip() != text.strip(),
+                invalid_message="Server name cannot be empty or contain leading/trailing spaces",
+                keybindings={"interrupt": [{"key": "escape"}]},
+            ).execute()
+
+            # Server type
+            answers["type"] = inquirer.select(
+                message="Server type:",
+                choices=[
+                    {"name": "STDIO Server (local command)", "value": "stdio"},
+                    {"name": "Remote Server (HTTP/SSE)", "value": "remote"},
+                ],
+                keybindings={"interrupt": [{"key": "escape"}]},
+            ).execute()
+
+            if answers["type"] == "stdio":
+                # STDIO Server configuration
+                console.print("\n[cyan]STDIO Server Configuration[/]")
+                
+                answers["command"] = inquirer.text(
+                    message="Command to execute:",
+                    validate=lambda text: len(text.strip()) > 0,
+                    invalid_message="Command cannot be empty",
+                    keybindings={"interrupt": [{"key": "escape"}]},
+                ).execute()
+
+                answers["args"] = inquirer.text(
+                    message="Arguments (comma-separated):",
+                    instruction="(Leave empty for no arguments)",
+                    keybindings={"interrupt": [{"key": "escape"}]},
+                ).execute()
+
+                answers["env"] = inquirer.text(
+                    message="Environment variables (KEY=value,KEY2=value2):",
+                    instruction="(Leave empty for no environment variables)",
+                    keybindings={"interrupt": [{"key": "escape"}]},
+                ).execute()
+
+            else:  # remote
+                # Remote Server configuration
+                console.print("\n[cyan]Remote Server Configuration[/]")
+                
+                answers["url"] = inquirer.text(
+                    message="Server URL:",
+                    validate=lambda text: text.strip().startswith(("http://", "https://")) if text.strip() else False,
+                    invalid_message="URL must start with http:// or https://",
+                    keybindings={"interrupt": [{"key": "escape"}]},
+                ).execute()
+
+                answers["headers"] = inquirer.text(
+                    message="HTTP headers (KEY=value,KEY2=value2):",
+                    instruction="(Leave empty for no custom headers)",
+                    keybindings={"interrupt": [{"key": "escape"}]},
+                ).execute()
+
+            # Confirmation
+            console.print("\n[bold]Summary of new server:[/]")
+            console.print(f"Name: [cyan]{answers['name']}[/]")
+            console.print(f"Type: [cyan]{answers['type'].upper()}[/]")
+            
+            if answers["type"] == "stdio":
+                console.print(f"Command: [cyan]{answers['command']}[/]")
+                new_args = [arg.strip() for arg in answers['args'].split(",") if arg.strip()] if answers['args'] else []
+                console.print(f"Arguments: [cyan]{new_args}[/]")
+                
+                new_env = {}
+                if answers['env']:
+                    for env_pair in answers['env'].split(","):
+                        if "=" in env_pair:
+                            key, value = env_pair.split("=", 1)
+                            new_env[key.strip()] = value.strip()
+                console.print(f"Environment: [cyan]{new_env}[/]")
+                
+            else:  # remote
+                console.print(f"URL: [cyan]{answers['url']}[/]")
+                
+                new_headers = {}
+                if answers['headers']:
+                    for header_pair in answers['headers'].split(","):
+                        if "=" in header_pair:
+                            key, value = header_pair.split("=", 1)
+                            new_headers[key.strip()] = value.strip()
+                console.print(f"Headers: [cyan]{new_headers}[/]")
+
+            confirm = inquirer.confirm(
+                message="Create this server?",
+                default=True,
+                keybindings={"interrupt": [{"key": "escape"}]},
+            ).execute()
+
+            if not confirm:
+                return {"cancelled": True}
+
+        finally:
+            # Restore original argv
+            sys.argv = original_argv
+
+        return {
+            "cancelled": False,
+            "answers": answers,
+        }
+
+    except (KeyboardInterrupt, EOFError):
+        console.print("\n[yellow]Operation cancelled[/]")
+        return {"cancelled": True}
+    except Exception as e:
+        console.print(f"[red]Error running interactive form: {e}[/]")
+        return None

tests/test_edit.py

@@ -60,4 +60,37 @@ def test_edit_command_help():
     assert "Edit a server configuration" in result.output
     assert "Opens an interactive form editor" in result.output
     assert "mcpm edit time" in result.output
-    assert "Interactive form" in result.output
+    assert "mcpm edit -N" in result.output
+    assert "mcpm edit -e" in result.output
+    assert "--new" in result.output
+    assert "--editor" in result.output
+
+
+def test_edit_editor_flag(monkeypatch):
+    """Test the -e/--editor flag."""
+    mock_global_config = Mock()
+    mock_global_config.config_path = "/tmp/test_servers.json"
+    monkeypatch.setattr("mcpm.commands.edit.global_config_manager", mock_global_config)
+    
+    # Mock os.path.exists to return True
+    monkeypatch.setattr("os.path.exists", lambda path: True)
+    
+    # Mock subprocess.run to avoid actually opening an editor
+    mock_subprocess = Mock()
+    monkeypatch.setattr("subprocess.run", mock_subprocess)
+    
+    # Mock os.uname to simulate macOS
+    mock_uname = Mock()
+    mock_uname.sysname = "Darwin"
+    monkeypatch.setattr("os.uname", lambda: mock_uname)
+
+    runner = CliRunner()
+    result = runner.invoke(edit, ["-e"])
+
+    assert result.exit_code == 0
+    assert "Opening global MCPM configuration in your default editor" in result.output
+    assert "/tmp/test_servers.json" in result.output
+    assert "After editing, restart any running MCP servers" in result.output
+    
+    # Verify subprocess.run was called with correct arguments
+    mock_subprocess.assert_called_once_with(["open", "/tmp/test_servers.json"])