feat: add 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.

```git-revs
ef0b2d8  (Base revision)
b00e0fa  Add run command to CLI
51594c3  Add import for get_command_from_config
9ad7dd6  Add end-to-end test for run command CLI
4253b3d  Auto-commit format changes
875d7e5  Auto-commit lint changes
402a071  Update the test assertions to match the actual error message
29ae4e6  Update CLI run command to stream output to terminal in real-time
62d2cd0  Update test to use --no-stream flag for consistent testing
980e370  Update test_run_command_with_args to use --no-stream flag
2efae9a  Update test_run_command_not_found to use --no-stream flag
dd4060e  Update test_run_command_empty_definition to use --no-stream flag
8601a6a  Add test for streaming mode
d2e92b9  Fix test for streaming mode to work with proper mocking
88fd447  Auto-commit format changes
c6c1813  Auto-commit lint changes
125536b  Fix test to prevent hanging in pytest by ensuring proper cleanup of mocks
ff9a32b  Add proper process cleanup on keyboard interrupt
6972726  Fix coroutine warning by properly mocking asyncio.run
285cf01  Complete rewrite of test file to properly mock async functions and prevent warnings
a588d61  Auto-commit format changes
HEAD     Auto-commit lint changes
```

codemcp-id: 277-feat-add-run-command-to-cli
ghstack-source-id: 391e2b3
Pull-Request-resolved: #270

Author: ezyang

codemcp/main.py

@@ -14,6 +14,7 @@
 from starlette.applications import Starlette
 from starlette.routing import Mount
 
+from .code_command import get_command_from_config
 from .common import normalize_file_path
 from .git_query import get_current_commit_hash
 from .tools.chmod import chmod
@@ -861,6 +862,149 @@ def run() -> None:
     mcp.run()
 
 
