indent 0.0.8__py3-none-any.whl

exponent/commands/github_app_commands.py

@@ -0,0 +1,211 @@
+import asyncio
+import json
+from pathlib import Path
+import subprocess
+import sys
+from uuid import uuid4
+import webbrowser
+
+import click
+from git import GitCommandError, Repo
+
+from exponent.commands.common import (
+    redirect_to_login,
+    verify_gh_app_installation,
+)
+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.git import get_git_info
+
+
+@exponent_cli_group()
+def github_app_cli() -> None:
+    """Run AI-powered chat sessions."""
+    pass
+
+
+@github_app_cli.command()
+@use_settings
+def install_github_app(
+    settings: Settings,
+) -> None:
+    """Start or reconnect to an Exponent session."""
+    if not settings.api_key:
+        redirect_to_login(settings)
+        return
+
+    loop = asyncio.get_event_loop()
+
+    api_key = settings.api_key
+    base_api_url = settings.get_base_api_url()
+    base_ws_url = settings.get_base_ws_url()
+
+    git_info = asyncio.run(get_git_info("."))
+    if not git_info:
+        raise RuntimeError("Not running inside of valid git repository")
+
+    install_url = "https://github.com/apps/indent-com/installations/new"
+    webbrowser.open(install_url)
+
+    click.confirm(
+        "Press enter once you've installed the github app.",
+        default=True,
+        abort=True,
+        prompt_suffix="",
+    )
+
+    click.secho("Verifying installation...", fg="yellow")
+    verified = loop.run_until_complete(
+        verify_gh_app_installation(api_key, base_api_url, base_ws_url, git_info)
+    )
+
+    if verified:
+        click.secho("Verified!", fg="green")
+    else:
+        click.secho("No verification found :(", fg="red")
+        sys.exit(1)
+
+    click.secho("Creating workflow file...", fg="yellow")
+    _create_workflow_yaml()
+
+
+WORKFLOW_YAML = """
+name: Indent Action
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  indent:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@indent')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@indent')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@indent')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@indent') || contains(github.event.issue.title, '@indent')))
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Generate token for Indent app
+        id: generate_token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.INDENT_APP_ID }}
+          private-key: ${{ secrets.INDENT_APP_PRIVATE_KEY }}
+
+      - name: Respond to mention
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ steps.generate_token.outputs.token }}
+          script: |
+            const issue_number = context.payload.issue?.number || 
+                               context.payload.pull_request?.number ||
+                               context.payload.review?.pull_request?.number;
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issue_number,
+              body: 'Hi it\'s me, Indent'
+            });
+""".lstrip()
+
+
+def _create_workflow_yaml() -> None:
+    git_branch = f"indent-workflow-{uuid4()}"
+    workflow_file = "indent-review.yml"
+
+    # 1. Locate the repository (searches upward until it finds .git).
+    repo = Repo(Path.cwd(), search_parent_directories=True)
+    if repo.bare or not repo.working_tree_dir:
+        sys.exit("Error: cannot operate inside a bare repository.")
+
+    original_branch = repo.active_branch.name if not repo.head.is_detached else None
+
+    # 2. Create or reuse the branch, then check it out.
+    try:
+        branch_ref = repo.create_head(git_branch)
+    except GitCommandError:
+        branch_ref = repo.heads[git_branch]
+    branch_ref.checkout()
+
+    # 3. Ensure workflow directory exists.
+    wf_dir = Path(repo.working_tree_dir) / ".github" / "workflows"
+    wf_dir.mkdir(parents=True, exist_ok=True)
+
+    yml = wf_dir / workflow_file
+    if not yml.exists():
+        yml.write_text(WORKFLOW_YAML)
+        # 5. Stage & commit.
+        repo.index.add([str(yml)])
+        repo.index.commit("Add Indent workflow template")
+        print(
+            f"Created {yml.relative_to(repo.working_tree_dir)} "
+            f"on branch '{git_branch}'."
+        )
+    else:
+        print(
+            f"{yml.relative_to(repo.working_tree_dir)} already exists; nothing to do."
+        )
+
+    subprocess.run(
+        ["git", "push", "-u", "origin", git_branch],
+        cwd=repo.working_tree_dir,
+        check=True,
+        capture_output=False,
+        text=True,
+    )
+
+    pr_url: str | None = None
+    pr_title = f"Add Indent workflow ({workflow_file})"
+    pr_body = "This PR introduces an Indent github action workflow"
+
+    def run_gh(cmd: list[str]) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            ["gh", *cmd],
+            cwd=repo.working_tree_dir,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+    try:
+        # Does a PR already exist for this head branch?
+        result = run_gh(["pr", "view", git_branch, "--json", "url"])
+        pr_url = json.loads(result.stdout)["url"]
+    except subprocess.CalledProcessError:
+        # No PR yet → create one
+        base = original_branch or repo.remotes.origin.refs[0].name.split("/")[-1]
+        run_gh(
+            [
+                "pr",
+                "create",
+                "--head",
+                git_branch,
+                "--base",
+                base,
+                "--title",
+                pr_title,
+                "--body",
+                pr_body,
+            ]
+        )
+        # Fetch the newly created URL
+        result = run_gh(["pr", "view", git_branch, "--json", "url"])
+        pr_url = json.loads(result.stdout)["url"]
+
+    if pr_url:
+        click.secho(f"PR: {pr_url}", fg="green")
+        webbrowser.open(pr_url)
+    else:
+        click.secho("Failed to create PR!", fg="red")
+
+    if original_branch:
+        repo.git.checkout(original_branch)

