openhands 0.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

openhands/tools/execute_bash/utils/command.py

@@ -1,150 +0,0 @@
-import re
-import traceback
-from typing import Any
-
-import bashlex
-from bashlex.errors import ParsingError
-
-from openhands.sdk.logger import get_logger
-
-
-logger = get_logger(__name__)
-
-
-def split_bash_commands(commands: str) -> list[str]:
-    if not commands.strip():
-        return [""]
-    try:
-        parsed = bashlex.parse(commands)
-    except (
-        ParsingError,
-        NotImplementedError,
-        TypeError,
-        AttributeError,
-    ):
-        # Added AttributeError to catch 'str' object has no attribute 'kind' error
-        # (issue #8369)
-        logger.debug(
-            f"Failed to parse bash commands\n[input]: {commands}\n[warning]: "
-            f"{traceback.format_exc()}\nThe original command will be returned as is."
-        )
-        # If parsing fails, return the original commands
-        return [commands]
-
-    result: list[str] = []
-    last_end = 0
-
-    for node in parsed:
-        start, end = node.pos
-
-        # Include any text between the last command and this one
-        if start > last_end:
-            between = commands[last_end:start]
-            logger.debug(f"BASH PARSING between: {between}")
-            if result:
-                result[-1] += between.rstrip()
-            elif between.strip():
-                # THIS SHOULD NOT HAPPEN
-                result.append(between.rstrip())
-
-        # Extract the command, preserving original formatting
-        command = commands[start:end].rstrip()
-        logger.debug(f"BASH PARSING command: {command}")
-        result.append(command)
-
-        last_end = end
-
-    # Add any remaining text after the last command to the last command
-    remaining = commands[last_end:].rstrip()
-    logger.debug(f"BASH PARSING remaining: {remaining}")
-    if last_end < len(commands) and result:
-        result[-1] += remaining
-        logger.debug(f"BASH PARSING result[-1] += remaining: {result[-1]}")
-    elif last_end < len(commands):
-        if remaining:
-            result.append(remaining)
-            logger.debug(f"BASH PARSING result.append(remaining): {result[-1]}")
-    return result
-
-
-def escape_bash_special_chars(command: str) -> str:
-    r"""Escapes characters that have different interpretations in bash vs python.
-    Specifically handles escape sequences like \;, \|, \&, etc.
-    """
-    if command.strip() == "":
-        return ""
-
-    try:
-        parts = []
-        last_pos = 0
-
-        def visit_node(node: Any) -> None:
-            nonlocal last_pos
-            if (
-                node.kind == "redirect"
-                and hasattr(node, "heredoc")
-                and node.heredoc is not None
-            ):
-                # We're entering a heredoc - preserve everything as-is until we see EOF
-                # Store the heredoc end marker (usually 'EOF' but could be different)
-                between = command[last_pos : node.pos[0]]
-                parts.append(between)
-                # Add the heredoc start marker
-                parts.append(command[node.pos[0] : node.heredoc.pos[0]])
-                # Add the heredoc content as-is
-                parts.append(command[node.heredoc.pos[0] : node.heredoc.pos[1]])
-                last_pos = node.pos[1]
-                return
-
-            if node.kind == "word":
-                # Get the raw text between the last position and current word
-                between = command[last_pos : node.pos[0]]
-                word_text = command[node.pos[0] : node.pos[1]]
-
-                # Add the between text, escaping special characters
-                between = re.sub(r"\\([;&|><])", r"\\\\\1", between)
-                parts.append(between)
-
-                # Check if word_text is a quoted string or command substitution
-                if (
-                    (word_text.startswith('"') and word_text.endswith('"'))
-                    or (word_text.startswith("'") and word_text.endswith("'"))
-                    or (word_text.startswith("$(") and word_text.endswith(")"))
-                    or (word_text.startswith("`") and word_text.endswith("`"))
-                ):
-                    # Preserve quoted strings, command substitutions, and heredoc
-                    # content as-is
-                    parts.append(word_text)
-                else:
-                    # Escape special chars in unquoted text
-                    word_text = re.sub(r"\\([;&|><])", r"\\\\\1", word_text)
-                    parts.append(word_text)
-
-                last_pos = node.pos[1]
-                return
-
-            # Visit child nodes
-            if hasattr(node, "parts"):
-                for part in node.parts:
-                    visit_node(part)
-
-        # Process all nodes in the AST
-        nodes = list(bashlex.parse(command))
-        for node in nodes:
-            between = command[last_pos : node.pos[0]]
-            between = re.sub(r"\\([;&|><])", r"\\\\\1", between)
-            parts.append(between)
-            last_pos = node.pos[0]
-            visit_node(node)
-
-        # Handle any remaining text after the last word
-        remaining = command[last_pos:]
-        parts.append(remaining)
-        return "".join(parts)
-    except (ParsingError, NotImplementedError, TypeError):
-        logger.debug(
-            f"Failed to parse bash commands for special characters escape\n[input]: "
-            f"{command}\n[warning]: {traceback.format_exc()}\nThe original command "
-            f"will be returned as is."
-        )
-        return command

