indent 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

exponent/core/remote_execution/cli_rpc_types.py

@@ -1,6 +1,12 @@
+from typing import TYPE_CHECKING, Any
+
 import msgspec
 import yaml
-from typing import Any
+
+if TYPE_CHECKING:
+    from exponent_server.core.tools.edit_tool import (
+        EditToolInput as ServerSideEditToolInput,
+    )
 
 
 class PartialToolResult(msgspec.Struct, tag_field="tool_name", omit_defaults=True):
@@ -46,11 +52,17 @@ class ReadToolInput(ToolInput, tag=READ_TOOL_NAME):
     limit: int | None = None
 
 
+class FileMetadata(msgspec.Struct):
+    modified_timestamp: float
+    file_mode: str
+
+
 class ReadToolResult(ToolResult, tag=READ_TOOL_NAME):
     content: str
     num_lines: int
     start_line: int
     total_lines: int
+    metadata: FileMetadata | None = None
 
     def to_text(self) -> str:
         lines = self.content.splitlines()
@@ -99,6 +111,7 @@ class WriteToolInput(ToolInput, tag=WRITE_TOOL_NAME):
 
 class WriteToolResult(ToolResult, tag=WRITE_TOOL_NAME):
     message: str
+    metadata: FileMetadata | None = None
 
 
 GREP_TOOL_NAME = "grep"
@@ -125,10 +138,27 @@ class EditToolInput(ToolInput, tag=EDIT_TOOL_NAME):
     old_string: str
     new_string: str
     replace_all: bool = False
+    # The last retrieved modified timestamp. This is used to check if the file has been modified since the last read/write that we are aware of (in which case we should re-read the file before editing).
+    last_known_modified_timestamp: float | None = None
+
+    @classmethod
+    def from_server_side_input(
+        cls,
+        server_side_input: "ServerSideEditToolInput",
+        last_known_modified_timestamp: float | None,
+    ) -> "EditToolInput":
+        return cls(
+            file_path=server_side_input.file_path,
+            old_string=server_side_input.old_string,
+            new_string=server_side_input.new_string,
+            replace_all=server_side_input.replace_all,
+            last_known_modified_timestamp=last_known_modified_timestamp,
+        )
 
 
 class EditToolResult(ToolResult, tag=EDIT_TOOL_NAME):
     message: str
+    metadata: FileMetadata | None = None
 
 
 BASH_TOOL_NAME = "bash"

exponent/core/remote_execution/client.py

@@ -6,7 +6,7 @@ import logging
 from collections.abc import AsyncGenerator, Callable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from typing import Any, TypeVar, Union, cast
+from typing import Any, TypeVar, cast
 
 import msgspec
 import websockets.client
