refactor(shell): remove PS1 metadata system and simplify command output handling

This commit removes the complex PS1 metadata system that was previously used to track command execution details like exit codes, working directories, and Python interpreter paths. The system proved to be unreliable across different shell environments and added unnecessary complexity.

Key changes:
- Removed CmdOutputMetadata class and all related PS1 prompt generation/parsing logic
- Simplified CommandResult class to focus on core command output without metadata
- Updated BashSession to handle command output more directly without PS1 parsing
- Improved output extraction logic to be more robust against shell decorations
- Added fast_test_mode flag to BashSessionExecutor for faster test execution
- Updated all tests to work with the simplified output handling system
- Removed unused imports and dependencies related to the old metadata system

The new approach provides more reliable command execution tracking while being simpler to maintain and more compatible across different shell environments.

Author: SDGLBL

mcp_claude_code/prompts/project_system.py

@@ -3,7 +3,7 @@
 Here is useful information about the environment you are running in:
 
 <env>
-Working directory: {working_directory}
+Working directory: {working_directory} (You need cd to this directory by yourself)
 Is directory a git repo: {is_git_repo}
 Platform: {platform}
 OS Version: {os_version}

mcp_claude_code/tools/filesystem/grep.py

@@ -386,7 +386,7 @@ async def call(
         pattern = params.get("pattern")
         path: str = params.get("path", ".")
         # Support both 'include' and legacy 'file_pattern' parameter for backward compatibility
-        include: str = params.get("include")
+        include: str = params.get("include") or params.get("file_pattern")
 
         # Validate required parameters for direct calls (not through MCP framework)
         if pattern is None:

mcp_claude_code/tools/shell/base.py

@@ -4,14 +4,11 @@
 including command execution, script running, and process management.
 """
 
-import json
-import re
 from abc import ABC, abstractmethod
 from enum import Enum
 from typing import Any, Self, final
 
 from fastmcp import Context as MCPContext
-from pydantic import BaseModel
 
 from mcp_claude_code.tools.common.base import BaseTool
 from mcp_claude_code.tools.common.permissions import PermissionManager
@@ -26,80 +23,6 @@ class BashCommandStatus(Enum):
     HARD_TIMEOUT = "hard_timeout"
 
 
-# PS1 metadata constants
-CMD_OUTPUT_PS1_BEGIN = "\n###PS1JSON###\n"
-CMD_OUTPUT_PS1_END = "\n###PS1END###"
-CMD_OUTPUT_METADATA_PS1_REGEX = re.compile(
-    f"^{CMD_OUTPUT_PS1_BEGIN.strip()}(.*?){CMD_OUTPUT_PS1_END.strip()}",
-    re.DOTALL | re.MULTILINE,
-)
-
-
-class CmdOutputMetadata(BaseModel):
-    """Rich metadata captured from PS1 prompts and command execution."""
-
-    exit_code: int = -1
-    pid: int = -1
-    username: str | None = None
-    hostname: str | None = None
-    working_dir: str | None = None
-    py_interpreter_path: str | None = None
-    prefix: str = ""  # Prefix to add to command output
-    suffix: str = ""  # Suffix to add to command output
-
-    @classmethod
-    def to_ps1_prompt(cls) -> str:
-        """Convert the required metadata into a PS1 prompt."""
-        prompt = CMD_OUTPUT_PS1_BEGIN
-        json_str = json.dumps(
-            {
-                "pid": "$!",
-                "exit_code": "$?",
-                "username": r"\u",
-                "hostname": r"\h",
-                "working_dir": r"$(pwd)",
-                "py_interpreter_path": r'$(which python 2>/dev/null || echo "")',
-            },
-            indent=2,
-        )
-        # Make sure we escape double quotes in the JSON string
-        # So that PS1 will keep them as part of the output
-        prompt += json_str.replace('"', r"\"")
-        prompt += CMD_OUTPUT_PS1_END + "\n"  # Ensure there's a newline at the end
-        return prompt
-
-    @classmethod
-    def matches_ps1_metadata(cls, string: str) -> list[re.Match[str]]:
-        """Find all PS1 metadata matches in a string."""
-        matches = []
-        for match in CMD_OUTPUT_METADATA_PS1_REGEX.finditer(string):
-            try:
-                json.loads(match.group(1).strip())  # Try to parse as JSON
-                matches.append(match)
-            except json.JSONDecodeError:
-                continue  # Skip if not valid JSON
-        return matches
-
-    @classmethod
-    def from_ps1_match(cls, match: re.Match[str]) -> Self:
-        """Extract the required metadata from a PS1 prompt."""
-        metadata = json.loads(match.group(1))
-        # Create a copy of metadata to avoid modifying the original
-        processed = metadata.copy()
-        # Convert numeric fields
-        if "pid" in metadata:
-            try:
-                processed["pid"] = int(float(str(metadata["pid"])))
-            except (ValueError, TypeError):
-                processed["pid"] = -1
-        if "exit_code" in metadata:
-            try:
-                processed["exit_code"] = int(float(str(metadata["exit_code"])))
-            except (ValueError, TypeError):
-                processed["exit_code"] = -1
-        return cls(**processed)
-
-
 @final
 class CommandResult:
     """Represents the result of a command execution with rich metadata."""
@@ -111,7 +34,6 @@ def __init__(
         stderr: str = "",
         error_message: str | None = None,
         session_id: str | None = None,
-        metadata: CmdOutputMetadata | None = None,
         status: BashCommandStatus = BashCommandStatus.COMPLETED,
         command: str = "",
     ):
@@ -123,7 +45,6 @@ def __init__(
             stderr: Standard error from the command
             error_message: Optional error message for failure cases
             session_id: Optional session ID used for the command execution
-            metadata: Rich metadata from command execution
             status: Command execution status
             command: The original command that was executed
         """
@@ -132,7 +53,6 @@ def __init__(
         self.stderr: str = stderr
         self.error_message: str | None = error_message
         self.session_id: str | None = session_id
-        self.metadata: CmdOutputMetadata = metadata or CmdOutputMetadata()
         self.status: BashCommandStatus = status
         self.command: str = command
 
@@ -180,7 +100,7 @@ def message(self) -> str:
         return f"Command `{self.command}` executed with exit code {self.return_code}."
 
     def format_output(self, include_exit_code: bool = True) -> str:
-        """Format the command output as a string with rich metadata.
+        """Format the command output as a string.
 
         Args:
             include_exit_code: Whether to include the exit code in the output
@@ -206,26 +126,9 @@ def format_output(self, include_exit_code: bool = True) -> str:
         if include_exit_code and (self.return_code != 0 or not self.error_message):
             result_parts.append(f"Exit code: {self.return_code}")
 
-        # Add working directory if available
-        if self.metadata.working_dir:
-            result_parts.append(f"Working directory: {self.metadata.working_dir}")
-
-        # Add Python interpreter if available
-        if self.metadata.py_interpreter_path:
-            result_parts.append(
-                f"Python interpreter: {self.metadata.py_interpreter_path}"
-            )
-
-        # Format the main output with prefix and suffix
-        output_content = self.stdout
-        if self.metadata.prefix:
-            output_content = self.metadata.prefix + output_content
-        if self.metadata.suffix:
-            output_content = output_content + self.metadata.suffix
-
         # Add stdout if present
-        if output_content:
-            result_parts.append(f"STDOUT:\n{output_content}")
+        if self.stdout:
+            result_parts.append(f"STDOUT:\n{self.stdout}")
 
         # Add stderr if present
         if self.stderr:
@@ -235,26 +138,10 @@ def format_output(self, include_exit_code: bool = True) -> str:
         return "\n\n".join(result_parts)
 
     def to_agent_observation(self) -> str:
-        """Format the result for agent consumption (similar to OpenHands)."""
+        """Format the result for agent consumption."""
         content = self.stdout
-        if self.metadata.prefix:
-            content = self.metadata.prefix + content
-        if self.metadata.suffix:
-            content = content + self.metadata.suffix
 
         additional_info: list[str] = []
-        if self.metadata.working_dir:
-            additional_info.append(
-                f"[Current working directory: {self.metadata.working_dir}]"
-            )
-        if self.metadata.py_interpreter_path:
-            additional_info.append(
-                f"[Python interpreter: {self.metadata.py_interpreter_path}]"
-            )
-        if self.metadata.exit_code != -1:
-            additional_info.append(
-                f"[Command finished with exit code {self.metadata.exit_code}]"
-            )
         if self.session_id:
             additional_info.append(f"[Session ID: {self.session_id}]")