openhands/tools/str_replace_editor/__init__.py

@@ -1,17 +0,0 @@
-from openhands.tools.str_replace_editor.definition import (
-    FileEditorTool,
-    StrReplaceEditorAction,
-    StrReplaceEditorObservation,
-    str_replace_editor_tool,
-)
-from openhands.tools.str_replace_editor.impl import FileEditorExecutor, file_editor
-
-
-__all__ = [
-    "str_replace_editor_tool",
-    "StrReplaceEditorAction",
-    "StrReplaceEditorObservation",
-    "file_editor",
-    "FileEditorExecutor",
-    "FileEditorTool",
-]

openhands/tools/str_replace_editor/definition.py

@@ -1,158 +0,0 @@
-"""String replace editor tool implementation."""
-
-from typing import Literal
-
-from pydantic import Field
-
-from openhands.sdk.llm import ImageContent, TextContent
-from openhands.sdk.tool import ActionBase, ObservationBase, Tool, ToolAnnotations
-
-
-CommandLiteral = Literal["view", "create", "str_replace", "insert", "undo_edit"]
-
-
-class StrReplaceEditorAction(ActionBase):
-    """Schema for string replace editor operations."""
-
-    command: CommandLiteral = Field(
-        description="The commands to run. Allowed options are: `view`, `create`, "
-        "`str_replace`, `insert`, `undo_edit`."
-    )
-    path: str = Field(
-        description="Absolute path to file or directory, e.g. `/workspace/file.py` "
-        "or `/workspace`."
-    )
-    file_text: str | None = Field(
-        default=None,
-        description="Required parameter of `create` command, with the content of "
-        "the file to be created.",
-    )
-    old_str: str | None = Field(
-        default=None,
-        description="Required parameter of `str_replace` command containing the "
-        "string in `path` to replace.",
-    )
-    new_str: str | None = Field(
-        default=None,
-        description="Optional parameter of `str_replace` command containing the "
-        "new string (if not given, no string will be added). Required parameter "
-        "of `insert` command containing the string to insert.",
-    )
-    insert_line: int | None = Field(
-        default=None,
-        description="Required parameter of `insert` command. The `new_str` will "
-        "be inserted AFTER the line `insert_line` of `path`.",
-    )
-    view_range: list[int] | None = Field(
-        default=None,
-        description="Optional parameter of `view` command when `path` points to a "
-        "file. If none is given, the full file is shown. If provided, the file "
-        "will be shown in the indicated line number range, e.g. [11, 12] will "
-        "show lines 11 and 12. Indexing at 1 to start. Setting `[start_line, "
-        "-1]` shows all lines from `start_line` to the end of the file.",
-    )
-
-
-class StrReplaceEditorObservation(ObservationBase):
-    """A ToolResult that can be rendered as a CLI output."""
-
-    output: str = Field(
-        default="", description="The output message from the tool for the LLM to see."
-    )
-    path: str | None = Field(default=None, description="The file path that was edited.")
-    prev_exist: bool = Field(
-        default=True,
-        description="Indicates if the file previously existed. If not, it was created.",
-    )
-    old_content: str | None = Field(
-        default=None, description="The content of the file before the edit."
-    )
-    new_content: str | None = Field(
-        default=None, description="The content of the file after the edit."
-    )
-    error: str | None = Field(default=None, description="Error message if any.")
-
-    @property
-    def agent_observation(self) -> list[TextContent | ImageContent]:
-        if self.error:
-            return [TextContent(text=self.error)]
-        return [TextContent(text=self.output)]
-
-
-Command = Literal[
-    "view",
-    "create",
-    "str_replace",
-    "insert",
-    "undo_edit",
-]
-
-
-TOOL_DESCRIPTION = """Custom editing tool for viewing, creating and editing files in plain-text format
-* State is persistent across command calls and discussions with the user
-* If `path` is a text file, `view` displays the result of applying `cat -n`. If `path` is a directory, `view` lists non-hidden files and directories up to 2 levels deep
-* The following binary file extensions can be viewed in Markdown format: [".xlsx", ".pptx", ".wav", ".mp3", ".m4a", ".flac", ".pdf", ".docx"]. IT DOES NOT HANDLE IMAGES.
-* The `create` command cannot be used if the specified `path` already exists as a file
-* If a `command` generates a long output, it will be truncated and marked with `<response clipped>`
-* The `undo_edit` command will revert the last edit made to the file at `path`
-* This tool can be used for creating and editing files in plain-text format.
-
-
-Before using this tool:
-1. Use the view tool to understand the file's contents and context
-2. Verify the directory path is correct (only applicable when creating new files):
-   - Use the view tool to verify the parent directory exists and is the correct location
-
-When making edits:
-   - Ensure the edit results in idiomatic, correct code
-   - Do not leave the code in a broken state
-   - Always use absolute file paths (starting with /)
-
-CRITICAL REQUIREMENTS FOR USING THIS TOOL:
-
-1. EXACT MATCHING: The `old_str` parameter must match EXACTLY one or more consecutive lines from the file, including all whitespace and indentation. The tool will fail if `old_str` matches multiple locations or doesn't match exactly with the file content.
-
-2. UNIQUENESS: The `old_str` must uniquely identify a single instance in the file:
-   - Include sufficient context before and after the change point (3-5 lines recommended)
-   - If not unique, the replacement will not be performed
-
-3. REPLACEMENT: The `new_str` parameter should contain the edited lines that replace the `old_str`. Both strings must be different.
-
-Remember: when making multiple file edits in a row to the same file, you should prefer to send all edits in a single message with multiple calls to this tool, rather than multiple messages with a single call each.
-"""  # noqa: E501
-
-
-str_replace_editor_tool = Tool(
-    name="str_replace_editor",
-    input_schema=StrReplaceEditorAction,
-    description=TOOL_DESCRIPTION,
-    annotations=ToolAnnotations(
-        title="str_replace_editor",
-        readOnlyHint=False,
-        destructiveHint=True,
-        idempotentHint=False,
-        openWorldHint=False,
-    ),
-)
-
-
-class FileEditorTool(Tool[StrReplaceEditorAction, StrReplaceEditorObservation]):
-    """A Tool subclass that automatically initializes a FileEditorExecutor."""
-
-    def __init__(self):
-        """Initialize FileEditorTool with a FileEditorExecutor."""
-        # Import here to avoid circular imports
-        from openhands.tools.str_replace_editor.impl import FileEditorExecutor
-
-        # Initialize the executor
-        executor = FileEditorExecutor()
-
-        # Initialize the parent Tool with the executor
-        super().__init__(
-            name=str_replace_editor_tool.name,
-            description=TOOL_DESCRIPTION,
-            input_schema=StrReplaceEditorAction,
-            output_schema=StrReplaceEditorObservation,
-            annotations=str_replace_editor_tool.annotations,
-            executor=executor,
-        )