indent 0.1.26__py3-none-any.whl

exponent/core/remote_execution/code_execution.py

@@ -0,0 +1,77 @@
+from collections.abc import AsyncGenerator, Callable
+
+from exponent.core.remote_execution.cli_rpc_types import (
+    StreamingCodeExecutionRequest,
+    StreamingCodeExecutionResponse,
+    StreamingCodeExecutionResponseChunk,
+)
+from exponent.core.remote_execution.languages.python_execution import (
+    execute_python_streaming,
+)
+from exponent.core.remote_execution.languages.shell_streaming import (
+    execute_shell_streaming,
+)
+from exponent.core.remote_execution.languages.types import StreamedOutputPiece
+from exponent.core.remote_execution.session import RemoteExecutionClientSession
+
+EMPTY_OUTPUT_STRING = "(No output)"
+MAX_OUTPUT_LENGTH = 50000  # Maximum characters to keep in final output
+
+
+async def execute_code_streaming(
+    request: StreamingCodeExecutionRequest,
+    session: RemoteExecutionClientSession,
+    working_directory: str,
+    should_halt: Callable[[], bool] | None = None,
+) -> AsyncGenerator[
+    StreamingCodeExecutionResponseChunk | StreamingCodeExecutionResponse, None
+]:
+    if request.language == "python":
+        async for output in execute_python_streaming(
+            request.content, session.kernel, user_interrupted=should_halt
+        ):
+            if isinstance(output, StreamedOutputPiece):
+                yield StreamingCodeExecutionResponseChunk(
+                    content=output.content, correlation_id=request.correlation_id
+                )
+            else:
+                final_output = output.output or EMPTY_OUTPUT_STRING
+                truncated = len(final_output) > MAX_OUTPUT_LENGTH
+                if truncated:
+                    final_output = final_output[-MAX_OUTPUT_LENGTH:]
+                    final_output = (
+                        f"[Truncated to last {MAX_OUTPUT_LENGTH} characters]\n\n"
+                        + final_output
+                    )
+                yield StreamingCodeExecutionResponse(
+                    correlation_id=request.correlation_id,
+                    content=final_output,
+                    truncated=truncated,
+                    halted=output.halted,
+                )
+
+    elif request.language == "shell":
+        async for shell_output in execute_shell_streaming(
+            request.content, working_directory, request.timeout, should_halt
+        ):
+            if isinstance(shell_output, StreamedOutputPiece):
+                yield StreamingCodeExecutionResponseChunk(
+                    content=shell_output.content, correlation_id=request.correlation_id
+                )
+            else:
+                final_output = shell_output.output or EMPTY_OUTPUT_STRING
+                truncated = len(final_output) > MAX_OUTPUT_LENGTH
+                if truncated:
+                    final_output = final_output[-MAX_OUTPUT_LENGTH:]
+                    final_output = (
+                        f"[Truncated to last {MAX_OUTPUT_LENGTH} characters]\n\n"
+                        + final_output
+                    )
+                yield StreamingCodeExecutionResponse(
+                    correlation_id=request.correlation_id,
+                    content=final_output,
+                    truncated=truncated,
+                    halted=shell_output.halted,
+                    exit_code=shell_output.exit_code,
+                    cancelled_for_timeout=shell_output.cancelled_for_timeout,
+                )

exponent/core/remote_execution/default_env.py

@@ -0,0 +1,31 @@
+import os
+
+
+def get_default_env() -> dict[str, str]:
+    """
+    Returns default environment variables for CLI-spawned processes.
+    These are merged with the parent process environment.
+    """
+    return {
+        "GIT_EDITOR": "true",
+    }
+
+
+def get_process_env(env_overrides: dict[str, str] | None = None) -> dict[str, str]:
+    """
+    Returns the complete environment for spawned processes.
+    Merges parent environment with default variables, then applies overrides.
+
+    Priority order (lowest to highest):
+    1. Parent process environment (os.environ)
+    2. Default environment variables (get_default_env())
+    3. Explicit overrides (env_overrides parameter)
+
+    Args:
+        env_overrides: Optional dict of environment variables that override defaults
+    """
+    env = os.environ.copy()
+    env.update(get_default_env())
+    if env_overrides:
+        env.update(env_overrides)
+    return env