+@cli.command()
+@click.argument("command", type=str, required=True)
+@click.argument("args", nargs=-1, type=click.UNPROCESSED)
+@click.option(
+    "--path",
+    type=click.Path(exists=True),
+    default=".",
+    help="Path to the project directory (default: current directory)",
+)
+@click.option(
+    "--no-stream",
+    is_flag=True,
+    help="Don't stream output to the terminal in real-time",
+)
+def run(command: str, args: List[str], path: str, no_stream: bool) -> None:
+    """Run a command defined in codemcp.toml.
+
+    COMMAND: The name of the command to run as defined in codemcp.toml
+    ARGS: Optional arguments to pass to the command
+    """
+    import asyncio
+    import subprocess
+    from uuid import uuid4
+
+    # Configure logging
+    configure_logging()
+
+    # Convert args tuple to a space-separated string
+    args_str = " ".join(args) if args else None
+
+    # Generate a temporary chat ID for this command
+    chat_id = str(uuid4())
+
+    # Convert to absolute path if needed
+    project_dir = normalize_file_path(path)
+
+    try:
+        # Check if command exists in config
+        command_list = get_command_from_config(project_dir, command)
+        if not command_list:
+            click.echo(
+                f"Error: Command '{command}' not found in codemcp.toml", err=True
+            )
+            return
+
+        if no_stream:
+            # Use the standard non-streaming implementation
+            result = asyncio.run(run_command(project_dir, command, args_str, chat_id))
+            click.echo(result)
+        else:
+            # Check if directory is in a git repository and commit any pending changes
+            from .git import commit_changes, is_git_repository
+
+            is_git_repo = asyncio.run(is_git_repository(project_dir))
+            if is_git_repo:
+                logging.info(f"Committing any pending changes before {command}")
+                commit_result = asyncio.run(
+                    commit_changes(
+                        project_dir,
+                        f"Snapshot before auto-{command}",
+                        chat_id,
+                        commit_all=True,
+                    )
+                )
+                if not commit_result[0]:
+                    logging.warning(
+                        f"Failed to commit pending changes: {commit_result[1]}"
+                    )
+
+            # Extend the command with arguments if provided
+            full_command = command_list.copy()
+            if args_str:
+                import shlex
+
+                parsed_args = shlex.split(args_str)
+                full_command.extend(parsed_args)
+
+            # Stream output to the terminal in real-time
+            click.echo(f"Running command: {' '.join(str(c) for c in full_command)}")
+
+            # Run the command with live output streaming
+            try:
+                process = subprocess.Popen(
+                    full_command,
+                    cwd=project_dir,
+                    stdout=None,  # Use parent's stdout/stderr (the terminal)
+                    stderr=None,
+                    text=True,
+                    bufsize=0,  # Unbuffered
+                )
+
+                try:
+                    # Wait for the process to complete
+                    exit_code = process.wait()
+                except KeyboardInterrupt:
+                    # Handle Ctrl+C gracefully
+                    process.terminate()
+                    try:
+                        process.wait(timeout=1)
+                    except subprocess.TimeoutExpired:
+                        process.kill()
+                    click.echo("\nProcess terminated by user.")
+                    return
+
+                # Check if command succeeded
+                if exit_code == 0:
+                    # If it's a git repo, commit any changes made by the command
+                    if is_git_repo:
+                        from .code_command import check_for_changes
+
+                        has_changes = asyncio.run(check_for_changes(project_dir))
+                        if has_changes:
+                            logging.info(
+                                f"Changes detected after {command}, committing"
+                            )
+                            success, commit_result_message = asyncio.run(
+                                commit_changes(
+                                    project_dir,
+                                    f"Auto-commit {command} changes",
+                                    chat_id,
+                                    commit_all=True,
+                                )
+                            )
+
+                            if success:
+                                click.echo(
+                                    f"\nCode {command} successful and changes committed."
+                                )
+                            else:
+                                click.echo(
+                                    f"\nCode {command} successful but failed to commit changes."
+                                )
+                                click.echo(f"Commit error: {commit_result_message}")
+                    else:
+                        click.echo(f"\nCode {command} successful.")
+                else:
+                    click.echo(f"\nCommand failed with exit code {exit_code}.")
+            except Exception as cmd_error:
+                click.echo(f"Error during command execution: {cmd_error}", err=True)
+    except Exception as e:
+        click.echo(f"Error running command: {e}", err=True)
+
+
 @cli.command()
 @click.option(
     "--host",

e2e/test_run_command.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+
+import subprocess
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+import codemcp.git
+from codemcp.main import cli
+
+
+# Create non-async mock functions to replace async ones
+def mock_is_git_repository(*args, **kwargs):
+    return False
+
+
+def mock_check_for_changes(*args, **kwargs):
+    return False
+
+
+def mock_commit_changes(*args, **kwargs):
+    return (True, "Mock commit message")
+
+
+# Patch the modules directly
+codemcp.git.is_git_repository = mock_is_git_repository
+
+
+@pytest.fixture
+def test_project():
+    """Create a temporary directory with a codemcp.toml file for testing."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        # Create a codemcp.toml file with test commands
+        config_path = Path(tmp_dir) / "codemcp.toml"
+        with open(config_path, "w") as f:
+            f.write("""[commands]
+echo = ["echo", "Hello from codemcp run!"]
+echo_args = ["echo"]
+invalid = []
+""")
+
+        # Initialize a git repository
+        subprocess.run(["git", "init"], cwd=tmp_dir, check=True, capture_output=True)
+        subprocess.run(
+            ["git", "config", "user.name", "Test User"], cwd=tmp_dir, check=True
+        )
+        subprocess.run(
+            ["git", "config", "user.email", "[email protected]"], cwd=tmp_dir, check=True
+        )
+        subprocess.run(["git", "add", "codemcp.toml"], cwd=tmp_dir, check=True)
+        subprocess.run(
+            ["git", "commit", "-m", "Initial commit"], cwd=tmp_dir, check=True
+        )
+
+        yield tmp_dir
+
+
+def test_run_command_success(test_project):
+    """Test running a command successfully."""
+    runner = CliRunner()
+    result = runner.invoke(cli, ["run", "echo", "--path", test_project, "--no-stream"])
+
+    assert result.exit_code == 0
+    assert "Hello from codemcp run!" in result.output
+    assert "Code echo successful" in result.output
+
+
+def test_run_command_with_args(test_project):
+    """Test running a command with arguments."""
+    runner = CliRunner()
+    result = runner.invoke(
+        cli,
+        [
+            "run",
+            "echo_args",
+            "Test",
+            "argument",
+            "string",
+            "--path",
+            test_project,
+            "--no-stream",
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert "Test argument string" in result.output
+    assert "Code echo_args successful" in result.output
+
+
+def test_run_command_not_found(test_project):
+    """Test running a command that doesn't exist in config."""
+    runner = CliRunner()
+    result = runner.invoke(
+        cli, ["run", "nonexistent", "--path", test_project, "--no-stream"]
+    )
+
+    assert "Error: Command 'nonexistent' not found in codemcp.toml" in result.output
+
+
+def test_run_command_empty_definition(test_project):
+    """Test running a command with an empty definition."""
+    runner = CliRunner()
+    result = runner.invoke(
+        cli, ["run", "invalid", "--path", test_project, "--no-stream"]
+    )
+
+    assert "Error: Command 'invalid' not found in codemcp.toml" in result.output
+
+
+@patch("codemcp.git.is_git_repository", mock_is_git_repository)
+@patch("codemcp.code_command.check_for_changes", mock_check_for_changes)
+@patch("codemcp.git.commit_changes", mock_commit_changes)
+@patch(
+    "asyncio.run", lambda x: False
+)  # Mock asyncio.run to return False for all coroutines
+def test_run_command_stream_mode(test_project):
+    """Test running a command with streaming mode."""
+    import subprocess
+
+    # Create a mock for subprocess.Popen
+    mock_process = MagicMock()
+    mock_process.returncode = 0
+    mock_process.wait.return_value = 0
+
+    # Keep track of Popen calls
+    popen_calls = []
+
+    # Create a safe replacement for Popen that won't leave hanging processes
+    original_popen = subprocess.Popen
+
+    def mock_popen(cmd, **kwargs):
+        if (
+            isinstance(cmd, list)
+            and cmd[0] == "echo"
+            and "Hello from codemcp run!" in cmd
+        ):
+            popen_calls.append((cmd, kwargs))
+            return mock_process
+        # For any other command, create a safe echo process with proper cleanup
+        return original_popen(
+            ["echo", "Test"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+
+    with patch("subprocess.Popen", mock_popen):
+        # Run the command with isolated stdin/stdout to prevent interference
+        runner = CliRunner(mix_stderr=False)
+        runner.invoke(cli, ["run", "echo", "--path", test_project])
+
+        # Check that our command was executed with the right parameters
+        assert any(cmd == ["echo", "Hello from codemcp run!"] for cmd, _ in popen_calls)
+
+        # Find the call for our echo command
+        for cmd, kwargs in popen_calls:
+            if cmd == ["echo", "Hello from codemcp run!"]:
+                # Verify streaming parameters
+                assert kwargs.get("stdout") is None
+                assert kwargs.get("stderr") is None
+                assert kwargs.get("bufsize") == 0