delos-cli 0.1.0__py3-none-any.whl

delos_cli/commands/builtin.py

@@ -0,0 +1,160 @@
+"""Global slash commands: /help, /clear, /rename, /delete, /stop, /resume, /quit."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from prompt_toolkit.application import get_app
+from rich.text import Text
+
+from delos_cli.transport.chats import create_chat, delete_chat, rename_chat
+from delos_cli.transport.client import TransportError
+
+from .base import CommandSpec, Quit, registry_from
+
+if TYPE_CHECKING:
+    from delos_cli.ctx import Ctx
+
+
+def _sink(ctx: Ctx) -> Any:
+    """Active print target — REPL output buffer if up, else the console."""
+    return ctx.output if ctx.output is not None else ctx.console
+
+
+def _handle_help(ctx: Ctx, args: str) -> None:
+    _ = args
+    sink = _sink(ctx)
+    seen: set[str] = set()
+    combined = {**GLOBAL_COMMANDS, **ctx.app.commands}
+    for spec in combined.values():
+        if spec.name in seen:
+            continue
+        seen.add(spec.name)
+        sink.print(
+            Text(spec.display_name, style="bold"),
+            Text(f" — {spec.summary}", style="dim"),
+        )
+
+
+async def _handle_clear(ctx: Ctx, args: str) -> None:
+    """Wipe the output area + start a fresh conversation (INSERT a new app_cli row)."""
+    _ = args
+    sink = _sink(ctx)
+    # cwd hasn't moved since startup (no shell escape), but read it
+    # again here so a future "/cd"-style command stays compatible.
+    try:
+        new_id = await create_chat(ctx.http, folder=str(Path.cwd()))
+    except TransportError as e:
+        sink.print(Text(f"clear failed: {e}", style="red"))
+        return
+    if ctx.output is not None:
+        ctx.output.clear()
+    ctx.state.conv_id = new_id
+    ctx.state.name = None
+    ctx.state.turn = 0
+    sink.print(Text(f"new conversation {new_id}", style="dim"))
+
+
+def _handle_quit(ctx: Ctx, args: str) -> None:
+    _ = ctx, args
+    raise Quit
+
+
+async def _handle_stop(ctx: Ctx, args: str) -> None:
+    _ = args
+    sink = _sink(ctx)
+    try:
+        await ctx.app.cancel(ctx)
+    except Exception as e:
+        sink.print(Text(f"stop failed: {e}", style="yellow"))
+        return
+    sink.print(Text("stop signal sent", style="dim"))
+
+
+def _handle_resume(ctx: Ctx, args: str) -> None:
+    """Exit the REPL Application; the outer loop re-shows the chat picker."""
+    _ = args
+    ctx.state.resume_requested = True
+    try:
+        get_app().exit()
+    except Exception as e:  # pragma: no cover — only fails if no app is running
+        _sink(ctx).print(Text(f"resume failed: {e}", style="yellow"))
+
+
+async def _handle_rename(ctx: Ctx, args: str) -> None:
+    """``/rename <new name>`` — UPDATE app_cli.name for the active chat."""
+    new_name = args.strip()
+    sink = _sink(ctx)
+    if not new_name:
+        sink.print(Text("usage: /rename <new name>", style="yellow"))
+        return
+    try:
+        await rename_chat(ctx.http, ctx.state.conv_id, new_name)
+    except TransportError as e:
+        sink.print(Text(f"rename failed: {e}", style="red"))
+        return
+    ctx.state.name = new_name
+    sink.print(Text(f"renamed to {new_name!r}", style="dim"))
+
+
+async def _handle_delete(ctx: Ctx, args: str) -> None:
+    """``/delete`` — DELETE the active chat row, then return to the picker."""
+    _ = args
+    sink = _sink(ctx)
+    try:
+        await delete_chat(ctx.http, ctx.state.conv_id)
+    except TransportError as e:
+        sink.print(Text(f"delete failed: {e}", style="red"))
+        return
+    sink.print(Text("conversation deleted", style="dim"))
+    # Bounce back to the picker — same exit path as /resume.
+    ctx.state.resume_requested = True
+    try:
+        get_app().exit()
+    except Exception as e:  # pragma: no cover
+        sink.print(Text(f"(could not exit cleanly: {e})", style="yellow"))
+
+
+HELP = CommandSpec(
+    name="/help",
+    summary="show available commands",
+    handler=_handle_help,
+)
+CLEAR = CommandSpec(
+    name="/clear",
+    summary="wipe the screen and start a new conversation",
+    handler=_handle_clear,
+)
+STOP = CommandSpec(
+    name="/stop",
+    summary="signal the backend agent to stop the current run",
+    handler=_handle_stop,
+)
+RESUME = CommandSpec(
+    name="/resume",
+    summary="back to the chat picker — load a different conversation",
+    handler=_handle_resume,
+)
+RENAME = CommandSpec(
+    name="/rename",
+    summary="rename the active conversation",
+    handler=_handle_rename,
+    args_hint="<new name>",
+)
+DELETE = CommandSpec(
+    name="/delete",
+    summary="delete the active conversation and return to the picker",
+    handler=_handle_delete,
+)
+QUIT = CommandSpec(
+    name="/quit",
+    summary="exit the REPL",
+    handler=_handle_quit,
+    aliases=("/exit", ":q"),
+)
+
+
+GLOBAL_COMMANDS: dict[str, CommandSpec] = registry_from(
+    [HELP, CLEAR, STOP, RESUME, RENAME, DELETE, QUIT],
+)

delos_cli/ctx.py

@@ -0,0 +1,65 @@
+"""Runtime context passed to every command and every app.
+
+Centralising the handles (config, HTTP client, console, state, current app)
+in one object keeps command signatures small and lets us swap components
+(e.g. the current app) without rewiring every caller.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from rich.console import Console
+
+    from .apps.base import App
+    from .auth.config import Config
+    from .state import ReplState
+    from .transport.client import AuthedClient
+    from .ui.output import OutputBuffer
+
+
+@dataclass(frozen=True)
+class ConfirmOutcome:
+    """Result of an in-app approval prompt.
+
+    ``accepted`` distinguishes approve from deny; ``reason`` is the
+    optional free-form text the user typed when denying — empty when
+    the user just pressed Enter on Deny without typing anything.
+    """
+
+    accepted: bool
+    reason: str = ""
+
+
+if TYPE_CHECKING:
+    #: Async approval prompt installed by the REPL.  Tools call
+    #: ``await ctx.confirm("preview text")`` to surface an Accept/Deny
+    #: dialog (with optional reason) inside the running prompt_toolkit
+    #: Application instead of spawning a nested PromptSession.
+    ConfirmFn = Callable[[str], Awaitable[ConfirmOutcome]]
+
+
+@dataclass
+class Ctx:
+    """Everything a command or app handler may need at runtime.
+
+    ``console`` is for output that happens BEFORE the REPL takes over the
+    terminal (login, region picker, fatal errors).  Once the REPL is
+    running, in-app prints must go through :attr:`output` so they appear
+    inside the streaming output area instead of clobbering the layout.
+    """
+
+    cfg: Config
+    state: ReplState
+    console: Console
+    http: AuthedClient
+    app: App
+    output: OutputBuffer | None = None
+    #: Set by the REPL on entry; tools that need user approval should
+    #: ``await ctx.confirm("preview text") -> bool`` instead of opening
+    #: their own prompt_toolkit session.
+    confirm: ConfirmFn | None = None