exponent/core/remote_execution/error_info.py

@@ -0,0 +1,45 @@
+import traceback
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class SerializableErrorInfo(BaseModel):
+    message: str
+    stack: list[str]
+    cls_name: str | None
+    cause: Optional["SerializableErrorInfo"]
+    context: Optional["SerializableErrorInfo"]
+
+    def __str__(self) -> str:
+        return self.to_string()
+
+    def to_string(self) -> str:
+        stack_str = "\nStack Trace:\n" + "".join(self.stack) if self.stack else ""
+        cause_str = (
+            "\nThe above exception was caused by the following exception:\n"
+            + self.cause.to_string()
+            if self.cause
+            else ""
+        )
+        context_str = (
+            "\nThe above exception occurred during handling of the following exception:\n"
+            + self.context.to_string()
+            if self.context
+            else ""
+        )
+
+        return f"{self.message}{stack_str}{cause_str}{context_str}"
+
+
+SerializableErrorInfo.model_rebuild()
+
+
+def serialize_error_info(error: BaseException) -> SerializableErrorInfo:
+    return SerializableErrorInfo(
+        message=str(error),
+        stack=traceback.format_tb(error.__traceback__),
+        cls_name=error.__class__.__name__,
+        cause=serialize_error_info(error.__cause__) if error.__cause__ else None,
+        context=serialize_error_info(error.__context__) if error.__context__ else None,
+    )

exponent/core/remote_execution/exceptions.py

@@ -0,0 +1,10 @@
+class ExponentError(Exception):
+    pass
+
+
+class HandledExponentError(Exception):
+    pass
+
+
+class RateLimitError(Exception):
+    pass

exponent/core/remote_execution/file_write.py

@@ -0,0 +1,35 @@
+import os
+
+from anyio import Path as AsyncPath
+
+from exponent.core.remote_execution.types import (
+    FilePath,
+)
+from exponent.core.remote_execution.utils import (
+    safe_write_file,
+)
+
+
+async def execute_full_file_rewrite(
+    file_path: FilePath, content: str, working_directory: str
+) -> str:
+    try:
+        # Construct the absolute path
+        full_file_path = AsyncPath(os.path.join(working_directory, file_path))
+
+        # Check if the directory exists, if not, create it
+        await full_file_path.parent.mkdir(parents=True, exist_ok=True)
+        exists = await full_file_path.exists()
+
+        await safe_write_file(full_file_path, content)
+
+        # Determine if the file exists and write the new content
+        if exists:
+            result = f"Modified file {file_path} successfully"
+        else:
+            result = f"Created file {file_path} successfully"
+
+        return result
+
+    except Exception as e:
+        return f"An error occurred: {e!s}"

exponent/core/remote_execution/files.py

