indent 0.1.16__tar.gz → 0.1.18__tar.gz

{indent-0.1.16 → indent-0.1.18}/.gitignore

@@ -14,10 +14,14 @@ workflow_input.json
 .anthropic.log.json
 CLAUDE.local.md
 indent.local.md
+plan.md
 
 # C extensions
 *.so
 
+# logs
+logs/
+
 # Distribution / packaging
 .Python
 build/
@@ -64,6 +68,11 @@ coverage.xml
 .hypothesis/
 .pytest_cache/
 log.txt
+*regression_results*.json
+
+# Profiling
+*profile.json
+*.callgrind
 
 # Translations
 *.mo
@@ -179,3 +188,8 @@ private-key.pem
 
 # Generated version files
 python_modules/exponent/exponent/__init__.py
+
+# LLM plan variants
+plans/*
+plan.md
+.PLAN.md

{indent-0.1.16 → indent-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: indent
-Version: 0.1.16
+Version: 0.1.18
 Summary: Indent is an AI Pair Programmer
 Author-email: Sashank Thupukari <sashank@exponent.run>
 Requires-Python: <3.13,>=3.10

{indent-0.1.16 → indent-0.1.18}/exponent/__init__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.16'
-__version_tuple__ = version_tuple = (0, 1, 16)
+__version__ = version = '0.1.18'
+__version_tuple__ = version_tuple = (0, 1, 18)
 
 __commit_id__ = commit_id = None

{indent-0.1.16 → indent-0.1.18}/exponent/cli.py

@@ -7,7 +7,6 @@ from exponent.commands.config_commands import config_cli
 from exponent.commands.run_commands import run, run_cli
 from exponent.commands.types import ExponentGroup, exponent_cli_group
 from exponent.commands.upgrade import upgrade_cli
-from exponent.commands.workflow_commands import workflow_cli
 from exponent.utils.version import (
     get_installed_version,
 )
@@ -34,7 +33,6 @@ sources: list[ExponentGroup] = [
     run_cli,  # Run AI chat commands
     upgrade_cli,  # Upgrade-related commands
     cloud_cli,  # Cloud commands
-    workflow_cli,  # Workflow commands
 ]
 
 for source in sources:

{indent-0.1.16 → indent-0.1.18}/exponent/commands/common.py

@@ -37,7 +37,8 @@ from exponent.core.remote_execution.exceptions import (
 )
 from exponent.core.remote_execution.files import FileCache
 from exponent.core.remote_execution.git import get_git_info
-from exponent.core.remote_execution.types import ChatSource, GitInfo
+from exponent.core.remote_execution.session import send_exception_log
+from exponent.core.remote_execution.types import ChatSource
 
 load_dotenv()
 
@@ -212,6 +213,13 @@ def run_until_complete(coro: Coroutine[Any, Any, Any]) -> Any:
         except asyncio.CancelledError:
             pass
     except ExponentError as e:
+        try:
+            settings = get_settings()
+            loop.run_until_complete(
+                send_exception_log(e, session=None, settings=settings)
+            )
+        except Exception:
+            pass
         click.secho(f"Encountered error: {e}", fg="red")
         click.secho(
             "The Indent team has been notified, "
@@ -321,7 +329,9 @@ async def start_client(
         if prompt:
             # If given a prompt, we also need to send a request
             # to kick off the initial turn loop for the chat
-            raise NotImplementedError("Kicking off with initial prompt not implemented")
+            aux_coros.append(
+                start_chat_turn(api_key, base_api_url, base_ws_url, chat_uuid, prompt)
+            )
         elif workflow_id:
             # Similarly, if given a workflow ID, we need to send
             # a request to kick off the workflow
@@ -346,34 +356,6 @@ async def create_chat(
         return None
 
 
-async def get_gh_app_installation_token(
-    api_key: str, base_api_url: str, base_ws_url: str, git_info: GitInfo
-) -> dict[str, Any] | None:
-    try:
-        async with RemoteExecutionClient.session(
-            api_key, base_api_url, base_ws_url, os.getcwd()
-        ) as client:
-            return await client.get_gh_installation_token(git_info)
-    except (httpx.ConnectError, ExponentError) as e:
-        click.secho(f"Error: {e}", fg="red")
-        return None
-
-
-async def verify_gh_app_installation(
-    api_key: str, base_api_url: str, base_ws_url: str, git_info: GitInfo
-) -> bool:
-    try:
-        async with RemoteExecutionClient.session(
-            api_key, base_api_url, base_ws_url, os.getcwd()
-        ) as client:
-            res = await client.get_gh_installation_token(git_info)
-            if "token" in res:
-                return True
-    except (httpx.ConnectError, ExponentError) as e:
-        click.secho(f"Error: {e}", fg="red")
-    return False
-
-
 async def set_login_complete(api_key: str, base_api_url: str, base_ws_url: str) -> None:
     graphql_client = GraphQLClient(
         api_key=api_key, base_api_url=base_api_url, base_ws_url=base_ws_url

{indent-0.1.16 → indent-0.1.18}/exponent/commands/run_commands.py

@@ -105,8 +105,7 @@ def run(
         sys.exit(1)
 
     if (
-        not prompt
-        and (not inside_ssh_session())
+        (not inside_ssh_session())
         and (not workflow_id)
         # If the user specified a chat ID, they probably don't want to re-launch the chat
         and (not chat_id)

{indent-0.1.16 → indent-0.1.18}/exponent/core/remote_execution/cli_rpc_types.py

@@ -51,6 +51,7 @@ class ErrorToolResult(ToolResult, tag="error"):
 
 
 READ_TOOL_NAME = "read"
+READ_TOOL_ARTIFACT_NAME = "read_tool_artifact"
 
 
 class ReadToolInput(ToolInput, tag=READ_TOOL_NAME):
@@ -80,6 +81,15 @@ class ReadToolResult(ToolResult, tag=READ_TOOL_NAME):
         return "\n".join(lines)
 
 
+class ReadToolArtifactResult(ToolResult, tag=READ_TOOL_ARTIFACT_NAME):
+    s3_uri: str
+    file_path: str
+    media_type: str
+
+    def to_text(self) -> str:
+        return f"[Image artifact uploaded to {self.s3_uri}]"
+
+
 LIST_TOOL_NAME = "ls"
 
 
@@ -217,6 +227,7 @@ PartialToolResultType = PartialBashToolResult
 
 ToolResultType = (
     ReadToolResult
+    | ReadToolArtifactResult
     | WriteToolResult
     | ListToolResult
     | GlobToolResult
@@ -273,6 +284,16 @@ class KeepAliveCliChatResponse(msgspec.Struct, tag="keep_alive_cli_chat"):
     pass
 
 
+class GenerateUploadUrlRequest(msgspec.Struct, tag="generate_upload_url"):
+    s3_key: str
+    content_type: str
+
+
+class GenerateUploadUrlResponse(msgspec.Struct, tag="generate_upload_url"):
+    upload_url: str
+    s3_uri: str
+
+
 class CliRpcRequest(msgspec.Struct):
     request_id: str
     request: (
@@ -283,6 +304,7 @@ class CliRpcRequest(msgspec.Struct):
         | BatchToolExecutionRequest
         | SwitchCLIChatRequest
         | KeepAliveCliChatRequest
+        | GenerateUploadUrlRequest
     )
 
 
@@ -305,4 +327,5 @@ class CliRpcResponse(msgspec.Struct):
         | HttpResponse
         | SwitchCLIChatResponse
         | KeepAliveCliChatResponse
+        | GenerateUploadUrlResponse
     )

{indent-0.1.16 → indent-0.1.18}/exponent/core/remote_execution/client.py

@@ -31,6 +31,8 @@ from exponent.core.remote_execution.cli_rpc_types import (
     CliRpcResponse,
     ErrorResponse,
     ErrorToolResult,
+    GenerateUploadUrlRequest,
+    GenerateUploadUrlResponse,
     GetAllFilesRequest,
     GetAllFilesResponse,
     HttpRequest,
@@ -52,6 +54,7 @@ from exponent.core.remote_execution.http_fetch import fetch_http_content
 from exponent.core.remote_execution.session import (
     RemoteExecutionClientSession,
     get_session,
+    send_exception_log,
 )
 from exponent.core.remote_execution.tool_execution import (
     execute_bash_tool,
@@ -62,7 +65,6 @@ from exponent.core.remote_execution.types import (
     ChatSource,
     CLIConnectedState,
     CreateChatResponse,
-    GitInfo,
     HeartbeatInfo,
     RemoteExecutionResponseType,
     RunWorkflowRequest,
@@ -115,6 +117,13 @@ class RemoteExecutionClient:
         # Track last request time for timeout functionality
         self._last_request_time: float | None = None
 
+        # Track pending upload URL requests
+        self._pending_upload_requests: dict[
+            str, asyncio.Future[GenerateUploadUrlResponse]
+        ] = {}
+        self._upload_request_lock = asyncio.Lock()
+        self._websocket: ClientConnection | None = None
+
     @property
     def working_directory(self) -> str:
         return self.current_session.working_directory
@@ -186,7 +195,21 @@ class RemoteExecutionClient:
         self._last_request_time = time.time()
 
         msg_data = json.loads(msg)
-        if msg_data["type"] != "request":
+        if msg_data["type"] == "result":
+            data = json.dumps(msg_data["data"])
+            try:
+                response = msgspec.json.decode(data, type=CliRpcResponse)
+                if isinstance(response.response, GenerateUploadUrlResponse):
+                    async with self._upload_request_lock:
+                        if response.request_id in self._pending_upload_requests:
+                            future = self._pending_upload_requests.pop(
+                                response.request_id
+                            )
+                            future.set_result(response.response)
+            except Exception as e:
+                logger.error(f"Error handling upload URL response: {e}")
+            return None
+        elif msg_data["type"] != "request":
             return None
 
         data = json.dumps(msg_data["data"])
@@ -357,6 +380,10 @@ class RemoteExecutionClient:
                         await results.put(response)
                 except Exception as e:
                     logger.info(f"Error handling request {request}:\n\n{e}")
+                    try:
+                        await send_exception_log(e, session=self.current_session)
+                    except Exception:
+                        pass
                     async with results_lock:
                         await results.put(
                             CliRpcResponse(
@@ -441,6 +468,8 @@ class RemoteExecutionClient:
         if connection_tracker is not None:
             await connection_tracker.set_connected(True)
 
+        self._websocket = websocket
+
         beats: asyncio.Queue[HeartbeatInfo] = asyncio.Queue()
         requests: asyncio.Queue[CliRpcRequest] = asyncio.Queue()
         results: asyncio.Queue[CliRpcResponse] = asyncio.Queue()
@@ -523,13 +552,6 @@ class RemoteExecutionClient:
         )
         return await deserialize_api_response(response, CreateChatResponse)
 
-    async def get_gh_installation_token(self, git_info: GitInfo) -> dict[str, Any]:
-        response = await self.api_client.post(
-            "/github_app/exchange_token",
-            json=git_info.model_dump(),
-        )
-        return cast(dict[str, Any], response.json())
-
     # deprecated
     async def run_workflow(self, chat_uuid: str, workflow_id: str) -> dict[str, Any]:
         response = await self.api_client.post(
@@ -582,6 +604,38 @@ class RemoteExecutionClient:
         logger.info(f"Heartbeat response: {connected_state}")
         return connected_state
 
+    async def request_upload_url(
+        self, s3_key: str, content_type: str
+    ) -> GenerateUploadUrlResponse:
+        if self._websocket is None:
+            raise RuntimeError("No active websocket connection")
+
+        request_id = str(uuid.uuid4())
+        request = CliRpcRequest(
+            request_id=request_id,
+            request=GenerateUploadUrlRequest(s3_key=s3_key, content_type=content_type),
+        )
+
+        future: asyncio.Future[GenerateUploadUrlResponse] = asyncio.Future()
+        async with self._upload_request_lock:
+            self._pending_upload_requests[request_id] = future
+
+        try:
+            await self._websocket.send(
+                json.dumps({"type": "request", "data": msgspec.to_builtins(request)})
+            )
+
+            response = await asyncio.wait_for(future, timeout=30)
+            return response
+        except TimeoutError:
+            async with self._upload_request_lock:
+                self._pending_upload_requests.pop(request_id, None)
+            raise RuntimeError("Timeout waiting for upload URL response")
+        except Exception as e:
+            async with self._upload_request_lock:
+                self._pending_upload_requests.pop(request_id, None)
+            raise e
+
     async def handle_request(self, request: CliRpcRequest) -> CliRpcResponse:
         # Update last request time for timeout functionality
         self._last_request_time = time.time()
@@ -596,7 +650,7 @@ class RemoteExecutionClient:
                     )
                 else:
                     raw_result = await execute_tool(  # type: ignore[assignment]
-                        request.request.tool_input, self.working_directory
+                        request.request.tool_input, self.working_directory, self
                     )
                 tool_result = truncate_result(raw_result)
                 return CliRpcResponse(
@@ -623,7 +677,9 @@ class RemoteExecutionClient:
                             )
                         )
                     else:
-                        coros.append(execute_tool(tool_input, self.working_directory))
+                        coros.append(
+                            execute_tool(tool_input, self.working_directory, self)
+                        )
 
                 results: list[ToolResultType | BaseException] = await asyncio.gather(
                     *coros, return_exceptions=True

{indent-0.1.16 → indent-0.1.18}/exponent/core/remote_execution/languages/shell_streaming.py

@@ -149,7 +149,10 @@ async def execute_shell_streaming(  # noqa: PLR0915
     def on_timeout() -> None:
         nonlocal timed_out
         timed_out = True
-        process.kill()
+        try:
+            process.kill()
+        except ProcessLookupError:
+            pass
 
     try:
         halt_task = asyncio.create_task(monitor_halt()) if should_halt else None

{indent-0.1.16 → indent-0.1.18}/exponent/core/remote_execution/tool_execution.py

@@ -3,6 +3,7 @@ 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
 
@@ -19,6 +20,7 @@ from exponent.core.remote_execution.cli_rpc_types import (
     GrepToolResult,
     ListToolInput,
     ListToolResult,
+    ReadToolArtifactResult,
     ReadToolInput,
     ReadToolResult,
     ToolInputType,
@@ -26,6 +28,9 @@ from exponent.core.remote_execution.cli_rpc_types import (
     WriteToolInput,
     WriteToolResult,
 )
+
+if TYPE_CHECKING:
+    from exponent.core.remote_execution.client import RemoteExecutionClient
 from exponent.core.remote_execution.code_execution import (
     execute_code_streaming,
 )
@@ -45,10 +50,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):
@@ -69,9 +76,20 @@ 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
-) -> ReadToolResult | ErrorToolResult:
+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 | ReadToolArtifactResult | ErrorToolResult:
     # Validate absolute path requirement
     if not tool_input.file_path.startswith("/"):
         return ErrorToolResult(
@@ -82,16 +100,44 @@ 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:
+            import aiohttp
+
+            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)
+
+            async with aiohttp.ClientSession() as session:
+                f = await file.open("rb")
+                async with f:
+                    file_data = await f.read()
+                    async with session.put(
+                        upload_response.upload_url,
+                        data=file_data,
+                        headers={"Content-Type": media_type},
+                    ) as resp:
+                        if resp.status != 200:
+                            raise RuntimeError(
+                                f"Upload failed with status {resp.status}"
+                            )
+
+            return 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 +184,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 +194,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 +250,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,
     )

{indent-0.1.16 → indent-0.1.18}/exponent/core/remote_execution/truncation.py

@@ -11,6 +11,7 @@ from exponent.core.remote_execution.cli_rpc_types import (
     GlobToolResult,
     GrepToolResult,
     ListToolResult,
+    ReadToolArtifactResult,
     ReadToolResult,
     ToolResult,
     WriteToolResult,
@@ -173,6 +174,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."""
 
@@ -264,6 +273,7 @@ class StringListTruncation(TruncationStrategy):
 
 TRUNCATION_REGISTRY: dict[type[ToolResult], TruncationStrategy] = {
     ReadToolResult: StringFieldTruncation("content"),
+    ReadToolArtifactResult: NoOpTruncation(),
     WriteToolResult: StringFieldTruncation("message"),
     BashToolResult: TailTruncation("shell_output"),
     GrepToolResult: StringListTruncation("matches"),

{indent-0.1.16 → indent-0.1.18}/exponent/core/remote_execution/types.py

@@ -52,6 +52,9 @@ class PrReviewWorkflowInput(BaseModel):
 class SlackWorkflowInput(BaseModel):
     channel_id: str
     thread_ts: str
+    slack_url: str | None = None
+    channel_name: str | None = None
+    message_ts: str | None = None
 
 
 WorkflowInput = PrReviewWorkflowInput | SlackWorkflowInput
@@ -216,8 +219,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"),
 ]
 
@@ -542,30 +555,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):

{indent-0.1.16 → indent-0.1.18}/exponent/utils/version.py

@@ -260,7 +260,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.16 → indent-0.1.18}/pyproject.toml

@@ -49,7 +49,7 @@ dev = [
     "coverage>=7.6.1,<8",
     "freezegun>=1.5.1,<2",
     "pytest>=8.3.3,<9",
-    "pytest-asyncio>=0.24.0,<0.25",
+    "pytest-asyncio>=0.24.0,<1.3",
     "pytest-cov>=5.0.0,<6",
     "pytest-httpx>=0.31.0",
     "pytest-xdist>=3.6.1,<4",

indent-0.1.16/exponent/commands/workflow_commands.py

@@ -1,111 +0,0 @@
-import asyncio
-import os
-import sys
-from typing import cast
-
-import click
-
-from exponent.commands.run_commands import run_chat
-from exponent.commands.settings import use_settings
-from exponent.commands.types import exponent_cli_group
-from exponent.core.config import Settings
-from exponent.core.remote_execution.client import RemoteExecutionClient, WSDisconnected
-from exponent.core.remote_execution.types import (
-    PrReviewWorkflowInput,
-    WorkflowTriggerResponse,
-)
-
-
-@exponent_cli_group(name="workflow")
-def workflow_cli() -> None:
-    """Workflow commands."""
-    pass
-
-
-@workflow_cli.group(hidden=True)
-def workflow() -> None:
-    """Workflow management commands."""
-    pass
-
-
-@workflow.command()
-@use_settings
-@click.argument("workflow_type", type=click.STRING)
-def trigger(settings: Settings, workflow_type: str) -> None:
-    """Trigger a workflow."""
-
-    if not settings.api_key:
-        raise click.ClickException(
-            "No API key found. Use `indent login` to set your API key."
-        )
-
-    if workflow_type != "pr_review":
-        raise click.UsageError("Invalid workflow name. Only 'pr_review' is supported.")
-
-    loop = asyncio.get_event_loop()
-    response = loop.run_until_complete(trigger_pr_review_workflow(settings))
-
-    while True:
-        result = run_chat(
-            loop, settings.api_key, response.chat_uuid, settings, None, None, None
-        )
-        if result is None or isinstance(result, WSDisconnected):
-            # NOTE: None here means that handle_connection_changes exited
-            # first. We should likely have a different message for this.
-            if result and result.error_message:
-                click.secho(f"Error: {result.error_message}", fg="red")
-                sys.exit(10)
-            else:
-                click.echo("Disconnected upon user request, shutting down...")
-                break
-        else:
-            raise click.ClickException("Workflow run exited unexpectedly")
-
-
-async def _subprocess_check_output(command: str) -> str:
-    process = await asyncio.create_subprocess_shell(
-        command,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.STDOUT,
-    )
-    stdout, _ = await process.communicate()
-
-    if process.returncode != 0:
-        output = stdout.decode().strip()
-        raise click.ClickException(
-            f"Command '{command}' failed with exit code {process.returncode}:\n{output}"
-        )
-
-    return stdout.decode().strip()
-
-
-async def trigger_pr_review_workflow(settings: Settings) -> WorkflowTriggerResponse:
-    origin_url = await _subprocess_check_output("git ls-remote --get-url origin")
-    url = origin_url.strip().removesuffix(".git")
-    remote = url.split(":")[-1]
-    owner, repo = remote.split("/")[-2:]
-
-    pr_number_str = os.environ.get("PR_NUMBER")
-    if not pr_number_str:
-        raise click.ClickException("PR_NUMBER environment variable is not set")
-    try:
-        pr_number = int(pr_number_str)
-    except ValueError:
-        raise click.ClickException(
-            "PR_NUMBER environment variable is not a valid integer"
-        )
-
-    async with RemoteExecutionClient.session(
-        api_key=cast(str, settings.api_key),
-        base_url=settings.get_base_api_url(),
-        base_ws_url=settings.get_base_ws_url(),
-        working_directory=os.getcwd(),
-    ) as client:
-        return await client.trigger_workflow(
-            workflow_name="pr_review",
-            workflow_input=PrReviewWorkflowInput(
-                repo_owner=owner,
-                repo_name=repo,
-                pr_number=pr_number,
-            ),
-        )