delos_cli/loop.py

@@ -0,0 +1,19 @@
+"""REPL entrypoint — delegates to the prompt_toolkit Application in :mod:`ui.repl`.
+
+Kept as a thin shim so :mod:`delos_cli.main` doesn't need to know about
+the layout details.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .ui.repl import run as _run
+
+if TYPE_CHECKING:
+    from .ctx import Ctx
+
+
+async def run(ctx: Ctx) -> None:
+    """Drive the REPL until the user quits."""
+    await _run(ctx)

delos_cli/main.py

@@ -0,0 +1,230 @@
+"""Typer entrypoint for the `delos` command."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Annotated
+
+import questionary
+import typer
+from rich.console import Console
+from rich.text import Text
+
+from . import __version__
+from .apps import ChatApp
+from .auth import config as cfg_mod
+from .auth.oauth import OAuthError, run_login_flow
+from .ctx import Ctx
+from .loop import run as run_loop
+from .state import ReplState
+from .transport.chats import create_chat, fetch_messages, list_recent
+from .transport.client import AuthedClient, TransportError
+from .ui.chat_picker import pick_conversation
+
+app = typer.Typer(
+    help="Delos terminal — talk to the Cosmos chat agent from your shell.",
+    no_args_is_help=False,
+    add_completion=False,
+)
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def default(ctx: typer.Context) -> None:
+    """Start the REPL when `delos` is invoked with no subcommand."""
+    if ctx.invoked_subcommand is not None:
+        return
+    cfg = cfg_mod.load()
+    if not cfg.is_signed_in:
+        console.print(Text("Not signed in. Run `delos login` first.", style="yellow"))
+        raise typer.Exit(code=1)
+    asyncio.run(_run_repl(cfg))
+
+
+async def _run_repl(cfg: cfg_mod.Config) -> None:
+    """Show the recent-chats picker, then hand off to the REPL.
+
+    Loops back to the picker whenever the REPL exits via ``/resume`` so
+    the user can hop between conversations without restarting ``delos``.
+
+    A single :class:`AuthedClient` owns both the backend and Supabase
+    REST connections for the whole session.
+    """
+    # Captured once at REPL start.  The user can't ``cd`` from inside
+    # delos, so this stays accurate for the whole session — passed to
+    # both the picker filter and ``create_chat`` (and ``/clear``).
+    folder = str(Path.cwd())
+
+    async with AuthedClient(cfg) as http:
+        # The ChatApp persists across resumes — its tool registry and
+        # available_models cache carry over.  Picker + REPL are
+        # re-entered each iteration so the conv id is fresh per turn.
+        chat_app = ChatApp()
+
+        while True:
+            try:
+                chats = await list_recent(http, cfg.org_uuid, folder=folder)
+            except TransportError as e:
+                console.print(Text(f"(could not load recent chats: {e})", style="yellow"))
+                chats = []
+
+            resume_id = await pick_conversation(chats)
+
+            name: str | None = None
+            if resume_id is not None:
+                # Stage history so on_enter replays it once the OutputBuffer
+                # is wired up; soft-fail (start the chat empty) on transport
+                # errors rather than blocking the user from typing.
+                try:
+                    chat_app.pending_replay = await fetch_messages(http, resume_id)
+                except TransportError as e:
+                    console.print(
+                        Text(f"(could not load chat history: {e})", style="yellow"),
+                    )
+                    chat_app.pending_replay = []
+                conv_id = resume_id
+                # Hydrate the toolbar label from the picker payload — saves
+                # an extra fetch.  ``next(...)`` returns None when the chat
+                # vanished between the list and the pick (unlikely race).
+                picked = next((c for c in chats if c.id == resume_id), None)
+                name = picked.name if picked else None
+            else:
+                # User picked "+ New chat" — INSERT the row immediately so the
+                # backend has somewhere to append messages on the first turn,
+                # and so future model-pick-before-first-message just writes
+                # to the existing row.  ``folder`` pins it to ``cwd`` so the
+                # picker only resurfaces it when the user comes back here.
+                try:
+                    conv_id = await create_chat(http, folder=folder)
+                except TransportError as e:
+                    console.print(Text(f"(could not create chat: {e})", style="red"))
+                    return
+                chat_app.pending_replay = []
+
+            ctx = Ctx(
+                cfg=cfg,
+                state=ReplState(conv_id=conv_id, name=name),
+                console=console,
+                http=http,
+                app=chat_app,
+            )
+            await run_loop(ctx)
+            if not ctx.state.resume_requested:
+                return
+
+
+@app.command()
+def login(
+    region: Annotated[
+        str | None,
+        typer.Option(
+            "--region",
+            help="Region to sign into: eu, us, ae (plus dev/staging when DELOS_INTERNAL=1).",
+        ),
+    ] = None,
+) -> None:
+    """Open the browser, sign in via OAuth PKCE, save tokens to ~/.config/delos/."""
+    cfg = cfg_mod.load()
+
+    if region:
+        allowed = cfg_mod.available_regions()
+        if region not in allowed:
+            known = ", ".join(sorted(allowed))
+            console.print(Text(f"Unknown region '{region}'. Known: {known}", style="red"))
+            raise typer.Exit(code=2)
+        cfg.region = region
+    else:
+        picked = _pick_region(cfg.region)
+        if picked is None:
+            console.print(Text("cancelled.", style="dim"))
+            raise typer.Exit(code=1)
+        cfg.region = picked
+
+    console.print(Text(f"Signing in to {cfg.region} ({cfg.web_url})…", style="bold"))
+
+    async def _prompt(prompt: str) -> str:
+        return await asyncio.to_thread(input, prompt)
+
+    try:
+        result = asyncio.run(
+            run_login_flow(
+                cfg,
+                lambda m: console.print(Text(m, style="dim")),
+                _prompt,
+            ),
+        )
+    except OAuthError as e:
+        console.print(Text(f"Login failed: {e}", style="red"))
+        raise typer.Exit(code=1) from e
+
+    cfg.client_id = result.client_id
+    cfg.tokens = result.tokens
+    cfg.user_id = result.user_id
+    cfg.org_uuid = result.org_uuid
+    path = cfg_mod.save(cfg)
+
+    console.print(Text(f"Signed in as {result.user_id} (org {result.org_uuid})", style="green"))
+    console.print(Text(f"saved → {path}", style="dim"))
+
+
+@app.command()
+def logout() -> None:
+    """Forget stored tokens (region is preserved)."""
+    cfg = cfg_mod.load()
+    cfg.tokens = cfg_mod.Tokens()
+    cfg.user_id = ""
+    cfg.org_uuid = ""
+    cfg_mod.save(cfg)
+    console.print(Text("Signed out.", style="green"))
+
+
+@app.command()
+def whoami() -> None:
+    """Print the signed-in user and org, and the effective region URLs."""
+    cfg = cfg_mod.load()
+    console.print(Text("region   ", style="bold"), Text(cfg.region, style="dim"))
+    console.print(Text("web      ", style="bold"), Text(cfg.web_url, style="dim"))
+    console.print(Text("api      ", style="bold"), Text(cfg.api_url, style="dim"))
+    console.print(Text("user_id  ", style="bold"), Text(cfg.user_id or "(not signed in)", style="dim"))
+    console.print(Text("org_uuid ", style="bold"), Text(cfg.org_uuid or "(not signed in)", style="dim"))
+
+
+@app.command()
+def version() -> None:
+    """Print the CLI version."""
+    console.print(Text(__version__))
+
+
+_PICKER_STYLE = questionary.Style(
+    [
+        ("qmark", "fg:ansicyan"),
+        ("question", ""),
+        ("pointer", "fg:ansicyan"),
+        ("highlighted", "fg:ansicyan"),
+        ("selected", "fg:ansicyan"),
+        ("answer", "fg:ansicyan"),
+        ("instruction", "fg:ansigray"),
+    ],
+)
+
+
+def _pick_region(default: str) -> str | None:
+    """Inline arrow-key picker (via questionary); returns the chosen region or None if cancelled."""
+    _ = default  # intentionally unused — always start at the top, no pre-selection highlight
+    allowed = cfg_mod.available_regions()
+    choices = [
+        questionary.Choice(title=f"{name:<8}  {info['web']}", value=name)
+        for name, info in sorted(allowed.items())
+    ]
+    return questionary.select(
+        "Pick a region:",
+        choices=choices,
+        use_shortcuts=True,
+        qmark="›",
+        style=_PICKER_STYLE,
+    ).ask()
+
+
+if __name__ == "__main__":
+    app()

