indent 0.1.13__py3-none-any.whl → 0.1.28__py3-none-any.whl

exponent/core/remote_execution/tool_execution.py

@@ -1,8 +1,10 @@
+import asyncio
 import logging
 import uuid
 from collections.abc import Callable
 from pathlib import Path
 from time import time
+from typing import TYPE_CHECKING
 
 from anyio import Path as AsyncPath
 
@@ -10,6 +12,8 @@ from exponent.core.remote_execution import files
 from exponent.core.remote_execution.cli_rpc_types import (
     BashToolInput,
     BashToolResult,
+    DownloadArtifactToolInput,
+    DownloadArtifactToolResult,
     EditToolInput,
     EditToolResult,
     ErrorToolResult,
@@ -19,22 +23,32 @@ from exponent.core.remote_execution.cli_rpc_types import (
     GrepToolResult,
     ListToolInput,
     ListToolResult,
+    ReadToolArtifactResult,
     ReadToolInput,
     ReadToolResult,
     ToolInputType,
     ToolResultType,
+    UploadArtifactToolInput,
+    UploadArtifactToolResult,
     WriteToolInput,
     WriteToolResult,
 )
+
+if TYPE_CHECKING:
+    from exponent.core.remote_execution.client import RemoteExecutionClient
+import urllib.request
+
+import aiohttp
+
+from exponent.core.remote_execution.cli_rpc_types import (
+    StreamingCodeExecutionRequest,
+    StreamingCodeExecutionResponse,
+)
 from exponent.core.remote_execution.code_execution import (
     execute_code_streaming,
 )
 from exponent.core.remote_execution.file_write import execute_full_file_rewrite
 from exponent.core.remote_execution.truncation import truncate_tool_result
-from exponent.core.remote_execution.types import (
-    StreamingCodeExecutionRequest,
-    StreamingCodeExecutionResponse,
-)
 from exponent.core.remote_execution.utils import (
     assert_unreachable,
     safe_get_file_metadata,
@@ -45,10 +59,12 @@ logger = logging.getLogger(__name__)
 
 
 async def execute_tool(
-    tool_input: ToolInputType, working_directory: str
+    tool_input: ToolInputType,
+    working_directory: str,
+    upload_client: "RemoteExecutionClient | None" = None,
 ) -> ToolResultType:
     if isinstance(tool_input, ReadToolInput):
-        return await execute_read_file(tool_input, working_directory)
+        return await execute_read_file(tool_input, working_directory, upload_client)
     elif isinstance(tool_input, WriteToolInput):
         return await execute_write_file(tool_input, working_directory)
     elif isinstance(tool_input, ListToolInput):
@@ -59,6 +75,10 @@ async def execute_tool(
         return await execute_grep_files(tool_input, working_directory)
     elif isinstance(tool_input, EditToolInput):
         return await execute_edit_file(tool_input, working_directory)
+    elif isinstance(tool_input, DownloadArtifactToolInput):
+        return await execute_download_artifact(tool_input, working_directory)
+    elif isinstance(tool_input, UploadArtifactToolInput):
+        return await execute_upload_artifact(tool_input, working_directory)
     elif isinstance(tool_input, BashToolInput):
         raise ValueError("Bash tool input should be handled by execute_bash_tool")
     else:
@@ -69,8 +89,19 @@ def truncate_result[T: ToolResultType](tool_result: T) -> T:
     return truncate_tool_result(tool_result)
 
 
-async def execute_read_file(  # noqa: PLR0911
-    tool_input: ReadToolInput, working_directory: str
+def is_image_file(file_path: str) -> tuple[bool, str | None]:
+    ext = Path(file_path).suffix.lower()
+    if ext == ".png":
+        return (True, "image/png")
+    elif ext in [".jpg", ".jpeg"]:
+        return (True, "image/jpeg")
+    return (False, None)
+
+
+async def execute_read_file(  # noqa: PLR0911, PLR0915
+    tool_input: ReadToolInput,
+    working_directory: str,
+    upload_client: "RemoteExecutionClient | None" = None,
 ) -> ReadToolResult | ErrorToolResult:
     # Validate absolute path requirement
     if not tool_input.file_path.startswith("/"):
@@ -82,16 +113,49 @@ async def execute_read_file(  # noqa: PLR0911
     offset = tool_input.offset if tool_input.offset is not None else 0
     limit = tool_input.limit if tool_input.limit is not None else 2000
 
-    if offset < 0:
-        return ErrorToolResult(
-            error_message=f"Offset must be non-negative, got: {offset}"
-        )
-
     if limit <= 0:
         return ErrorToolResult(error_message=f"Limit must be positive, got: {limit}")
 
     file = AsyncPath(working_directory, tool_input.file_path)
 
+    # Check if this is an image file and we have an upload client
+    is_image, media_type = is_image_file(tool_input.file_path)
+    if is_image and media_type and upload_client is not None:
+        try:
+            file_name = Path(tool_input.file_path).name
+            s3_key = f"images/{uuid.uuid4()}/{file_name}"
+
+            upload_response = await upload_client.request_upload_url(s3_key, media_type)
+
+            f = await file.open("rb")
+            async with f:
+                file_data = await f.read()
+
+                def _upload() -> int:
+                    req = urllib.request.Request(
+                        upload_response.upload_url,
+                        data=file_data,
+                        headers={"Content-Type": media_type},
+                        method="PUT",
+                    )
+                    with urllib.request.urlopen(req) as resp:
+                        status: int = resp.status
+                        return status
+
+                status = await asyncio.to_thread(_upload)
+                if status != 200:
+                    raise RuntimeError(f"Upload failed with status {status}")
+
+            return ReadToolResult(
+                artifact=ReadToolArtifactResult(
+                    s3_uri=upload_response.s3_uri,
+                    file_path=tool_input.file_path,
+                    media_type=media_type,
+                )
+            )
+        except Exception as e:
+            return ErrorToolResult(error_message=f"Failed to upload image to S3: {e!s}")
+
     try:
         exists = await file.exists()
     except (OSError, PermissionError) as e:
@@ -138,8 +202,8 @@ async def execute_read_file(  # noqa: PLR0911
     content_lines = content.splitlines(keepends=True)
     total_lines = len(content_lines)
 
-    # Handle offset beyond file length
-    if offset >= total_lines:
+    # Handle offset beyond file length for positive offsets
+    if offset >= 0 and offset >= total_lines:
         return ReadToolResult(
             content="",
             num_lines=0,
@@ -148,8 +212,26 @@ async def execute_read_file(  # noqa: PLR0911
             metadata=metadata,
         )
 
-    # Apply offset and limit
-    content_lines = content_lines[offset : offset + limit]
+    # Use Python's native slicing - it handles negative offsets naturally
+    # Handle the case where offset + limit < 0 (can't mix negative and non-negative indices)
+    if offset < 0 and offset + limit < 0:
+        # Both start and end are negative, use negative end index
+        end_index = offset + limit
+    elif offset < 0 and offset + limit >= 0:
+        # Start is negative but end would be positive/zero, slice to end
+        end_index = None
+    else:
+        # Normal case: both indices are non-negative
+        end_index = offset + limit
+
+    content_lines = content_lines[offset:end_index]
+
+    # Calculate the actual start line for the result
+    if offset < 0:
+        # For negative offsets, calculate where we actually started
+        actual_start_line = max(0, total_lines + offset)
+    else:
+        actual_start_line = offset
 
     # Apply character-level truncation at line boundaries to ensure consistency
     # This ensures the content field and num_lines field remain in sync
@@ -186,7 +268,7 @@ async def execute_read_file(  # noqa: PLR0911
     return ReadToolResult(
         content=final_content,
         num_lines=num_lines,
-        start_line=offset,
+        start_line=actual_start_line,
         total_lines=total_lines,
         metadata=metadata,
     )
@@ -383,3 +465,131 @@ async def execute_bash_tool(
         timed_out=result.cancelled_for_timeout,
         stopped_by_user=result.halted,
     )
+
+
+async def execute_download_artifact(
+    tool_input: DownloadArtifactToolInput, working_directory: str
+) -> DownloadArtifactToolResult | ErrorToolResult:
+    """Download an artifact from S3 using a pre-signed URL."""
+
+    # Validate absolute path
+    if not tool_input.file_path.startswith("/"):
+        return ErrorToolResult(
+            error_message=f"File path must be absolute, got relative path: {tool_input.file_path}"
+        )
+
+    # Check if file exists and overwrite is False
+    file_path = Path(tool_input.file_path)
+    if file_path.exists() and not tool_input.overwrite:
+        return ErrorToolResult(
+            error_message=f"File already exists: {tool_input.file_path}. Set overwrite=True to replace it."
+        )
+
+    try:
+        # Download from pre-signed URL
+        async with aiohttp.ClientSession() as session:
+            async with session.get(tool_input.presigned_url) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    return ErrorToolResult(
+                        error_message=f"Failed to download artifact: HTTP {response.status} - {error_text}"
+                    )
+
+                # Create parent directory if needed
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+
+                # Write file
+                content = await response.read()
+                file_path.write_bytes(content)
+
+        file_size = len(content)
+
+        # Try to generate content preview for text files
+        # Attempt to decode as UTF-8 to determine if it's a text file
+        content_preview = None
+        num_lines = None
+        total_lines = None
+        truncated = False
+
+        try:
+            text_content = content.decode("utf-8")
+            lines = text_content.splitlines()
+            total_lines = len(lines)
+
+            # Show first 50 lines
+            preview_limit = 50
+            if len(lines) > preview_limit:
+                preview_lines = lines[:preview_limit]
+                truncated = True
+                num_lines = preview_limit
+            else:
+                preview_lines = lines
+                num_lines = len(lines)
+
+            content_preview = "\n".join(preview_lines)
+        except UnicodeDecodeError:
+            # Binary file, skip preview
+            pass
+
+        return DownloadArtifactToolResult(
+            file_path=tool_input.file_path,
+            artifact_id=tool_input.artifact_id,
+            file_size_bytes=file_size,
+            content_preview=content_preview,
+            num_lines=num_lines,
+            total_lines=total_lines,
+            truncated=truncated,
+        )
+
+    except Exception as e:
+        logger.exception("Failed to download artifact")
+        return ErrorToolResult(error_message=f"Failed to download artifact: {e!s}")
+
+
+async def execute_upload_artifact(
+    tool_input: UploadArtifactToolInput, working_directory: str
+) -> UploadArtifactToolResult | ErrorToolResult:
+    """Upload an artifact to S3 using a pre-signed URL."""
+
+    # Validate absolute path
+    if not tool_input.file_path.startswith("/"):
+        return ErrorToolResult(
+            error_message=f"File path must be absolute, got relative path: {tool_input.file_path}"
+        )
+
+    # Check if file exists
+    file_path = Path(tool_input.file_path)
+    if not file_path.exists():
+        return ErrorToolResult(error_message=f"File not found: {tool_input.file_path}")
+
+    if not file_path.is_file():
+        return ErrorToolResult(
+            error_message=f"Path is not a file: {tool_input.file_path}"
+        )
+
+    try:
+        # Read file
+        content = file_path.read_bytes()
+        file_size = len(content)
+
+        # Upload to pre-signed URL
+        async with aiohttp.ClientSession() as session:
+            headers = {"Content-Type": tool_input.content_type}
+            async with session.put(
+                tool_input.presigned_url, data=content, headers=headers
+            ) as response:
+                if response.status not in (200, 204):
+                    error_text = await response.text()
+                    return ErrorToolResult(
+                        error_message=f"Failed to upload artifact: HTTP {response.status} - {error_text}"
+                    )
+
+        return UploadArtifactToolResult(
+            artifact_id=tool_input.artifact_id,
+            file_size_bytes=file_size,
+            content_type=tool_input.content_type,
+        )
+
+    except Exception as e:
+        logger.exception("Failed to upload artifact")
+        return ErrorToolResult(error_message=f"Failed to upload artifact: {e!s}")

exponent/core/remote_execution/tool_type_utils.py

@@ -0,0 +1,39 @@
+from typing import Any
+
+import msgspec
+
+from exponent.core.remote_execution.cli_rpc_types import ToolResult
+
+
+def to_mostly_xml(tool_result: ToolResult) -> str:
+    """
+    This provides a default textual representation of the tool result. Override it as needed for your tool."""
+    d = msgspec.to_builtins(tool_result)
+    del d["tool_name"]
+    return to_mostly_xml_helper(d)
+
+
+def to_mostly_xml_helper(
+    d: Any,
+) -> str:
+    if isinstance(d, dict):
+        # No outer wrapper at top level, each field gets XML tags
+        parts = []
+        for key, value in d.items():
+            if isinstance(value, list):
+                # Handle lists with item tags
+                list_items = "\n".join(
+                    f"<item>\n{to_mostly_xml_helper(item)}\n</item>" for item in value
+                )
+                parts.append(f"<{key}>\n{list_items}\n</{key}>")
+            elif isinstance(value, dict):
+                # Nested dict
+                parts.append(f"<{key}>\n{to_mostly_xml_helper(value)}\n</{key}>")
+            else:
+                # Scalar value
+                parts.append(f"<{key}>\n{value!s}\n</{key}>")
+        return "\n".join(parts)
+    elif isinstance(d, list):
+        raise ValueError("Lists are not allowed at the top level")
+    else:
+        return str(d)

exponent/core/remote_execution/truncation.py

@@ -17,7 +17,7 @@ from exponent.core.remote_execution.cli_rpc_types import (
 )
 from exponent.core.remote_execution.utils import truncate_output
 
-DEFAULT_CHARACTER_LIMIT = 90_000
+DEFAULT_CHARACTER_LIMIT = 50_000
 DEFAULT_LIST_ITEM_LIMIT = 1000
 DEFAULT_LIST_PREVIEW_ITEMS = 10
 
@@ -173,6 +173,14 @@ class TailTruncation(TruncationStrategy):
         return replace(result, **updates)
 
 
+class NoOpTruncation(TruncationStrategy):
+    def should_truncate(self, result: ToolResult) -> bool:
+        return False
+
+    def truncate(self, result: ToolResult) -> ToolResult:
+        return result
+
+
 class StringListTruncation(TruncationStrategy):
     """Truncation for lists of strings that limits both number of items and individual string length."""
 

exponent/core/remote_execution/types.py

@@ -49,9 +49,48 @@ class PrReviewWorkflowInput(BaseModel):
     pr_number: int
 
 
+class SlackWorkflowInput(BaseModel):
+    discriminator: Literal["slack_workflow"] = "slack_workflow"
+    channel_id: str
+    thread_ts: str
+    slack_url: str | None = None
+    channel_name: str | None = None
+    message_ts: str | None = None
+
+
+class SlackPlanApprovalWorkflowInput(BaseModel):
+    discriminator: Literal["slack_plan_approval"] = "slack_plan_approval"
+    channel_id: str
+    thread_ts: str
+    slack_url: str
+    channel_name: str
+    message_ts: str
+
+
+class SentryWorkflowInput(BaseModel):
+    title: str
+    issue_id: str
+    permalink: str
+
+
+class GenericCloudWorkflowInput(BaseModel):
+    initial_prompt: str
+    system_prompt_override: str | None = None
+    reasoning_level: str = "LOW"
+
+
+WorkflowInput = (
+    PrReviewWorkflowInput
+    | SlackWorkflowInput
+    | SentryWorkflowInput
+    | GenericCloudWorkflowInput
+    | SlackPlanApprovalWorkflowInput
+)
+
+
 class WorkflowTriggerRequest(BaseModel):
     workflow_name: str
-    workflow_input: PrReviewWorkflowInput
+    workflow_input: WorkflowInput
 
 
 class WorkflowTriggerResponse(BaseModel):
@@ -81,6 +120,14 @@ class PythonEnvInfo(BaseModel):
     provider: Literal["venv", "pyenv", "pipenv", "conda"] | None = "pyenv"
 
 
+class PortInfo(BaseModel):
+    process_name: str
+    port: int
+    protocol: str
+    pid: int | None
+    uptime_seconds: float | None
+
+
 class SystemInfo(BaseModel):
     name: str
     cwd: str
@@ -88,6 +135,7 @@ class SystemInfo(BaseModel):
     shell: str
     git: GitInfo | None
     python_env: PythonEnvInfo | None
+    port_usage: list[PortInfo] | None = None
 
 
 class HeartbeatInfo(BaseModel):
@@ -208,8 +256,18 @@ class PromptAttachment(BaseModel):
     prompt_content: str
 
 
+class SQLAttachment(BaseModel):
+    attachment_type: Literal["sql"] = "sql"
+    query_content: str
+    query_id: str
+
+
 MessageAttachment = Annotated[
-    FileAttachment | URLAttachment | TableSchemaAttachment | PromptAttachment,
+    FileAttachment
+    | URLAttachment
+    | TableSchemaAttachment
+    | PromptAttachment
+    | SQLAttachment,
     Field(discriminator="attachment_type"),
 ]
 
@@ -509,6 +567,10 @@ class ChatMode(str, Enum):
     DATABASE = "DATABASE"  # chat with database connection
     WORKFLOW = "WORKFLOW"
 
+    @classmethod
+    def requires_cli(cls, mode: "ChatMode") -> bool:
+        return mode not in [cls.DATABASE]
+
 
 class ChatSource(str, Enum):
     CLI_SHELL = "CLI_SHELL"
@@ -516,6 +578,8 @@ class ChatSource(str, Enum):
     WEB = "WEB"
     DESKTOP_APP = "DESKTOP_APP"
     VSCODE_EXTENSION = "VSCODE_EXTENSION"
+    SLACK_APP = "SLACK_APP"
+    SENTRY_APP = "SENTRY_APP"
 
 
 class CLIConnectedState(BaseModel):
@@ -529,30 +593,18 @@ class CLIConnectedState(BaseModel):
 
 
 class DevboxConnectedState(str, Enum):
-    # TODO: Only needed if we create devbox async
-    INITIALIZED = "INITIALIZED"
     # The chat has been initialized, but the devbox is still loading
     DEVBOX_LOADING = "DEVBOX_LOADING"
-    # Devbox is ready to use but not tied to a chat
-    DEVBOX_READY = "DEVBOX_READY"
     # CLI is connected and running on devbox
     CONNECTED = "CONNECTED"
-    # CLI has disconnected
-    # TODO: what condition?
-    CLI_DISCONNECTED = "CLI_DISCONNECTED"
-    # CLI has an error, devbox is running
-    CLI_ERROR = "CLI_ERROR"
     # Devbox has an error
     DEVBOX_ERROR = "DEVBOX_ERROR"
     # Devbox is going to idle
-    GOING_TO_IDLE = "GOING_TO_IDLE"
-    # Devbox is idle
-    IDLE = "IDLE"
-    # Devbox is going to idle
-    RESUMING_FROM_IDLE = "RESUMING_FROM_IDLE"
-    # Devbox_shutdown
-    # TODO: In theory our terminal state, do we want to name something different?
-    DEVBOX_SHUTDOWN = "DEVBOX_SHUTDOWN"
+    PAUSING = "PAUSING"
+    # Devbox has been paused and is not running
+    PAUSED = "PAUSED"
+    # Dev box is starting up. Sandbox exists but devbox is not running
+    RESUMING = "RESUMING"
 
 
 class CloudConnectedState(BaseModel):

exponent/utils/version.py

@@ -135,8 +135,8 @@ def _get_upgrade_command_str(version: str) -> str:
 
 def _new_version_str(current_version: str, new_version: str) -> str:
     return (
-        f"\n{click.style('A new Exponent version is available:', fg='cyan')} {new_version} (current: {current_version})\n"
-        f"See {click.style('https://docs.exponent.run/installation', underline=True)} for details.\n"
+        f"\n{click.style('A new Indent version is available:', fg='cyan')} {new_version} (current: {current_version})\n"
+        f"See {click.style('https://docs.indent.com/help_and_resources/troubleshooting#installation-methods', underline=True)} for details.\n"
     )
 
 
@@ -148,6 +148,7 @@ def _ask_continue_without_upgrading() -> None:
     if click.confirm("Continue without upgrading?", default=False):
         click.secho("Using outdated version.", fg="red")
     else:
+        click.secho("Exiting due to outdated version", fg="red")
         sys.exit(1)
 
 
@@ -196,15 +197,15 @@ def upgrade_exponent(
 
     if result.returncode != 0:
         click.secho(
-            "\nFailed to upgrade Exponent. See https://docs.exponent.run/installation for help, or reach out to team@exponent.run.",
+            "\nFailed to upgrade Indent. See https://docs.indent.com/help_and_resources/troubleshooting#installation-methods for help, or reach out to team@indent.com",
             fg="red",
         )
         sys.exit(2)
 
-    click.secho(f"Successfully upgraded Exponent to version {new_version}!", fg="green")
+    click.secho(f"Successfully upgraded Indent to version {new_version}!", fg="green")
 
-    click.echo("Re-run exponent to use the latest version.")
-    sys.exit(1)
+    click.echo("Re-run indent to use the latest version.")
+    sys.exit(0)
 
 
 def _upgrade_thread_worker(
@@ -260,7 +261,7 @@ def upgrade_exponent_in_background(
         return
 
     click.secho(
-        f"\nUpgrading Exponent from {current_version} to {new_version} (this will take effect next time)\n",
+        f"\nUpgrading Indent from {current_version} to {new_version} (this will take effect next time)\n",
         fg="cyan",
         bold=True,
     )

{indent-0.1.13.dist-info → indent-0.1.28.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: indent
-Version: 0.1.13
+Version: 0.1.28
 Summary: Indent is an AI Pair Programmer
 Author-email: Sashank Thupukari <sashank@exponent.run>
 Requires-Python: <3.13,>=3.10
+Requires-Dist: aiohttp>=3.13.2
 Requires-Dist: anyio<5,>=4.6.0
 Requires-Dist: async-timeout<5,>=4.0.3; python_version < '3.11'
 Requires-Dist: beautifulsoup4[chardet]<5,>=4.13.4
@@ -22,6 +23,8 @@ Requires-Dist: msgspec>=0.19.0
 Requires-Dist: packaging~=24.1
 Requires-Dist: pip<26,>=25.0.1
 Requires-Dist: prompt-toolkit<4,>=3.0.36
+Requires-Dist: psutil<7,>=5.9.0
+Requires-Dist: pydantic-ai==0.0.30
 Requires-Dist: pydantic-settings<3,>=2.2.1
 Requires-Dist: pydantic[email]<3,>=2.6.4
 Requires-Dist: pygit2<2,>=1.15.0
@@ -29,7 +32,7 @@ Requires-Dist: python-ripgrep==0.0.9
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: questionary<3,>=2.0.1
 Requires-Dist: rapidfuzz<4,>=3.9.0
-Requires-Dist: rich<14,>=13.7.1
+Requires-Dist: rich>=13.7.1
 Requires-Dist: sentry-sdk<3,>=2.1.1
 Requires-Dist: toml<0.11,>=0.10.2
 Requires-Dist: websockets~=15.0