exponent/commands/listen_commands.py

@@ -0,0 +1,96 @@
+import asyncio
+
+import click
+from websockets.exceptions import ConnectionClosed
+
+from exponent.commands.settings import use_settings
+from exponent.commands.shell_commands import LiveView
+from exponent.commands.theme import get_theme
+from exponent.commands.types import exponent_cli_group
+from exponent.core.config import Settings
+from exponent.core.graphql.client import GraphQLClient
+from exponent.core.graphql.subscriptions import INDENT_CHAT_EVENT_STREAM_SUBSCRIPTION
+
+
+@exponent_cli_group(hidden=True)
+def listen_cli() -> None:
+    pass
+
+
+@listen_cli.command()
+@click.option("--chat-id", help="ID of the chat to listen to", required=True)
+@click.option(
+    "--known-event-uuids",
+    help="Comma-separated list of known event UUIDs to skip",
+    default="",
+)
+@use_settings
+def listen(settings: Settings, chat_id: str, known_event_uuids: str) -> None:
+    """Listen to events from an indent chat session."""
+    api_key = settings.api_key
+    if not api_key:
+        raise click.UsageError("API key is not set")
+
+    base_api_url = settings.get_base_api_url()
+    base_ws_url = settings.get_base_ws_url()
+
+    gql_client = GraphQLClient(api_key, base_api_url, base_ws_url)
+
+    # Parse known event UUIDs
+    known_uuids = []
+    if known_event_uuids:
+        known_uuids = [
+            uuid.strip() for uuid in known_event_uuids.split(",") if uuid.strip()
+        ]
+
+    # Set up the live view with theme
+    theme = get_theme(settings.options.use_default_colors)
+    live_view = LiveView(theme, render_user_messages=True)
+
+    asyncio.run(_listen(gql_client, chat_id, known_uuids, live_view))
+
+
+async def _listen(
+    gql_client: GraphQLClient,
+    chat_id: str,
+    known_event_uuids: list[str],
+    live_view: LiveView,
+) -> None:
+    """Internal listen function that handles the WebSocket subscription."""
+    while True:
+        try:
+            variables = {
+                "chatUuid": chat_id,
+                "lastKnownFullEventUuid": known_event_uuids[-1]
+                if known_event_uuids
+                else None,
+            }
+
+            async for response in gql_client.subscribe(
+                INDENT_CHAT_EVENT_STREAM_SUBSCRIPTION, variables
+            ):
+                event = response["indentChatEventStream"]
+                kind = event["__typename"]
+
+                # Handle different event types
+                if kind in ["UserEvent", "AssistantEvent", "SystemEvent"]:
+                    live_view.render_event(kind, event)
+                elif kind == "Error":
+                    print(f"Error: {event.get('message', 'Unknown error')}")
+                elif kind == "UnauthenticatedError":
+                    print(
+                        f"Authentication error: {event.get('message', 'Unauthenticated')}"
+                    )
+                    break
+                else:
+                    print(f"Unknown event type: {kind}")
+
+        except ConnectionClosed:
+            print("WebSocket disconnected, reconnecting...")
+            await asyncio.sleep(1)
+        except KeyboardInterrupt:
+            print("\nDisconnecting...")
+            break
+        except Exception as e:
+            print(f"Error: {e}")
+            await asyncio.sleep(1)

