delos-cli 0.1.0__tar.gz

delos_cli-0.1.0/.gitignore

@@ -0,0 +1,145 @@
+knip.txt
+pentest-*
+lefthook.yml
+backend/.vscode
+backend/cosmos_env
+# Allow backend/.env (has safe localhost defaults), but ignore all other .env files
+apps/**/.env
+collab/.env
+cvn-tunnel/.env
+mail-forward/.env
+tools/**/.env
+infrastructure/supabase/**/.env
+.env
+!backend/.env
+.venv
+.vscode
+**/*.vscode
+backend/.python-version
+/scripts/
+*/scripts/
+
+.claude/worktrees
+
+data/documents2
+**/**0
+_local
+.env.old
+.cursorignore
+.gitignore.local
+*.code-workspace
+
+already_translated_chunk.json
+
+.DS_Store
+
+.idea/
+.vercel
+
+log.txt
+.eslintcache
+
+# dependencies
+node_modules
+.wrangler
+.pnp
+.pnp.js
+
+# testing
+coverage
+.coverage
+htmlcov/
+
+# next.js
+.next/
+out/
+next-env.d.ts
+
+# production
+build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# local env files
+.env*.local
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+
+# turbo
+.turbo
+
+# ide
+.idea/
+.vscode/
+.zed
+
+# contentlayer
+.contentlayer/
+
+# process-compose logs
+logs/
+
+/pentest/
+
+# terraform
+.terraform/
+*.tfstate
+*.tfstate.*
+*.tfstate.backup
+.terraform.lock.hcl
+
+.serena/
+
+
+# skillz (duplicate of skills/, generated during experiments)
+.skillz/
+
+# IDE-specific AI settings (per-user configuration)
+**/.gemini/
+**/.qwen/
+
+# serena
+.serena/
+
+# Mobile App (Expo/React Native)
+apps/mobile/.expo/
+apps/mobile/dist/
+apps/mobile/web-build/
+apps/mobile/expo-env.d.ts
+apps/mobile/ios/
+apps/mobile/android/
+apps/mobile/.kotlin/
+apps/mobile/google-services.json
+apps/mobile/*.mobileprovision
+apps/mobile/*.p12
+apps/mobile/*.key
+apps/mobile/.metro-health-check*
+
+
+.gitnexus
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+.reference
+
+# Nvim config
+.nvim.lua
+.nvim.lua.sprite
+.sprite

delos_cli-0.1.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: delos-cli
+Version: 0.1.0
+Summary: Terminal REPL for the Delos agent — the Claude-Code-style CLI for Delos.
+Project-URL: Homepage, https://delos.so
+Project-URL: Repository, https://github.com/Delos-Intelligence/cosmos-saas
+Project-URL: Issues, https://github.com/Delos-Intelligence/cosmos-saas/issues
+Author: Delos Intelligence
+License: MIT
+Keywords: agent,ai,chat,cli,delos,repl,terminal
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Requires-Python: ==3.12.*
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: prompt-toolkit>=3.0.47
+Requires-Dist: questionary>=2.0.1
+Requires-Dist: rich>=13.8.0
+Requires-Dist: typer>=0.12.5
+Description-Content-Type: text/markdown
+
+# delos-cli
+
+A terminal REPL for [Delos](https://delos.so) — the **Claude-Code-style CLI for the Delos agent**.
+
+Talk to your Delos AI from any shell. Streaming Markdown answers, slash
+commands, and tools that read and edit your local files (with your
+approval), all in a TUI that lives in your terminal.
+
+## Install
+
+```bash
+uv tool install delos-cli
+```
+
+Or with pipx:
+
+```bash
+pipx install delos-cli
+```
+
+## Sign in
+
+```bash
+delos login --region eu       # or "us" / "ae"
+```
+
+The browser opens, you sign in to your Delos workspace, and the CLI
+saves your tokens to `~/.config/delos/`.
+
+## Run
+
+```bash
+delos
+```
+
+Conversations are scoped to the directory you launch from — running
+`delos` in `~/projects/foo` shows only chats started in
+`~/projects/foo`. Pick an existing one to resume, or start a fresh one.
+
+### In the REPL
+
+| Action | Key |
+|---|---|
+| Send a message | `Enter` |
+| New line | `Alt+Enter` |
+| Stop the agent mid-answer | `Esc` (or `/stop`) |
+| Quit | `Ctrl+D` (or `/quit`) |
+| Scroll | mouse wheel · `PageUp` / `PageDown` · `End` to follow again |
+
+### Slash commands
+
+```
+/help                 list commands
+/clear                wipe the screen and start a fresh conversation
+/rename <new name>    rename the current chat
+/delete               delete the current chat and go back to the picker
+/resume               back to the picker without deleting
+/stop                 interrupt the agent
+/quit                 exit
+```
+
+## Requirements
+
+- Python 3.12
+- A [Delos](https://delos.so) account
+
+## Uninstall
+
+```bash
+uv tool uninstall delos-cli
+```
+
+---
+
+Made by [Delos Intelligence](https://delos.so).

delos_cli-0.1.0/README.md

@@ -0,0 +1,75 @@
+# delos-cli
+
+A terminal REPL for [Delos](https://delos.so) — the **Claude-Code-style CLI for the Delos agent**.
+
+Talk to your Delos AI from any shell. Streaming Markdown answers, slash
+commands, and tools that read and edit your local files (with your
+approval), all in a TUI that lives in your terminal.
+
+## Install
+
+```bash
+uv tool install delos-cli
+```
+
+Or with pipx:
+
+```bash
+pipx install delos-cli
+```
+
+## Sign in
+
+```bash
+delos login --region eu       # or "us" / "ae"
+```
+
+The browser opens, you sign in to your Delos workspace, and the CLI
+saves your tokens to `~/.config/delos/`.
+
+## Run
+
+```bash
+delos
+```
+
+Conversations are scoped to the directory you launch from — running
+`delos` in `~/projects/foo` shows only chats started in
+`~/projects/foo`. Pick an existing one to resume, or start a fresh one.
+
+### In the REPL
+
+| Action | Key |
+|---|---|
+| Send a message | `Enter` |
+| New line | `Alt+Enter` |
+| Stop the agent mid-answer | `Esc` (or `/stop`) |
+| Quit | `Ctrl+D` (or `/quit`) |
+| Scroll | mouse wheel · `PageUp` / `PageDown` · `End` to follow again |
+
+### Slash commands
+
+```
+/help                 list commands
+/clear                wipe the screen and start a fresh conversation
+/rename <new name>    rename the current chat
+/delete               delete the current chat and go back to the picker
+/resume               back to the picker without deleting
+/stop                 interrupt the agent
+/quit                 exit
+```
+
+## Requirements
+
+- Python 3.12
+- A [Delos](https://delos.so) account
+
+## Uninstall
+
+```bash
+uv tool uninstall delos-cli
+```
+
+---
+
+Made by [Delos Intelligence](https://delos.so).

delos_cli-0.1.0/delos_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Delos CLI — terminal REPL for the Cosmos chat agent."""
+
+__version__ = "0.1.0"

delos_cli-0.1.0/delos_cli/agent/__init__.py

@@ -0,0 +1,34 @@
+"""High-level wrapper around the backend's ``/{app}/agent/*`` routes.
+
+:class:`AgentSession` drives one user turn end-to-end: streams completions,
+detects unresolved tool calls (= client-side tools), resolves them via
+registered handlers, and re-issues continuation requests until the agent
+run is fully complete.
+
+A :class:`ToolRegistry` is the single extension point — apps register:
+
+* **Renderers** — how a server-side tool's events show up in the terminal.
+* **Handlers** — how a client-side tool collects input from the user.
+
+Both have sensible defaults so apps work out of the box.
+"""
+
+from .session import AgentSession
+from .tools import (
+    ToolHandler,
+    ToolRegistry,
+    ToolRenderer,
+    default_handler,
+    default_renderer,
+)
+from .transport import AgentTransport
+
+__all__ = [
+    "AgentSession",
+    "AgentTransport",
+    "ToolHandler",
+    "ToolRegistry",
+    "ToolRenderer",
+    "default_handler",
+    "default_renderer",
+]

delos_cli-0.1.0/delos_cli/agent/session.py

@@ -0,0 +1,111 @@
+"""AgentSession — drives one user turn end-to-end.
+
+A turn may span multiple SSE streams: each client-side tool call ends
+one stream and starts another with ``tool_continuation=true``.  From the
+caller's POV, :meth:`AgentSession.send_turn` is a single async iterator
+of UI events — all the multi-stream stitching is internal.
+
+A :class:`ToolRegistry` resolves both how server-tool events render and
+how client-tool calls collect input from the user.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from delos_cli.ctx import Ctx
+
+    from .tools import ToolRegistry
+    from .transport import AgentTransport
+
+
+class AgentSession:
+    """One session per ``(transport, chat_id)`` pair."""
+
+    def __init__(
+        self,
+        transport: AgentTransport,
+        chat_id: str,
+        registry: ToolRegistry,
+    ) -> None:
+        """Bind to a chat row.  Multiple turns share the same session."""
+        self._transport = transport
+        self._chat_id = chat_id
+        self._registry = registry
+
+    @property
+    def chat_id(self) -> str:
+        """The chat row id this session is bound to."""
+        return self._chat_id
+
+    async def send_turn(
+        self,
+        body: dict[str, Any],
+        ctx: Ctx,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Send one user turn and yield every UI event the agent emits.
+
+        Streams the initial ``/completions`` request.  When the run
+        terminates with unresolved tool calls, treats them as client-side,
+        invokes the registered handler, posts the result via
+        ``/tool-result``, and re-streams a continuation request with
+        ``tool_continuation=true`` and ``messages=[]``.  Loops until no
+        pending calls remain or the user explicitly stopped.
+        """
+        current_body = dict(body)
+        while True:
+            pending: dict[str, dict[str, Any]] = {}
+            stopped = False
+            async for event in self._transport.stream_completions(current_body):
+                etype = event.get("type", "")
+                if etype == "tool-input-available":
+                    tcid = event.get("toolCallId", "")
+                    if tcid:
+                        pending[tcid] = {
+                            "name": event.get("toolName", ""),
+                            "input": event.get("input", {}) or {},
+                        }
+                elif etype == "tool-output-available":
+                    pending.pop(event.get("toolCallId", ""), None)
+                elif etype == "data-stopped":
+                    stopped = True
+                yield event
+
+            if stopped or not pending:
+                return
+
+            for tcid, meta in pending.items():
+                handler = self._registry.handler_for(meta["name"])
+                result = await handler(meta["input"], ctx)
+                await self._transport.submit_tool_result(
+                    self._chat_id, tcid, meta["name"], result,
+                )
+
+            current_body = {**body, "messages": [], "tool_continuation": True}
+
+    async def stop(self) -> None:
+        """Set the backend stop signal.  Idempotent."""
+        await self._transport.stop(self._chat_id)
+
+    async def clear_chat(self) -> None:
+        """Delete the chat row on the backend."""
+        await self._transport.clear_chat(self._chat_id)
+
+    async def queue_message(self, content: str) -> str:
+        """Add a message to the FIFO queue.  Returns the new message id."""
+        return await self._transport.queue_message(self._chat_id, content)
+
+    async def list_queue(self) -> list[dict[str, Any]]:
+        """Return the current queued-messages list."""
+        return await self._transport.list_queue(self._chat_id)
+
+    async def edit_queued(self, message_id: str, content: str) -> None:
+        """Edit a queued message in place."""
+        await self._transport.edit_queued(self._chat_id, message_id, content)
+
+    async def remove_queued(self, message_id: str) -> None:
+        """Remove a queued message."""
+        await self._transport.remove_queued(self._chat_id, message_id)

delos_cli-0.1.0/delos_cli/agent/tools.py

@@ -0,0 +1,131 @@
+"""Tool registry, default renderers, and default handlers.
+
+There are two extension points per tool:
+
+- **Renderer** — called when the agent emits ``tool-input-available``,
+  ``tool-output-available``, or ``data-tool-output-delta`` for that tool.
+  Returns a Rich renderable (``Panel``, ``Text``, …) or ``None`` to skip.
+  Used for server-side tools whose execution happens in the backend.
+
+- **Handler** — called when the agent emits ``tool-input-available`` and
+  the run terminates without a corresponding ``tool-output-available``
+  (= the tool was registered ``client=True`` server-side).  Returns the
+  result string the next agent turn should see.
+
+Defaults:
+
+- :func:`default_renderer` — a one-line ``→ tool_name`` indicator on
+  ``tool-input-available``; nothing on output / delta events.  Custom
+  renderers can opt into args, output, or streaming deltas.
+- :func:`default_handler` — prints the input dict, asks for a free-form
+  text answer via a one-shot prompt_toolkit prompt.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import HTML
+from rich.panel import Panel
+from rich.text import Text
+
+if TYPE_CHECKING:
+    from rich.console import RenderableType
+
+    from delos_cli.ctx import Ctx
+
+
+@runtime_checkable
+class ToolRenderer(Protocol):
+    """Render one tool-related event.
+
+    Return a Rich renderable to print above the live region, or ``None``
+    to skip rendering.  The same renderer instance receives every event
+    for its tool name across the whole REPL session, so it may keep state
+    (e.g. dedupe by ``toolCallId``) if needed.
+    """
+
+    def __call__(self, event: dict[str, Any]) -> RenderableType | None:
+        """Render ``event`` and return a Rich renderable, or ``None`` to skip."""
+        ...
+
+
+@runtime_checkable
+class ToolHandler(Protocol):
+    """Resolve a client-side tool call.
+
+    Receives the tool's ``input`` dict (whatever the agent passed) and the
+    REPL :class:`~delos_cli.ctx.Ctx` for console / HTTP access.  Returns
+    the result string the next agent turn should see.
+    """
+
+    async def __call__(
+        self, tool_input: dict[str, Any], ctx: Ctx,
+    ) -> str:
+        """Collect input from the user and return the result string."""
+        ...
+
+
+def default_renderer(event: dict[str, Any]) -> RenderableType | None:
+    """Show a single ``→ tool_name`` line on ``tool-input-available``; ignore the rest.
+
+    Args are intentionally hidden — most tool calls are noisy enough as JSON
+    that they hurt readability for the default case.  Custom renderers can
+    opt into args, output (``tool-output-available``), and streaming
+    deltas (``data-tool-output-delta``).
+    """
+    if event.get("type") != "tool-input-available":
+        return None
+    name = event.get("toolName", "?")
+    line = Text()
+    line.append("→ ", style="bold cyan")
+    line.append(name, style="cyan")
+    return line
+
+
+async def default_handler(tool_input: dict[str, Any], ctx: Ctx) -> str:
+    """Print the input dict and prompt for a single-line free-form answer.
+
+    A one-shot :class:`PromptSession` is spun up so the user gets the same
+    keybindings as the main REPL (Ctrl+R search, history hints, …) without
+    polluting the chat history file with these tool answers.
+    """
+    try:
+        pretty = json.dumps(tool_input, indent=2, ensure_ascii=False)
+    except (TypeError, ValueError):
+        pretty = str(tool_input)
+    ctx.console.print(
+        Panel(
+            Text(pretty, style="dim"),
+            title="? client tool input",
+            title_align="left",
+            border_style="yellow",
+            expand=False,
+        ),
+    )
+    sess: PromptSession[str] = PromptSession()
+    answer = await sess.prompt_async(HTML("<ansiyellow>tool result › </ansiyellow>"))
+    return answer.strip()
+
+
+@dataclass
+class ToolRegistry:
+    """Per-tool overrides keyed by tool name.
+
+    Lookups fall back to :func:`default_renderer` / :func:`default_handler`
+    when a tool isn't registered.
+    """
+
+    renderers: dict[str, ToolRenderer] = field(default_factory=dict)
+    handlers: dict[str, ToolHandler] = field(default_factory=dict)
+
+    def renderer_for(self, name: str) -> ToolRenderer:
+        """Return the registered renderer for ``name``, or the default."""
+        return self.renderers.get(name, default_renderer)
+
+    def handler_for(self, name: str) -> ToolHandler:
+        """Return the registered handler for ``name``, or the default."""
+        return self.handlers.get(name, default_handler)

delos_cli-0.1.0/delos_cli/agent/transport.py

@@ -0,0 +1,102 @@
+"""HTTP wrappers for the ``/{app}/agent/*`` routes.
+
+One :class:`AgentTransport` instance is bound to ``(app, org)``; the
+``chat_id`` is passed per call.  Methods map 1:1 to the routes the backend
+exposes via ``create_agent_router``.
+"""
+
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from delos_cli.transport.client import AuthedClient
+
+
+class AgentTransport:
+    """One transport instance per ``(app, org)`` pair."""
+
+    def __init__(
+        self,
+        http: AuthedClient,
+        api_prefix: str,
+        org_uuid: str,
+    ) -> None:
+        """Bind to an app's agent router.
+
+        ``api_prefix`` is the app slug (``"chat"``, ``"code"``, …) — it is
+        what the backend uses to mount each ``create_agent_router`` instance.
+        """
+        self._http = http
+        self._prefix = api_prefix
+        self._org = org_uuid
+
+    def _path(self, suffix: str, chat_id: str | None = None) -> str:
+        base = f"/{self._prefix}/agent/{suffix}/{self._org}"
+        return f"{base}/{chat_id}" if chat_id is not None else base
+
+    async def stream_completions(
+        self, body: dict[str, Any],
+    ) -> AsyncIterator[dict[str, Any]]:
+        """``POST /{app}/agent/completions/{org}`` → parsed SSE events."""
+        async for event in self._http.sse_post(self._path("completions"), body):
+            yield event
+
+    async def stop(self, chat_id: str) -> None:
+        """``POST /stop/{org}/{chat_id}`` — set the Redis stop signal."""
+        await self._http.json_post(self._path("stop", chat_id), {})
+
+    async def submit_tool_result(
+        self,
+        chat_id: str,
+        tool_call_id: str,
+        tool_name: str,
+        content: str,
+    ) -> None:
+        """``POST /tool-result/{org}/{chat_id}`` — persist a client-tool result."""
+        await self._http.json_post(
+            self._path("tool-result", chat_id),
+            {
+                "tool_call_id": tool_call_id,
+                "tool_name": tool_name,
+                "content": content,
+            },
+        )
+
+    async def clear_chat(self, chat_id: str) -> None:
+        """``POST /clear-chat/{org}/{chat_id}`` — delete the chat row."""
+        await self._http.json_post(self._path("clear-chat", chat_id), {})
+
+    async def queue_message(self, chat_id: str, content: str) -> str:
+        """``POST /queue/{org}/{chat_id}`` — append to the FIFO queue.
+
+        Generates a fresh UUID client-side (mirrors the frontend) and returns
+        it so the caller can later edit / remove the queued entry.
+        """
+        message_id = str(uuid.uuid4())
+        await self._http.json_post(
+            self._path("queue", chat_id),
+            {"message_id": message_id, "content": content},
+        )
+        return message_id
+
+    async def list_queue(self, chat_id: str) -> list[dict[str, Any]]:
+        """``GET /queue/{org}/{chat_id}`` — current queue snapshot."""
+        data = await self._http.json_get(self._path("queue", chat_id))
+        queue = data.get("queue") or []
+        return list(queue)
+
+    async def edit_queued(
+        self, chat_id: str, message_id: str, content: str,
+    ) -> None:
+        """``PUT /queue/{org}/{chat_id}/{msg_id}``."""
+        path = f"{self._path('queue', chat_id)}/{message_id}"
+        await self._http.json_request("PUT", path, {"content": content})
+
+    async def remove_queued(self, chat_id: str, message_id: str) -> None:
+        """``DELETE /queue/{org}/{chat_id}/{msg_id}``."""
+        path = f"{self._path('queue', chat_id)}/{message_id}"
+        await self._http.json_request("DELETE", path, None)