@@ -29,15 +29,14 @@ from exponent.core.remote_execution.cli_rpc_types import (
     ErrorResponse,
     GetAllFilesRequest,
     GetAllFilesResponse,
-    HttpResponse,
     HttpRequest,
+    SwitchCLIChatRequest,
+    SwitchCLIChatResponse,
     TerminateRequest,
     TerminateResponse,
     ToolExecutionRequest,
     ToolExecutionResponse,
     ToolResultType,
-    SwitchCLIChatRequest,
-    SwitchCLIChatResponse,
 )
 from exponent.core.remote_execution.code_execution import (
     execute_code_streaming,
@@ -87,7 +86,7 @@ class SwitchCLIChat:
     new_chat_uuid: str
 
 
-REMOTE_EXECUTION_CLIENT_EXIT_INFO = Union[WSDisconnected, SwitchCLIChat]
+REMOTE_EXECUTION_CLIENT_EXIT_INFO = WSDisconnected | SwitchCLIChat
 
 
 class RemoteExecutionClient:
@@ -302,7 +301,7 @@ class RemoteExecutionClient:
                     async with results_lock:
                         logger.info(f"Putting response {response}")
                         await results.put(response)
-                except Exception as e:  # noqa: BLE001
+                except Exception as e:
                     logger.info(f"Error handling request {request}:\n\n{e}")
                     async with results_lock:
                         await results.put(
@@ -550,7 +549,7 @@ class RemoteExecutionClient:
                             )
                         tool_result = truncate_result(raw_result)
                         results.append(tool_result)
-                    except Exception as e:  # noqa: BLE001
+                    except Exception as e:
                         logger.error(f"Error executing tool {tool_input}: {e}")
                         from exponent.core.remote_execution.cli_rpc_types import (
                             ErrorToolResult,

exponent/core/remote_execution/file_write.py

@@ -77,7 +77,7 @@ def lint_file(file_path: str, working_directory: str) -> str:
 
         # If the subprocess ran successfully, return a success message
         return f"Lint results:\n\n{result.stdout}\n\n{result.stderr}"
-    except Exception as e:  # noqa: BLE001
+    except Exception as e:
         # For any other errors, return a generic error message
         return f"An error occurred while linting: {e!s}"
 
@@ -103,7 +103,7 @@ async def execute_full_file_rewrite(
 
         return result
 
-    except Exception as e:  # noqa: BLE001
+    except Exception as e:
         return f"An error occurred: {e!s}"
 
 

exponent/core/remote_execution/files.py

@@ -1,21 +1,13 @@
 import os
-from asyncio import gather, to_thread
+from asyncio import to_thread
 from typing import Final, cast
 
 from anyio import Path as AsyncPath
 from python_ripgrep import PySortMode, PySortModeKind, files, search
-from rapidfuzz import process
 
 from exponent.core.remote_execution.cli_rpc_types import ErrorToolResult, GrepToolResult
 from exponent.core.remote_execution.types import (
-    FileAttachment,
     FilePath,
-    GetFileAttachmentRequest,
-    GetFileAttachmentResponse,
-    GetFileAttachmentsRequest,
-    GetFileAttachmentsResponse,
-    GetMatchingFilesRequest,
-    GetMatchingFilesResponse,
     ListFilesRequest,
     ListFilesResponse,
     RemoteFile,
@@ -114,99 +106,6 @@ async def get_file_content(
     return content, exists
 
 
-async def get_file_attachments(
-    get_file_attachments_request: GetFileAttachmentsRequest,
-    client_working_directory: str,
-) -> GetFileAttachmentsResponse:
-    """Get the content of the files at the specified paths.
-
-    Args:
-        get_file_attachments_request: An object containing the file paths.
-        client_working_directory:  The working directory of the client.
-
-    Returns:
-        A list of FileAttachment objects containing the content of the files.
-    """
-    remote_files = get_file_attachments_request.files
-    attachments = await gather(
-        *[
-            get_file_content(
-                AsyncPath(client_working_directory) / remote_file.file_path
-            )
-            for remote_file in remote_files
-        ]
-    )
-
-    files = [
-        FileAttachment(attachment_type="file", file=remote_file, content=content)
-        for remote_file, (content, _) in zip(remote_files, attachments)
-    ]
-
-    return GetFileAttachmentsResponse(
-        correlation_id=get_file_attachments_request.correlation_id,
-        file_attachments=files,
-    )
-
-
-async def get_file_attachment(
-    get_file_attachment_request: GetFileAttachmentRequest, client_working_directory: str
-) -> GetFileAttachmentResponse:
-    """Get the content of the file at the specified path.
-
-    Args:
-        get_file_attachment_request: An object containing the file path.
-        client_working_directory: The working directory of the client.
-
-    Returns:
-        A FileAttachment object containing the content of the file.
-    """
-    file = get_file_attachment_request.file
-    absolute_path = await file.resolve(client_working_directory)
-
-    content, exists = await get_file_content(absolute_path)
-
-    return GetFileAttachmentResponse(
-        content=content,
-        exists=exists,
-        file=file,
-        correlation_id=get_file_attachment_request.correlation_id,
-    )
-
-
-async def get_matching_files(
-    search_term: GetMatchingFilesRequest,
-    file_cache: FileCache,
-) -> GetMatchingFilesResponse:
-    """Get the files that match the search term.
-
-    Args:
-        search_term: The search term to match against the files.
-        file_cache: A cache of the files in the working directory.
-
-    Returns:
-        A list of RemoteFile objects that match the search term.
-    """
-    # Use rapidfuzz to find the best matching files
-    matching_files = await to_thread(
-        process.extract,
-        search_term.search_term,
-        await file_cache.get_files(),
-        limit=MAX_MATCHING_FILES,
-        score_cutoff=0,
-    )
-
-    directory = file_cache.working_directory
-    files: list[RemoteFile] = [
-        RemoteFile(file_path=file, working_directory=directory)
-        for file, _, _ in matching_files
-    ]
-
-    return GetMatchingFilesResponse(
-        files=files,
-        correlation_id=search_term.correlation_id,
-    )
-
-
 async def search_files(
     path_str: str,
     file_pattern: str | None,

exponent/core/remote_execution/git.py

@@ -167,7 +167,7 @@ async def _get_git_branch(repo: Repository) -> str | None:
         else:
             return None
 
-    except Exception:  # noqa: BLE001
+    except Exception:
         return None
 
 

exponent/core/remote_execution/http_fetch.py

@@ -1,13 +1,12 @@
 """HTTP fetch implementation for remote execution client."""
 
 import logging
-from typing import Any
 
 import httpx
 
 from exponent.core.remote_execution.cli_rpc_types import (
-    HttpResponse,
     HttpRequest,
+    HttpResponse,
 )
 
 logger = logging.getLogger(__name__)
@@ -79,7 +78,7 @@ async def fetch_http_content(http_request: HttpRequest) -> HttpResponse:
         )
 
     except httpx.RequestError as e:
-        error_msg = f"Request error for {http_request.url}: {str(e)}"
+        error_msg = f"Request error for {http_request.url}: {e!s}"
         return HttpResponse(
             status_code=None,
             content="",
@@ -87,7 +86,7 @@ async def fetch_http_content(http_request: HttpRequest) -> HttpResponse:
         )
 
     except Exception as e:
-        error_msg = f"Unexpected error fetching {http_request.url}: {str(e)}"
+        error_msg = f"Unexpected error fetching {http_request.url}: {e!s}"
         return HttpResponse(
             status_code=None,
             content="",

exponent/core/remote_execution/languages/python_execution.py

@@ -140,7 +140,7 @@ class Kernel:
                 except queue.Empty:
                     continue
 
-            except Exception as e:  # noqa: BLE001 - TODO: Deep audit potential exceptions
+            except Exception as e:
                 logger.info(f"Error getting message from kernel: {e}")
                 break
 

exponent/core/remote_execution/languages/shell_streaming.py

@@ -75,7 +75,7 @@ async def read_stream(
             break
 
 
-async def execute_shell_streaming(
+async def execute_shell_streaming(  # noqa: PLR0915
     code: str,
     working_directory: str,
     timeout: int,

exponent/core/remote_execution/session.py

@@ -120,7 +120,7 @@ async def get_session(
     )
     try:
         yield session
-    except Exception as exc:  # noqa: BLE001
+    except Exception as exc:
         await send_exception_log(exc, session=session, settings=None)
         raise ExponentError(str(exc))
     finally:

exponent/core/remote_execution/system_context.py

@@ -2,14 +2,11 @@ import getpass
 import os
 import platform
 
-from anyio import Path as AsyncPath
-
 from exponent.core.remote_execution.git import get_git_info
 from exponent.core.remote_execution.languages import python_execution
 from exponent.core.remote_execution.types import (
     SystemInfo,
 )
-from exponent.core.remote_execution.utils import safe_read_file
 
 
 async def get_system_info(working_directory: str) -> SystemInfo:

exponent/core/remote_execution/tool_execution.py

@@ -1,3 +1,4 @@
+import logging
 import uuid
 from collections.abc import Callable
 from pathlib import Path
@@ -36,9 +37,12 @@ from exponent.core.remote_execution.types import (
 )
 from exponent.core.remote_execution.utils import (
     assert_unreachable,
+    safe_get_file_metadata,
     safe_read_file,
 )
 
+logger = logging.getLogger(__name__)
+
 
 async def execute_tool(
     tool_input: ToolInputType, working_directory: str
@@ -116,9 +120,11 @@ async def execute_read_file(  # noqa: PLR0911
         return ErrorToolResult(
             error_message="File appears to be binary or has invalid text encoding"
         )
-    except Exception as e:  # noqa: BLE001
+    except Exception as e:
         return ErrorToolResult(error_message=f"Error reading file: {e!s}")
 
+    metadata = await safe_get_file_metadata(file)
+
     # Handle empty files
     if not content:
         return ReadToolResult(
@@ -126,6 +132,7 @@ async def execute_read_file(  # noqa: PLR0911
             num_lines=0,
             start_line=0,
             total_lines=0,
+            metadata=metadata,
         )
 
     content_lines = content.splitlines(keepends=True)
@@ -138,6 +145,7 @@ async def execute_read_file(  # noqa: PLR0911
             num_lines=0,
             start_line=offset,
             total_lines=total_lines,
+            metadata=metadata,
         )
 
     # Apply offset and limit
@@ -180,6 +188,7 @@ async def execute_read_file(  # noqa: PLR0911
         num_lines=num_lines,
         start_line=offset,
         total_lines=total_lines,
+        metadata=metadata,
     )
 
 
@@ -213,6 +222,16 @@ async def execute_edit_file(  # noqa: PLR0911
     if not exists:
         return ErrorToolResult(error_message="File not found")
 
+    if tool_input.last_known_modified_timestamp is not None:
+        metadata = await safe_get_file_metadata(file)
+        if (
+            metadata is not None
+            and metadata.modified_timestamp > tool_input.last_known_modified_timestamp
+        ):
+            return ErrorToolResult(
+                error_message="File has been modified since last read/write"
+            )
+
     try:
         if await file.is_dir():
             return ErrorToolResult(
@@ -232,7 +251,7 @@ async def execute_edit_file(  # noqa: PLR0911
         return ErrorToolResult(
             error_message="File appears to be binary or has invalid text encoding"
         )
-    except Exception as e:  # noqa: BLE001
+    except Exception as e:
         return ErrorToolResult(error_message=f"Error reading file: {e!s}")
 
     # Check if search text exists
@@ -265,9 +284,10 @@ async def execute_edit_file(  # noqa: PLR0911
         path = Path(working_directory, tool_input.file_path)
         await execute_full_file_rewrite(path, new_content, working_directory)
         return EditToolResult(
-            message=f"Successfully replaced text in {tool_input.file_path}"
+            message=f"Successfully replaced text in {tool_input.file_path}",
+            metadata=await safe_get_file_metadata(path),
         )
-    except Exception as e:  # noqa: BLE001
+    except Exception as e:
         return ErrorToolResult(error_message=f"Error writing file: {e!s}")
 
 

exponent/core/remote_execution/truncation.py

@@ -123,6 +123,56 @@ class CompositeTruncation(TruncationStrategy):
         return result
 
 
+class TailTruncation(TruncationStrategy):
+    """Truncation strategy that keeps the end of the output (tail) instead of the beginning."""
+
+    def __init__(
+        self,
+        field_name: str,
+        character_limit: int = DEFAULT_CHARACTER_LIMIT,
+    ):
+        self.field_name = field_name
+        self.character_limit = character_limit
+
+    def should_truncate(self, result: ToolResult) -> bool:
+        if hasattr(result, self.field_name):
+            value = getattr(result, self.field_name)
+            if isinstance(value, str):
+                return len(value) > self.character_limit
+        return False
+
+    def truncate(self, result: ToolResult) -> ToolResult:
+        if not hasattr(result, self.field_name):
+            return result
+
+        value = getattr(result, self.field_name)
+        if not isinstance(value, str):
+            return result
+
+        if len(value) <= self.character_limit:
+            return result
+
+        # Keep the last character_limit characters
+        truncated_value = value[-self.character_limit :]
+
+        # Try to start at a newline if possible for cleaner output
+        newline_pos = truncated_value.find("\n")
+        if (
+            newline_pos != -1 and newline_pos < 1000
+        ):  # Only adjust if newline is reasonably close to start
+            truncated_value = truncated_value[newline_pos + 1 :]
+
+        # Add truncation indicator at the beginning
+        truncation_msg = f"... (output truncated, showing last {len(truncated_value)} characters) ...\n"
+        truncated_value = truncation_msg + truncated_value
+
+        updates: dict[str, Any] = {self.field_name: truncated_value}
+        if hasattr(result, "truncated"):
+            updates["truncated"] = True
+
+        return replace(result, **updates)
+
+
 class StringListTruncation(TruncationStrategy):
     """Truncation for lists of strings that limits both number of items and individual string length."""
 
@@ -215,7 +265,7 @@ class StringListTruncation(TruncationStrategy):
 TRUNCATION_REGISTRY: dict[type[ToolResult], TruncationStrategy] = {
     ReadToolResult: StringFieldTruncation("content"),
     WriteToolResult: StringFieldTruncation("message"),
-    BashToolResult: StringFieldTruncation("shell_output"),
+    BashToolResult: TailTruncation("shell_output"),
     GrepToolResult: StringListTruncation("matches"),
     GlobToolResult: StringListTruncation("filenames", max_item_length=4096),
     ListToolResult: StringListTruncation("files", max_item_length=4096),
@@ -236,49 +286,3 @@ def truncate_tool_result(result: T) -> T:
             return cast(T, strategy.truncate(result))
 
     return result
-
-
-def register_truncation_strategy(
-    result_type: type[ToolResult],
-    strategy: TruncationStrategy,
-) -> None:
-    TRUNCATION_REGISTRY[result_type] = strategy
-
-
-def configure_truncation_limits(
-    character_limit: int | None = None,
-    list_item_limit: int | None = None,
-    list_preview_items: int | None = None,
-    string_item_length: int | None = None,
-) -> None:
-    for strategy in TRUNCATION_REGISTRY.values():
-        if isinstance(strategy, StringFieldTruncation) and character_limit is not None:
-            strategy.character_limit = character_limit
-        elif isinstance(strategy, ListFieldTruncation):
-            if list_item_limit is not None:
-                strategy.item_limit = list_item_limit
-            if list_preview_items is not None:
-                strategy.preview_items = list_preview_items
-        elif isinstance(strategy, StringListTruncation):
-            if list_item_limit is not None:
-                strategy.max_items = list_item_limit
-            if list_preview_items is not None:
-                strategy.preview_items = list_preview_items
-            if string_item_length is not None:
-                strategy.max_item_length = string_item_length
-        elif isinstance(strategy, CompositeTruncation):
-            for sub_strategy in strategy.strategies:
-                if isinstance(sub_strategy, StringFieldTruncation) and character_limit:
-                    sub_strategy.character_limit = character_limit
-                elif isinstance(sub_strategy, ListFieldTruncation):
-                    if list_item_limit is not None:
-                        sub_strategy.item_limit = list_item_limit
-                    if list_preview_items is not None:
-                        sub_strategy.preview_items = list_preview_items
-                elif isinstance(sub_strategy, StringListTruncation):
-                    if list_item_limit is not None:
-                        sub_strategy.max_items = list_item_limit
-                    if list_preview_items is not None:
-                        sub_strategy.preview_items = list_preview_items
-                    if string_item_length is not None:
-                        sub_strategy.max_item_length = string_item_length