Revamp subtool/command distinction

Signed-off-by: Edward Z. Yang <ezyang@mit.edu>

Author: ezyang

ARCHITECTURE.md

@@ -6,12 +6,12 @@ This document provides an overview of the architecture and design decisions of c
 
 The codemcp tool uses a TOML file (`codemcp.toml`) in the project root for configuration. This file has several sections:
 
-### Global Prompt
+### Project Prompt
 
-The `global_prompt` string is included in system prompts to provide project-specific instructions to Claude.
+The `project_prompt` string is included in system prompts to provide project-specific instructions to Claude.
 
 ```toml
-global_prompt = """
+project_prompt = """
 Project-specific instructions for Claude go here.
 """
 ```
@@ -45,7 +45,7 @@ codemcp provides several tools that Claude can use during interaction:
 When a project is initialized using `InitProject`, codemcp reads the `codemcp.toml` file and constructs a system prompt that includes:
 
 1. Default system instructions
-2. The project's `global_prompt`
+2. The project's `project_prompt`
 3. Instructions to use specific tools at appropriate times
 
 For example, if a format command is configured, the system prompt will include an instruction for Claude to use the Format tool when the task is complete.

README.md

@@ -109,7 +109,7 @@ branch from the default branch.  Suppose that codemcp is operating on
 Here are all the config options supported by `codemcp.toml`:
 
 ```toml
-global_prompt = """
+project_prompt = """
 Before beginning work on this feature, write a short haiku.  Do this only once.
 """
 
@@ -118,7 +118,7 @@ format = ["./run_format.sh"]
 test = ["./run_test.sh"]
 ```
 
-The `global_prompt` will be loaded when you initialize the project in chats.
+The `project_prompt` will be loaded when you initialize the project in chats.
 
 The `commands` section allows you to configure commands for specific tools:
 - `format`: used to format code according to project standards.  Formatting is

codemcp.toml

@@ -1,4 +1,4 @@
-global_prompt = """
+project_prompt = """
 Before beginning work on this feature, write a short haiku.  Do this only once.
 When you are done with your task, run format and lint commands.
 """

codemcp/main.py

@@ -21,7 +21,7 @@
 @mcp.tool()
 async def codemcp(
     ctx: Context,
-    command: str,
+    subtool: str,
     *,
     path: str | None = None,
     content: str | None = None,
@@ -33,7 +33,7 @@ async def codemcp(
     pattern: str | None = None,
     include: str | None = None,
     test_selector: str | None = None,
-    command_type: str | None = None,
+    command: str | None = None,
     arguments: list[str] | None = None,
     old_str: str | None = None,  # Added for backward compatibility
     new_str: str | None = None,  # Added for backward compatibility
@@ -44,11 +44,11 @@ async def codemcp(
     IMMEDIATELY follow before continuing.
 
     Arguments:
-      command: The command to run (InitProject, ...)
+      subtool: The subtool to run (InitProject, ...)
       path: The path to the file or directory to operate on
       ... (there are other arguments which are documented later)
     """