@@ -0,0 +1,330 @@
+import os
+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 exponent.core.remote_execution.cli_rpc_types import ErrorToolResult, GrepToolResult
+from exponent.core.remote_execution.types import (
+    FilePath,
+    ListFilesRequest,
+    ListFilesResponse,
+    RemoteFile,
+)
+from exponent.core.remote_execution.utils import safe_read_file
+
+MAX_MATCHING_FILES: Final[int] = 10
+FILE_NOT_FOUND: Final[str] = "File {} does not exist"
+MAX_FILES_TO_WALK: Final[int] = 10_000
+
+GLOB_MAX_COUNT: Final[int] = 1000
+GREP_MAX_RESULTS = 100
+
+
+class FileCache:
+    """A cache of the files in a working directory.
+
+    Args:
+        working_directory: The working directory to cache the files from.
+    """
+
+    def __init__(self, working_directory: str) -> None:
+        self.working_directory = working_directory
+        self._cache: list[str] | None = None
+
+    async def get_files(self) -> list[str]:
+        """Get the files in the working directory.
+
+        Returns:
+            A list of file paths in the working directory.
+        """
+        if self._cache is None:
+            self._cache = await file_walk(self.working_directory)
+
+        return self._cache
+
+
+async def list_files(list_files_request: ListFilesRequest) -> ListFilesResponse:
+    """Get a list of files in the specified directory.
+
+    Args:
+        list_files_request: An object containing the directory to list files from.
+
+    Returns:
+        A list of RemoteFile objects representing the files in the directory.
+    """
+
+    filenames = [
+        entry.name async for entry in AsyncPath(list_files_request.directory).iterdir()
+    ]
+
+    return ListFilesResponse(
+        files=[
+            RemoteFile(
+                file_path=filename,
+                working_directory=list_files_request.directory,
+            )
+            for filename in filenames
+        ],
+        correlation_id=list_files_request.correlation_id,
+    )
+
+
+async def get_file_content(
+    absolute_path: FilePath, offset: int | None = None, limit: int | None = None
+) -> tuple[str, bool]:
+    """Get the content of the file at the specified path.
+
+    Args:
+        absolute_path: The absolute path to the file.
+
+    Returns:
+        A tuple containing the content of the file and a boolean indicating if the file exists.
+    """
+    file = AsyncPath(absolute_path)
+    exists = await file.exists()
+
+    if not exists:
+        return FILE_NOT_FOUND.format(absolute_path), False
+
+    if await file.is_dir():
+        return "File is a directory", True
+
+    content = await safe_read_file(file)
+
+    if offset or limit:
+        offset = offset or 0
+        limit = limit or -1
+
+        content_lines = content.splitlines()
+        content_lines = content_lines[offset:]
+        content_lines = content_lines[:limit]
+
+        content = "\n".join(content_lines)
+
+    return content, exists
+
+
+async def search_files(
+    path_str: str,
+    file_pattern: str | None,
+    regex: str,
+    working_directory: str,
+    multiline: bool | None = None,
+) -> GrepToolResult | ErrorToolResult:
+    path = AsyncPath(working_directory) / path_str
+
+    if not await path.exists():
+        return ErrorToolResult(
+            error_message=f"Path does not exist: {path_str}",
+        )
+
+    path_resolved = await path.resolve()
+    globs = [file_pattern] if file_pattern else None
+
+    if globs:
+        matched_files = await to_thread(
+            files,
+            patterns=[],
+            paths=[str(path_resolved)],
+            globs=globs,
+            max_count=1,
+        )
+        if not matched_files:
+            return ErrorToolResult(
+                error_message=f"No files matched the include glob pattern: {file_pattern} at {path_str}",
+            )
+
+    results = await to_thread(
+        search,
+        patterns=[regex],
+        paths=[str(path_resolved)],
+        globs=globs,
+        after_context=3,
+        before_context=5,
+        heading=True,
+        separator_field_context="|",
+        separator_field_match="|",
+        separator_context="\n...\n",
+        multiline=multiline,
+    )
+
+    return GrepToolResult(
+        matches=results[:GREP_MAX_RESULTS],
+        truncated=bool(len(results) > GREP_MAX_RESULTS),
+    )
+
+
+async def get_all_file_contents(
+    working_directory: str,
+) -> list[list[str]]:
+    path_resolved = await AsyncPath(working_directory).resolve()
+
+    results = await to_thread(
+        search,
+        patterns=[".*"],
+        paths=[str(path_resolved)],
+        globs=["!**/poetry.lock", "!**/pnpm-lock.yaml"],
+        heading=True,
+        line_number=False,
+    )
+
+    result_sizes = [len(result) for result in results]
+    total_size = sum(result_sizes)
+    batch_size = total_size // 10
+
+    batches = []
+    current_batch: list[str] = []
+    current_size = 0
+
+    for i, result in enumerate(results):
+        if current_size + result_sizes[i] > batch_size:
+            batches.append(current_batch)
+            current_batch = []
+            current_size = 0
+
+        current_batch.append(result)
+        current_size += result_sizes[i]
+
+    batches.append(current_batch)
+
+    return batches
+
+
+async def normalize_files(
+    working_directory: str, file_paths: list[FilePath]
+) -> list[RemoteFile]:
+    """Normalize file paths to be relative to the working directory.
+
+    Args:
+        working_directory: The working directory to normalize the file paths against.
+        file_paths: A list of file paths to normalize.
+
+    Returns:
+        A list of RemoteFile objects with normalized file paths.
+    """
+    working_path = await AsyncPath(working_directory).resolve()
+    normalized_files = []
+
+    for file_path in file_paths:
+        path = AsyncPath(file_path)
+
+        if path.is_absolute():
+            path = path.relative_to(working_path)
+
+        normalized_files.append(
+            RemoteFile(
+                file_path=str(path),
+                working_directory=working_directory,
+            )
+        )
+
+    return sorted(normalized_files)
+
+
+def _format_ignore_globs(ignore_extra: list[str] | None) -> list[str]:
+    if ignore_extra is None:
+        return []
+
+    return [f"!**/{ignore}" for ignore in ignore_extra]
+
+
+async def file_walk(
+    directory: str,
+    ignore_extra: list[str] | None = None,
+    max_files: int = MAX_FILES_TO_WALK,
+) -> list[str]:
+    """
+    Walk through a directory and return all file paths, respecting .gitignore and additional ignore patterns.
+
+    Args:
+        directory: The directory to walk through
+        ignore_extra: Additional directory paths to ignore, follows the gitignore format.
+        max_files: The maximal number of files to return
+
+    Returns:
+        A list of file paths in the directory.
+    """
+    working_path = str(await AsyncPath(directory).resolve())
+
+    results: list[str] = await to_thread(
+        files,
+        patterns=[""],
+        paths=[working_path],
+        globs=_format_ignore_globs(ignore_extra),
+        sort=PySortMode(kind=PySortModeKind.Path),
+        max_count=max_files,
+    )
+
+    # Create relative paths using os.path functions which handle platform differences
+    relative_results = []
+    for result in results:
+        # Check if the path is inside the working directory
+        if os.path.commonpath([working_path, result]) == working_path:
+            # Create relative path
+            rel_path = os.path.relpath(result, working_path)
+            relative_results.append(rel_path)
+        else:
+            # Fallback to just using the filename
+            relative_results.append(os.path.basename(result))
+
+    return relative_results
+
+
+async def get_all_non_ignored_files(working_directory: str) -> list[RemoteFile]:
+    file_paths = await file_walk(working_directory, ignore_extra=DEFAULT_IGNORES)
+
+    return await normalize_files(working_directory, cast(list[FilePath], file_paths))
+
+
+async def glob(
+    path: str,
+    glob_pattern: str,
+) -> list[str]:
+    return await to_thread(
+        files,
+        patterns=[],
+        paths=[path],
+        globs=[glob_pattern],
+        sort=PySortMode(kind=PySortModeKind.Path),
+        max_count=GLOB_MAX_COUNT,
+    )
+
+
+DEFAULT_IGNORES = [
+    "**/.git/",
+    ".venv/",
+    ".mypy_cache",
+    ".pytest_cache",
+    "node_modules/",
+    "venv/",
+    ".pyenv",
+    "__pycache__",
+    ".ipynb_checkpoints",
+    ".vercel",
+    "__pycache__/",
+    "*.py[cod]",
+    "*$py.class",
+    ".env",
+    "*.so",
+    ".Python",
+    "build/",
+    "develop-eggs/",
+    "dist/",
+    "downloads/",
+    "eggs/",
+    ".eggs/",
+    "lib/",
+    "lib64/",
+    "parts/",
+    "sdist/",
+    "var/",
+    "wheels/",
+    "pip-wheel-metadata/",
+    "share/python-wheels/",
+    "*.egg-info/",
+    ".installed.cfg",
+    "*.egg",
+    "MANIFEST",
+]