exponent/commands/run_commands.py

@@ -0,0 +1,208 @@
+import asyncio
+import sys
+import time
+
+import click
+
+from exponent.commands.common import (
+    check_inside_git_repo,
+    check_running_from_home_directory,
+    check_ssl,
+    create_chat,
+    inside_ssh_session,
+    redirect_to_login,
+    start_client,
+)
+from exponent.commands.settings import use_settings
+from exponent.commands.types import exponent_cli_group
+from exponent.commands.utils import (
+    ConnectionTracker,
+    Spinner,
+    launch_exponent_browser,
+    print_exponent_message,
+)
+from exponent.core.config import Settings
+from exponent.core.remote_execution.client import (
+    REMOTE_EXECUTION_CLIENT_EXIT_INFO,
+    SwitchCLIChat,
+    WSDisconnected,
+)
+from exponent.core.remote_execution.types import ChatSource
+from exponent.core.remote_execution.utils import assert_unreachable
+from exponent.utils.version import check_exponent_version_and_upgrade
+
+try:
+    # this is an optional dependency for python <3.11
+    from async_timeout import timeout
+except ImportError:  # pragma: no cover
+    from asyncio import timeout
+
+
+@exponent_cli_group()
+def run_cli() -> None:
+    """Run AI-powered chat sessions."""
+    pass
+
+
+@run_cli.command()
+@click.option(
+    "--chat-id",
+    help="ID of an existing chat session to reconnect",
+    required=False,
+    prompt_required=False,
+    prompt="Enter the chat ID to reconnect to",
+)
+@click.option(
+    "--prompt",
+    help="Start a chat with a given prompt.",
+)
+@click.option(
+    "--workflow-id",
+    hidden=True,
+    required=False,
+)
+@use_settings
+def run(
+    settings: Settings,
+    chat_id: str | None = None,
+    prompt: str | None = None,
+    workflow_id: str | None = None,
+) -> None:
+    """Start or reconnect to an Exponent session."""
+    check_exponent_version_and_upgrade(settings)
+
+    if not settings.api_key:
+        redirect_to_login(settings)
+        return
+
+    loop = asyncio.get_event_loop()
+
+    check_running_from_home_directory()
+    check_ssl()
+    loop.run_until_complete(check_inside_git_repo(settings))
+
+    api_key = settings.api_key
+    base_url = settings.base_url
+    base_api_url = settings.get_base_api_url()
+    base_ws_url = settings.get_base_ws_url()
+
+    chat_uuid = chat_id or loop.run_until_complete(
+        create_chat(api_key, base_api_url, base_ws_url, ChatSource.CLI_RUN)
+    )
+
+    if chat_uuid is None:
+        sys.exit(1)
+
+    if (
+        not prompt
+        and (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)
+    ):
+        # Open the chat in the browser
+        launch_exponent_browser(settings.environment, base_url, chat_uuid)
+
+    while True:
+        result = run_chat(loop, api_key, chat_uuid, settings, prompt, workflow_id)
+        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:
+                print("Disconnected upon user request, shutting down...")
+                break
+        elif isinstance(result, SwitchCLIChat):
+            chat_uuid = result.new_chat_uuid
+            print("\nSwitching chats...")
+        else:
+            assert_unreachable(result)
+
+
+def run_chat(
+    loop: asyncio.AbstractEventLoop,
+    api_key: str,
+    chat_uuid: str,
+    settings: Settings,
+    prompt: str | None,
+    workflow_id: str | None,
+) -> REMOTE_EXECUTION_CLIENT_EXIT_INFO | None:
+    start_ts = time.time()
+    base_url = settings.base_url
+    base_api_url = settings.get_base_api_url()
+    base_ws_url = settings.get_base_ws_url()
+
+    print_exponent_message(base_url, chat_uuid)
+    print()
+
+    connection_tracker = ConnectionTracker()
+
+    client_fut = loop.create_task(
+        start_client(
+            api_key,
+            base_url,
+            base_api_url,
+            base_ws_url,
+            chat_uuid,
+            prompt=prompt,
+            workflow_id=workflow_id,
+            connection_tracker=connection_tracker,
+        )
+    )
+
+    conn_fut = loop.create_task(handle_connection_changes(connection_tracker, start_ts))
+
+    try:
+        done, _ = loop.run_until_complete(
+            asyncio.wait({client_fut, conn_fut}, return_when=asyncio.FIRST_COMPLETED)
+        )
+
+        if client_fut in done:
+            return client_fut.result()
+        else:
+            return None
+    finally:
+        for task in asyncio.all_tasks(loop):
+            task.cancel()
+
+        try:
+            loop.run_until_complete(asyncio.wait(asyncio.all_tasks(loop)))
+        except asyncio.CancelledError:
+            pass
+
+
+async def handle_connection_changes(
+    connection_tracker: ConnectionTracker, start_ts: float
+) -> None:
+    try:
+        async with timeout(5):
+            assert await connection_tracker.next_change()
+            print(ready_message(start_ts))
+    except TimeoutError:
+        spinner = Spinner("Connecting...")
+        spinner.show()
+        assert await connection_tracker.next_change()
+        spinner.hide()
+        print(ready_message(start_ts))
+
+    while True:
+        assert not await connection_tracker.next_change()
+
+        print("Disconnected...", end="")
+        await asyncio.sleep(1)
+        spinner = Spinner("Reconnecting...")
+        spinner.show()
+        assert await connection_tracker.next_change()
+        spinner.hide()
+        print("\x1b[1;32m✓ Reconnected", end="")
+        sys.stdout.flush()
+        await asyncio.sleep(1)
+        print("\r\x1b[0m\x1b[2K", end="")
+        sys.stdout.flush()
+
+
+def ready_message(start_ts: float) -> str:
+    elapsed = round(time.time() - start_ts, 2)
+    return f"\x1b[32m✓\x1b[0m Ready in {elapsed}s"