delos_cli/state.py

@@ -0,0 +1,28 @@
+"""Cross-app REPL state: conversation id and turn count.
+
+App-specific state (model selection, selected tools, …) lives on each
+``App`` instance rather than here, so one app's state doesn't leak into
+another's toolbar or completer.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ReplState:
+    """Mutable state shared between the loop, the toolbar, and the completer."""
+
+    conv_id: str
+    turn: int = 0
+    #: Display name for the active conversation.  Hydrated from the
+    #: picker (``app_cli.name``) on resume; updated by ``/rename``;
+    #: stays ``None`` for fresh chats until the auto-name trigger fills
+    #: ``app_cli.name`` on the first user message (the toolbar will keep
+    #: showing the conv id until the next REPL session reads it back).
+    name: str | None = None
+    #: Set by ``/resume`` (or ``/delete``) to signal the outer loop to
+    #: re-show the chat picker after the Application exits.  Cleared on
+    #: each new REPL iteration in ``main._run_repl``.
+    resume_requested: bool = False

delos_cli/tools/__init__.py

@@ -0,0 +1,20 @@
+"""Client-side tool implementations for the Delos CLI.
+
+Each module exports a ``handle_<tool>`` (the resolution callback that
+satisfies :class:`~delos_cli.agent.tools.ToolHandler`) and optionally a
+``render_<tool>`` (a custom :class:`~delos_cli.agent.tools.ToolRenderer`
+to give the tool a nicer visual than the default).
+"""
+
+from .edit_content import handle_edit_content, render_edit_content
+from .run_shell import handle_run_shell, render_run_shell
+from .write_content import handle_write_content, render_write_content
+
+__all__ = [
+    "handle_edit_content",
+    "handle_run_shell",
+    "handle_write_content",
+    "render_edit_content",
+    "render_run_shell",
+    "render_write_content",
+]