feat: add codemcp run command to CLI

Add a `codemcp run COMMAND` to the cli which runs the command as defined in codemcp.toml the same way the RunCommand tool does it. However, do NOT reuse RunCommand's code (which is tuned for MCP usage), instead reimplement the subprocess call code correctly. stdin/stdout/stderr should be inherited. Do NOT do git commits. Just run the command.

```git-revs
292b66b  (Base revision)
0015442  Add 'run' command to CLI to execute commands from codemcp.toml without git commits
adba9fb  Add end-to-end tests for the new 'run' command
375e216  Auto-commit format changes
ed25816  Auto-commit lint changes
d536fef  Add sys import to test_run_command.py
4daf9cb  Update test_run_command_exists to use sys.executable
7e2369e  Update test_run_command_basic to use sys.executable
41ff40d  Update test_run_command_with_args to use sys.executable
83691fe  Update test_run_command_error_exit_code to use sys.executable
189dcdf  Update test_run_command_missing_command to use sys.executable
6f476f5  Return non-zero exit code when command is not found in codemcp.toml
HEAD     Return non-zero exit code for invalid command configuration
```

codemcp-id: 278-feat-add-codemcp-run-command-to-cli
ghstack-source-id: 4f384bd
Pull-Request-resolved: #271

Author: ezyang

codemcp/main.py

@@ -825,6 +825,99 @@ def init(path: str, python: bool) -> None:
     click.echo(result)
 
 
+@cli.command()
+@click.argument("command", type=str)
+@click.argument("args", nargs=-1)
+@click.option("--path", type=click.Path(), default=".", help="Project directory path")
+def run(command: str, args: tuple, path: str) -> None:
+    """Run a command defined in codemcp.toml without doing git commits.
+
+    The command should be defined in the [commands] section of codemcp.toml.
+    Any additional arguments are passed to the command.
+
+    Examples:
+        codemcp run format
+        codemcp run test path/to/test_file.py
+    """
+    import asyncio
+    import os
+    import subprocess
+
+    import tomli
+
+    from .common import normalize_file_path
+
+    # Handle the async nature of the function in a sync context
+    asyncio.get_event_loop()
+
+    # Normalize path
+    full_path = normalize_file_path(path)
+
+    # Check if path exists
+    if not os.path.exists(full_path):
+        click.echo(f"Error: Path {path} does not exist", err=True)
+        return
+
+    # Check if it's a directory
+    if not os.path.isdir(full_path):
+        click.echo(f"Error: Path {path} is not a directory", err=True)
+        return
+
+    # Check for codemcp.toml file
+    config_path = os.path.join(full_path, "codemcp.toml")
+    if not os.path.exists(config_path):
+        click.echo(f"Error: Config file not found: {config_path}", err=True)
+        return
+
+    # Load command from config
+    try:
+        with open(config_path, "rb") as f:
+            config = tomli.load(f)
+
+        if "commands" not in config or command not in config["commands"]:
+            click.echo(
+                f"Error: Command '{command}' not found in codemcp.toml", err=True
+            )
+            exit(1)  # Exit with error code 1
+
+        cmd_config = config["commands"][command]
+        cmd_list = None
+
+        # Handle both direct command lists and dictionaries with 'command' field
+        if isinstance(cmd_config, list):
+            cmd_list = cmd_config
+        elif isinstance(cmd_config, dict) and "command" in cmd_config:
+            cmd_list = cmd_config["command"]
+        else:
+            click.echo(
+                f"Error: Invalid command configuration for '{command}'", err=True
+            )
+            exit(1)  # Exit with error code 1
+
+        # Add additional arguments if provided
+        if args:
+            cmd_list = list(cmd_list) + list(args)
+
+        # Run the command with inherited stdin/stdout/stderr
+        process = subprocess.run(
+            cmd_list,
+            cwd=full_path,
+            stdin=None,  # inherit
+            stdout=None,  # inherit
+            stderr=None,  # inherit
+            text=True,
+            check=False,  # Don't raise exception on non-zero exit codes
+        )
+
+        # Return the exit code
+        if process.returncode != 0:
+            exit(process.returncode)
+
+    except Exception as e:
+        click.echo(f"Error executing command: {e}", err=True)
+        exit(1)
+
+
 def create_sse_app(allowed_origins: Optional[List[str]] = None) -> Starlette:
     """Create an SSE app with the MCP server.
 

e2e/test_run_command.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+
+import os
+import subprocess
+import sys
+import tempfile
+
+import pytest
+
+from codemcp.main import init_codemcp_project
+
+
+@pytest.fixture
+def project_dir():
+    """Create a temporary project directory with a simple codemcp.toml configuration."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Initialize the project
+        init_codemcp_project(temp_dir)
+
+        # Create a codemcp.toml file with test commands
+        config_path = os.path.join(temp_dir, "codemcp.toml")
+        with open(config_path, "w") as f:
+            f.write("""
+[commands]
+echo = ["echo", "Hello World"]
+list = ["ls", "-la"]
+exit_with_error = ["bash", "-c", "exit 1"]
+            """)
+
+        yield temp_dir
+
+
+def test_run_command_exists():
+    """Test that the 'run' command exists and is listed in help output."""
+    result = subprocess.run(
+        [sys.executable, "-m", "codemcp", "--help"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert "run" in result.stdout
+
+
+def test_run_command_basic(project_dir):
+    """Test running a basic command that outputs to stdout."""
+    result = subprocess.run(
+        [sys.executable, "-m", "codemcp", "run", "echo", "--path", project_dir],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert "Hello World" in result.stdout
+
+
+def test_run_command_with_args(project_dir):
+    """Test running a command with additional arguments that override defaults."""
+    # Create a file to list
+    test_file = os.path.join(project_dir, "test_file.txt")
+    with open(test_file, "w") as f:
+        f.write("test content")
+
+    result = subprocess.run(
+        [sys.executable, "-m", "codemcp", "run", "list", test_file, "--path", project_dir],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert "test_file.txt" in result.stdout
+
+
+def test_run_command_error_exit_code(project_dir):
+    """Test that error exit codes from the command are propagated."""
+    # This should return a non-zero exit code
+    process = subprocess.run(
+        [sys.executable, "-m", "codemcp", "run", "exit_with_error", "--path", project_dir],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert process.returncode != 0
+
+
+def test_run_command_missing_command(project_dir):
+    """Test running a command that doesn't exist in codemcp.toml."""
+    process = subprocess.run(
+        [sys.executable, "-m", "codemcp", "run", "nonexistent", "--path", project_dir],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert process.returncode != 0
+    assert "not found in codemcp.toml" in process.stderr