exponent/commands/settings.py

@@ -0,0 +1,56 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import Any
+
+import click
+
+from exponent.commands.utils import (
+    print_editable_install_forced_prod_warning,
+    print_editable_install_warning,
+)
+from exponent.core.config import (
+    Environment,
+    get_settings,
+    is_editable_install,
+)
+
+
+def use_settings(f: Callable[..., Any]) -> Callable[..., Any]:
+    @click.option(
+        "--prod",
+        is_flag=True,
+        hidden=True,
+        help="Use production URLs even if in editable mode",
+    )
+    @click.option(
+        "--staging",
+        is_flag=True,
+        hidden=True,
+        help="Use staging URLs even if in editable mode",
+    )
+    @wraps(f)
+    def decorated_function(*args: Any, **kwargs: Any) -> Any:
+        prod = kwargs.pop("prod", False)
+        staging = kwargs.pop("staging", False)
+        settings = get_settings(use_prod=prod, use_staging=staging)
+
+        if is_editable_install() and not (prod or staging):
+            assert settings.environment == Environment.development
+            print_editable_install_warning(settings)
+
+        return f(*args, settings=settings, **kwargs)
+
+    return decorated_function
+
+
+def use_prod_settings(f: Callable[..., Any]) -> Callable[..., Any]:
+    @wraps(f)
+    def decorated_function(*args: Any, **kwargs: Any) -> Any:
+        settings = get_settings(use_prod=True)
+
+        if is_editable_install():
+            print_editable_install_forced_prod_warning(settings)
+
+        return f(*args, settings=settings, **kwargs)
+
+    return decorated_function