-    # Define expected parameters for each command
+    # Define expected parameters for each subtool
     expected_params = {
         "ReadFile": {"path", "offset", "limit"},
         "WriteFile": {"path", "content", "description"},
@@ -66,9 +66,9 @@ async def codemcp(
         "Grep": {"pattern", "path", "include"},
     }
 
-    # Check if command exists
-    if command not in expected_params:
-        return f"Unknown command: {command}. Available commands: {', '.join(expected_params.keys())}"
+    # Check if subtool exists
+    if subtool not in expected_params:
+        return f"Unknown subtool: {subtool}. Available subtools: {', '.join(expected_params.keys())}"
 
     # Get all provided non-None parameters
     provided_params = {
@@ -84,7 +84,7 @@ async def codemcp(
             "pattern": pattern,
             "include": include,
             "test_selector": test_selector,
-            "command_type": command_type,
+            "command": command,
             "arguments": arguments,
             # Include backward compatibility parameters
             "old_str": old_str,
@@ -94,67 +94,72 @@ async def codemcp(
     }
 
     # Check for unexpected parameters
-    unexpected_params = set(provided_params.keys()) - expected_params[command]
+    unexpected_params = set(provided_params.keys()) - expected_params[subtool]
     if unexpected_params:
-        return f"Error: Unexpected parameters for {command} command: {', '.join(unexpected_params)}"
+        return f"Error: Unexpected parameters for {subtool} subtool: {', '.join(unexpected_params)}"
 
-    # Now handle each command with its expected parameters
-    if command == "ReadFile":
+    # Now handle each subtool with its expected parameters
+    if subtool == "ReadFile":
         if path is None:
-            return "Error: path is required for ReadFile command"
+            return "Error: path is required for ReadFile subtool"
 
         return read_file_content(path, offset, limit)
 
-    if command == "WriteFile":
+    if subtool == "WriteFile":
         if path is None:
-            return "Error: path is required for WriteFile command"
+            return "Error: path is required for WriteFile subtool"
         if description is None:
-            return "Error: description is required for WriteFile command"
+            return "Error: description is required for WriteFile subtool"
 
         content_str = content or ""
         return write_file_content(path, content_str, description)
 
-    if command == "EditFile":
+    if subtool == "EditFile":
         if path is None:
-            return "Error: path is required for EditFile command"
+            return "Error: path is required for EditFile subtool"
         if description is None:
-            return "Error: description is required for EditFile command"
+            return "Error: description is required for EditFile subtool"
         if old_string is None and old_str is None:
             # TODO: I want telemetry to tell me when this occurs.
-            return "Error: Either old_string or old_str is required for EditFile command (use empty string for new file creation)"
+            return "Error: Either old_string or old_str is required for EditFile subtool (use empty string for new file creation)"
 
         # Accept either old_string or old_str (prefer old_string if both are provided)
         old_content = old_string or old_str or ""
         # Accept either new_string or new_str (prefer new_string if both are provided)
         new_content = new_string or new_str or ""
         return edit_file_content(path, old_content, new_content, None, description)
 
-    if command == "LS":
+    if subtool == "LS":
         if path is None:
-            return "Error: path is required for LS command"
+            return "Error: path is required for LS subtool"
 
         return ls_directory(path)
 
-    if command == "InitProject":
+    if subtool == "InitProject":
         if path is None:
-            return "Error: path is required for InitProject command"
+            return "Error: path is required for InitProject subtool"
 
         return init_project(path)
 
-    if command == "RunCommand":
+    if subtool == "RunCommand":
+        # When is something a command as opposed to a subtool?  They are
+        # basically the same thing, but commands are always USER defined.
+        # This means we shove them all in RunCommand so they are guaranteed
+        # not to conflict with codemcp's subtools.
+
         if path is None:
-            return "Error: path is required for RunCommand command"
-        if command_type is None:
-            return "Error: command_type is required for RunCommand command"
+            return "Error: path is required for RunCommand subtool"
+        if command is None:
+            return "Error: command is required for RunCommand subtool"
 
-        return run_command(path, command_type, arguments)
+        return run_command(path, command, arguments)
 
-    if command == "Grep":
+    if subtool == "Grep":
         if pattern is None:
-            return "Error: pattern is required for Grep command"
+            return "Error: pattern is required for Grep subtool"
 
         if path is None:
-            return "Error: path is required for Grep command"
+            return "Error: path is required for Grep subtool"
 
         try:
             result = grep_files(pattern, path, include)

codemcp/tools/init_project.py

@@ -38,7 +38,7 @@ def init_project(directory: str) -> str:
         directory: The directory path containing the codemcp.toml file
 
     Returns:
-        A string containing the system prompt plus any global_prompt from the config
+        A string containing the system prompt plus any project_prompt from the config
 
     """
     try:
@@ -55,7 +55,7 @@ def init_project(directory: str) -> str:
         # Build path to codemcp.toml file
         rules_file_path = os.path.join(full_dir_path, "codemcp.toml")
 
-        global_prompt = ""
+        project_prompt = ""
         command_help = ""
         command_docs = {}
         rules_config = {}
@@ -66,9 +66,9 @@ def init_project(directory: str) -> str:
                 with open(rules_file_path, "rb") as f:
                     rules_config = tomli.load(f)
 
-                # Extract global_prompt if it exists
-                if "global_prompt" in rules_config:
-                    global_prompt = rules_config["global_prompt"]
+                # Extract project_prompt if it exists
+                if "project_prompt" in rules_config:
+                    project_prompt = rules_config["project_prompt"]
 
                 # Extract commands and their documentation
                 command_list = rules_config.get("commands", {})
@@ -117,7 +117,7 @@ def init_project(directory: str) -> str:
 - If you intend to call multiple tools and there are no dependencies between the calls, make all of the independent calls in the same function_calls block.
 
 # codemcp tool
-The codemcp tool supports a number of subcommands which you should use to perform coding tasks.
+The codemcp tool supports a number of subtools which you should use to perform coding tasks.
 
 ## ReadFile path offset? limit?
 
@@ -201,7 +201,7 @@ def init_project(directory: str) -> str:
   Grep "function.*hello" /path/to/repo  # Find files containing functions with "hello" in their name
   Grep "console\\.log" /path/to/repo --include="*.js"  # Find JS files with console.log statements
 
-## RunCommand path command_type arguments?
+## RunCommand path command arguments?
 
 Runs a command.  This does NOT support arbitrary code execution, ONLY call
 with this set of valid commands: {command_help}
@@ -210,29 +210,21 @@ def init_project(directory: str) -> str:
 ## Summary
 
 Args:
-    command: The subcommand to execute (ReadFile, WriteFile, EditFile, LS, InitProject, RunCommand)
+    subtool: The subtool to execute (ReadFile, WriteFile, EditFile, LS, InitProject, RunCommand)
     path: The path to the file or directory to operate on
-    content: Content for WriteFile command
-    old_string: String to replace for EditFile command
-    new_string: Replacement string for EditFile command
-    offset: Line offset for ReadFile command
-    limit: Line limit for ReadFile command
+    content: Content for WriteFile subtool
+    old_string: String to replace for EditFile subtool
+    new_string: Replacement string for EditFile subtool
+    offset: Line offset for ReadFile subtool
+    limit: Line limit for ReadFile subtool
     description: Short description of the change (for WriteFile/EditFile)
-    arguments: A list of string arguments for RunCommand command
+    arguments: A list of string arguments for RunCommand subtool
 """
-        format_command_str = ""
-        # Check if format command is configured
-        if "commands" in rules_config and "format" in rules_config["commands"]:
-            format_command_str = (
-                "\n\nYou can also run code formatting using the Format tool."
-            )
-
-        # Combine system prompt, global prompt, and format command
+
+        # Combine system prompt, global prompt
         combined_prompt = system_prompt
-        if global_prompt:
-            combined_prompt += "\n\n" + global_prompt
-        if format_command_str:
-            combined_prompt += format_command_str
+        if project_prompt:
+            combined_prompt += "\n\n" + project_prompt
 
         return combined_prompt
     except Exception as e:

codemcp/tools/run_command.py

@@ -10,25 +10,25 @@
 
 
 def run_command(
-    project_dir: str, command_type: str, arguments: Optional[List[str]] = None
+    project_dir: str, command: str, arguments: Optional[List[str]] = None
 ) -> str:
     """Run a command that is configured in codemcp.toml.
 
     Args:
         project_dir: The directory path containing the codemcp.toml file
-        command_type: The type of command to run (e.g., "format", "lint", "test")
+        command: The type of command to run (e.g., "format", "lint", "test")
         arguments: Optional list of arguments to pass to the command
 
     Returns:
         A string containing the result of the command operation
     """
-    command_list = get_command_from_config(project_dir, command_type)
+    command_list = get_command_from_config(project_dir, command)
 
     # If arguments are provided, extend the command with them
     if arguments and command_list:
         command_list = command_list.copy()
         command_list.extend(arguments)
 
     return run_code_command(
-        project_dir, command_type, command_list, f"Auto-commit {command_type} changes"
+        project_dir, command, command_list, f"Auto-commit {command} changes"
     )

test/unit/test_init_project.py

@@ -44,10 +44,10 @@ def test_init_project_no_rules_file(self):
 
     def test_init_project_with_rules_file(self):
         """Test initializing a project with a codemcp.toml file."""
-        # Create a codemcp.toml file with a global_prompt
+        # Create a codemcp.toml file with a project_prompt
         rules_file_path = os.path.join(self.dir_path, "codemcp.toml")
         with open(rules_file_path, "w") as f:
-            f.write('global_prompt = "This is a custom global prompt."\n')
+            f.write('project_prompt = "This is a custom global prompt."\n')
 
         result = init_project(self.dir_path)
         # Check for a stable part of the system prompt and the custom global prompt
@@ -76,7 +76,7 @@ def test_init_project_invalid_toml(self):
         rules_file_path = os.path.join(self.dir_path, "codemcp.toml")
         with open(rules_file_path, "w") as f:
             f.write(
-                'global_prompt = "This is an invalid TOML file\n',
+                'project_prompt = "This is an invalid TOML file\n',
             )  # Missing closing quote
 
         result = init_project(self.dir_path)
@@ -88,7 +88,7 @@ def test_format_not_exposed_when_not_configured(self):
         rules_file_path = os.path.join(self.dir_path, "codemcp.toml")
         with open(rules_file_path, "w") as f:
             f.write(
-                'global_prompt = "This is a global prompt without formatter config."\n'
+                'project_prompt = "This is a global prompt without formatter config."\n'
             )
 
         result = init_project(self.dir_path)
@@ -101,7 +101,7 @@ def test_command_docs_exposed_when_configured(self):
         rules_file_path = os.path.join(self.dir_path, "codemcp.toml")
         with open(rules_file_path, "w") as f:
             f.write("""
-global_prompt = "This is a global prompt with command docs."
+project_prompt = "This is a global prompt with command docs."
 [commands]
 format = ["./run_format.sh"]
 [commands.test]
@@ -123,7 +123,7 @@ def test_multiple_command_docs(self):
         rules_file_path = os.path.join(self.dir_path, "codemcp.toml")
         with open(rules_file_path, "w") as f:
             f.write("""
-global_prompt = "This is a global prompt with multiple command docs."
+project_prompt = "This is a global prompt with multiple command docs."
 [commands]
 format = ["./run_format.sh"]
 [commands.test]
@@ -146,7 +146,7 @@ def test_no_command_docs(self):
         rules_file_path = os.path.join(self.dir_path, "codemcp.toml")
         with open(rules_file_path, "w") as f:
             f.write("""
-global_prompt = "This is a global prompt without command docs."
+project_prompt = "This is a global prompt without command docs."
 [commands]
 format = ["./run_format.sh"]
 test = ["./run_test.sh"]