delos-cli 0.1.0__py3-none-any.whl

delos_cli/tools/edit_content.py

@@ -0,0 +1,193 @@
+"""Client-side handler + renderer for the ``edit_content`` tool.
+
+Strict find/replace edit:
+
+1. Resolve ``path`` against ``cwd``; refuse missing / non-utf-8 / non-file.
+2. Validate args: ``old_content`` non-empty, distinct from ``new_content``.
+3. Count occurrences of ``old_content`` in the file.
+
+   - 0    → ask the agent to re-read.
+   - >1   → ask the agent to add more context.
+   - 1    → continue.
+
+4. Build a unified diff preview, ask the user to approve.
+5. Write the patched content back.
+
+Designed to be deterministic: literal string match, no fuzzy logic.  If
+the file changed since the last read, the match fails — by design.
+"""
+
+from __future__ import annotations
+
+import difflib
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from rich.console import Group
+from rich.padding import Padding
+from rich.text import Text
+
+if TYPE_CHECKING:
+    from rich.console import RenderableType
+
+    from delos_cli.ctx import Ctx
+
+
+_DIFF_CONTEXT_LINES = 2
+
+#: Sentinels for boundary inserts.  When ``old_content`` matches one of
+#: these, the handler skips the literal-match step and prepends /
+#: appends ``new_content`` instead — typical use cases are adding
+#: imports at the top or a new function at the bottom.
+_FIRST_LINE_SENTINEL = "<first_line>"
+_LAST_LINE_SENTINEL = "<last_line>"
+
+
+async def handle_edit_content(tool_input: dict[str, Any], ctx: Ctx) -> str:
+    """Resolve an ``edit_content`` call: validate, match, confirm, write."""
+    raw_path = (tool_input.get("path") or "").strip()
+    old_content = tool_input.get("old_content") or ""
+    new_content = tool_input.get("new_content") or ""
+    if not raw_path:
+        return "Error: empty path."
+    if not isinstance(old_content, str) or not isinstance(new_content, str):
+        return "Error: 'old_content' and 'new_content' must both be strings."
+    if not old_content:
+        return "Error: old_content is empty. Use a non-empty pivot string."
+    if old_content == new_content:
+        return "Error: old_content and new_content are identical — nothing to do."
+
+    # ASYNC240 only matters for tight loops; one-shot stat + read + write
+    # is fine on the CLI's event loop.
+    path = Path(raw_path).expanduser()  # noqa: ASYNC240
+    if not path.is_absolute():
+        path = Path.cwd() / path
+
+    if not path.exists():
+        return f"Error: file does not exist: {path}."
+    if not path.is_file():
+        return f"Error: not a regular file: {path}."
+
+    try:
+        file_text = path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        return f"Error: file is not utf-8: {path}."
+    except OSError as e:
+        return f"Error reading {path}: {e}"
+
+    # Boundary sentinels skip matching: prepend / append outright.  Real
+    # text containing the sentinel string verbatim is exceedingly rare
+    # (the angle brackets + underscore form is unusual in source code);
+    # if we ever hit a false positive, the agent can quote the existing
+    # first / last line with extra context to disambiguate.
+    if old_content == _FIRST_LINE_SENTINEL:
+        new_text = new_content + file_text
+        change_summary = f"prepend {len(new_content)} chars"
+    elif old_content == _LAST_LINE_SENTINEL:
+        new_text = file_text + new_content
+        change_summary = f"append {len(new_content)} chars"
+    else:
+        occurrences = file_text.count(old_content)
+        if occurrences == 0:
+            return (
+                f"Error: old_content not found in {path}. "
+                f"Re-read the file with run_shell (`cat {path}`) and try again."
+            )
+        if occurrences > 1:
+            return (
+                f"Error: old_content matches {occurrences} locations in {path}. "
+                f"Add more context (surrounding lines) to make it unique."
+            )
+        new_text = file_text.replace(old_content, new_content, 1)
+        change_summary = f"{len(old_content)} → {len(new_content)} chars"
+
+    if ctx.confirm is None:
+        sink = ctx.output if ctx.output is not None else ctx.console
+        sink.print(
+            Text(f"(no confirm hook; aborted: edit_content {path})", style="yellow"),
+        )
+        return "Tool rejected by the user."
+
+    # Render the full diff into the scrollable output area (the confirm
+    # dialog itself just shows the short ``edit_content → /path`` title
+    # so big patches don't overflow it).
+    if ctx.output is not None:
+        ctx.output.append_block(_diff_panel(path, file_text, new_text))
+
+    outcome = await ctx.confirm(f"edit_content → {path}")
+    if not outcome.accepted:
+        if outcome.reason:
+            return f"Tool rejected by the user. Reason: {outcome.reason}"
+        return "Tool rejected by the user."
+
+    # TOCTOU guard: the file may have been edited (manually, another
+    # process, …) while the dialog was open.  Re-read and bail out if
+    # what we'd be overwriting isn't what we showed in the preview.
+    try:
+        current_text = path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError) as e:
+        return f"Error re-reading {path}: {e}"
+    if current_text != file_text:
+        return (
+            f"Error: {path} changed on disk between the proposal and your approval. "
+            f"Re-read with run_shell (`cat {path}`) and propose the edit again."
+        )
+
+    try:
+        path.write_text(new_text, encoding="utf-8")
+    except OSError as e:
+        return f"Error writing to {path}: {e}"
+    return f"Edited {path}: {change_summary}."
+
+
+def render_edit_content(event: dict[str, Any]) -> RenderableType | None:
+    """Show ``✎ edit → /path  (N → M chars)`` instead of the default panel."""
+    if event.get("type") != "tool-input-available":
+        return None
+    inputs = event.get("input") or {}
+    path = inputs.get("path") or ""
+    old = inputs.get("old_content") or ""
+    new = inputs.get("new_content") or ""
+    if not path:
+        return None
+    line = Text()
+    line.append("✎ ", style="bold magenta")
+    line.append("edit → ", style="magenta")
+    line.append(str(path), style="bold magenta")
+    line.append(f"  ({len(old)} → {len(new)} chars)", style="dim")
+    return line
+
+
+def _diff_panel(path: Path, file_text: str, new_text: str) -> Padding:
+    """Build a coloured-diff block (no border) for the output area.
+
+    Lines are coloured per-row (``+`` green, ``-`` red, ``@@`` cyan,
+    headers dim) so the user can scan changes at a glance even on long
+    patches.  Line-level diff via :func:`difflib.unified_diff`
+    (``n=2`` context lines).
+    """
+    lines = list(
+        difflib.unified_diff(
+            file_text.splitlines(),
+            new_text.splitlines(),
+            fromfile="before",
+            tofile="after",
+            n=_DIFF_CONTEXT_LINES,
+            lineterm="",
+        ),
+    )
+    body = Text()
+    for raw in lines:
+        if raw.startswith(("---", "+++")):
+            body.append(raw, style="dim")
+        elif raw.startswith("@@"):
+            body.append(raw, style="cyan")
+        elif raw.startswith("+"):
+            body.append(raw, style="green")
+        elif raw.startswith("-"):
+            body.append(raw, style="red")
+        else:
+            body.append(raw)
+        body.append("\n")
+    title = Text(f"✎ proposed edit → {path}", style="bold")
+    return Padding(Group(title, body), (0, 0, 0, 2))

delos_cli/tools/run_shell.py

@@ -0,0 +1,150 @@
+"""Client-side handler + renderer for the ``run_shell`` tool.
+
+The agent emits ``tool-input-available`` for ``run_shell``; the REPL
+runs :func:`handle_run_shell` which:
+
+1. Decides whether the command can run silently (read-only allowlist
+   with no shell metacharacters) or needs a confirmation prompt.
+2. If a prompt is needed, shows the command in a Rich panel and asks
+   the user ``[y/N]`` via prompt_toolkit.
+3. On approval (or for safe commands), spawns the command with
+   :func:`asyncio.create_subprocess_shell`, merges stdout + stderr,
+   truncates to a sane size, and returns the result string for the
+   next agent turn.
+
+A custom renderer prints ``$ <command>`` instead of the default JSON
+panel so the conversation reads naturally.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import TYPE_CHECKING, Any
+
+from rich.text import Text
+
+from delos_cli.ctx import ConfirmOutcome
+
+if TYPE_CHECKING:
+    from rich.console import RenderableType
+
+    from delos_cli.ctx import Ctx
+
+
+# ---------------------------------------------------------------------------
+# Safety policy
+# ---------------------------------------------------------------------------
+
+#: Binaries known to be read-only — execute silently when the command
+#: starts with one and has no shell metacharacters.  Conservative on
+#: purpose: extra confirmations are mild friction; an unintended write
+#: is a real outage.  ``find`` is intentionally absent — it has
+#: ``-delete`` and ``-exec``.
+_SAFE_BINARIES: frozenset[str] = frozenset({"ls", "cat"})
+
+#: Tokens that can turn a read into a write (redirection / chaining /
+#: substitution).  Their presence anywhere in the command forces a
+#: confirmation, even if the visible binary is in the allowlist.
+_UNSAFE_TOKENS: tuple[str, ...] = (">", "<", "|", "&", ";", "$(", "`")
+
+_TIMEOUT_S = 30.0
+_OUTPUT_LIMIT = 8_000
+
+
+def is_safe_command(command: str) -> bool:
+    """True iff ``command`` may run without prompting the user.
+
+    Allowlist-based: any token that could redirect / chain / substitute
+    fails closed (we ask), and only the bare safe binaries pass.
+    """
+    if any(tok in command for tok in _UNSAFE_TOKENS):
+        return False
+    parts = command.strip().split(maxsplit=1)
+    if not parts:
+        return False
+    return parts[0] in _SAFE_BINARIES
+
+
+# ---------------------------------------------------------------------------
+# Handler — entry point used by AgentSession
+# ---------------------------------------------------------------------------
+
+
+async def handle_run_shell(tool_input: dict[str, Any], ctx: Ctx) -> str:
+    """Resolve a ``run_shell`` tool call and return its output string."""
+    command = (tool_input.get("command") or "").strip()
+    if not command:
+        return "Error: empty command."
+
+    if not is_safe_command(command):
+        outcome = await _ask_user(command, ctx)
+        if not outcome.accepted:
+            if outcome.reason:
+                return f"Tool rejected by the user. Reason: {outcome.reason}"
+            return "Tool rejected by the user."
+
+    return await _run(command)
+
+
+# ---------------------------------------------------------------------------
+# Renderer — overrides the default JSON panel with ``$ <command>``
+# ---------------------------------------------------------------------------
+
+
+def render_run_shell(event: dict[str, Any]) -> RenderableType | None:
+    """Render shell tool events as ``$ <command>`` / ``↳ output`` lines."""
+    etype = event.get("type")
+    if etype == "tool-input-available":
+        cmd = (event.get("input") or {}).get("command", "")
+        if not cmd:
+            return None
+        line = Text()
+        line.append("$ ", style="bold green")
+        line.append(cmd, style="green")
+        return line
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Internals
+# ---------------------------------------------------------------------------
+
+
+async def _ask_user(command: str, ctx: Ctx) -> ConfirmOutcome:
+    """Ask the REPL to surface its in-app Accept/Deny dialog.
+
+    Falls back to a deny outcome when ``ctx.confirm`` isn't installed
+    — that should only happen outside the REPL context, where prompting
+    is impossible anyway.
+    """
+    if ctx.confirm is None:
+        sink = ctx.output if ctx.output is not None else ctx.console
+        sink.print(Text(f"(no confirm hook; denied: {command})", style="yellow"))
+        return ConfirmOutcome(accepted=False)
+    return await ctx.confirm(command)
+
+
+async def _run(command: str) -> str:
+    """Spawn ``command`` in a subprocess, capture merged output, truncate."""
+    proc = await asyncio.create_subprocess_shell(
+        command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+        cwd=os.getcwd(),  # noqa: PTH109 — we want literal cwd, not Path-resolved
+    )
+    try:
+        stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=_TIMEOUT_S)
+    except TimeoutError:
+        proc.kill()
+        await proc.wait()
+        return f"$ {command}\n(timed out after {int(_TIMEOUT_S)}s)"
+
+    output = stdout.decode("utf-8", errors="replace")
+    truncated = ""
+    if len(output) > _OUTPUT_LIMIT:
+        omitted = len(output) - _OUTPUT_LIMIT
+        output = output[:_OUTPUT_LIMIT]
+        truncated = f"\n... (truncated, {omitted} chars omitted)"
+
+    return f"$ {command}\nexit {proc.returncode}\n{output}{truncated}"

delos_cli/tools/write_content.py

@@ -0,0 +1,120 @@
+"""Client-side handler + renderer for the ``write_content`` tool.
+
+Writes ``content`` to an existing empty file at ``path``:
+
+1. Resolve the path against ``cwd`` (the user's launch folder).
+2. Refuse if the file is missing, not a regular file, or non-empty —
+   ``write_content`` is intentionally narrow so the agent can't ever
+   silently clobber existing data.  Creation is delegated to
+   ``run_shell touch …``; partial edits to ``edit_content``.
+3. Ask the user to approve the operation (path + content preview).
+4. Write the file (utf-8) and report back.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from rich.console import Group
+from rich.padding import Padding
+from rich.text import Text
+
+if TYPE_CHECKING:
+    from rich.console import RenderableType
+
+    from delos_cli.ctx import Ctx
+
+
+async def handle_write_content(tool_input: dict[str, Any], ctx: Ctx) -> str:
+    """Resolve a ``write_content`` call: validate, confirm, write."""
+    raw_path = (tool_input.get("path") or "").strip()
+    content = tool_input.get("content") or ""
+    if not raw_path:
+        return "Error: empty path."
+    if not isinstance(content, str):
+        return "Error: 'content' must be a string."
+
+    # ``ASYNC240`` flags pathlib calls inside async functions in case
+    # they block the event loop.  Tiny stat() / one-shot write here is
+    # fine; not worth pulling in ``anyio.path``.
+    path = Path(raw_path).expanduser()  # noqa: ASYNC240
+    if not path.is_absolute():
+        path = Path.cwd() / path
+
+    if not path.exists():
+        return (
+            f"Error: file does not exist: {path}. "
+            f"Use run_shell with `touch` to create it first."
+        )
+    if not path.is_file():
+        return f"Error: not a regular file: {path}."
+    if path.stat().st_size > 0:
+        return (
+            f"Error: file is not empty: {path}. "
+            f"write_content only writes to empty files; use edit_content "
+            f"to modify an existing file."
+        )
+
+    if ctx.confirm is None:
+        sink = ctx.output if ctx.output is not None else ctx.console
+        sink.print(
+            Text(f"(no confirm hook; aborted: write_content {path})", style="yellow"),
+        )
+        return "Tool rejected by the user."
+
+    # Print the proposed content into the scrollable output area so big
+    # blocks don't overflow the (small, fixed-height) confirm dialog.
+    if ctx.output is not None:
+        ctx.output.append_block(_content_panel(path, content))
+
+    outcome = await ctx.confirm(f"write_content → {path}  ({len(content)} chars)")
+    if not outcome.accepted:
+        if outcome.reason:
+            return f"Tool rejected by the user. Reason: {outcome.reason}"
+        return "Tool rejected by the user."
+
+    # TOCTOU guard: the file may have been touched between the empty-
+    # check and the user's approval.  Bail out if it's no longer empty
+    # so we never silently overwrite content the user just added.
+    try:
+        if path.stat().st_size > 0:
+            return (
+                f"Error: {path} is no longer empty (was when proposed). "
+                f"Re-check and propose again."
+            )
+    except OSError as e:
+        return f"Error re-reading {path}: {e}"
+
+    try:
+        path.write_text(content, encoding="utf-8")
+    except OSError as e:
+        return f"Error writing to {path}: {e}"
+    return f"Wrote {len(content)} chars to {path}."
+
+
+def render_write_content(event: dict[str, Any]) -> RenderableType | None:
+    """Show ``✎ write → path (N chars)`` instead of the default JSON panel."""
+    if event.get("type") != "tool-input-available":
+        return None
+    inputs = event.get("input") or {}
+    path = inputs.get("path") or ""
+    content = inputs.get("content") or ""
+    if not path:
+        return None
+    line = Text()
+    line.append("✎ ", style="bold green")
+    line.append("write → ", style="green")
+    line.append(str(path), style="bold green")
+    line.append(f"  ({len(content)} chars)", style="dim")
+    return line
+
+
+def _content_panel(path: Path, content: str) -> Padding:
+    """Render the proposed content (no border) for the output area."""
+    body = Text(content) if content else Text("(empty)", style="dim")
+    title = Text(
+        f"✎ proposed write → {path}  ({len(content)} chars)",
+        style="bold",
+    )
+    return Padding(Group(title, body), (0, 0, 0, 2))

delos_cli/transport/__init__.py

@@ -0,0 +1,24 @@
+"""Transport layer: authed HTTP client + one file per backend / Supabase resource."""
+
+from .chats import (
+    ChatListItem,
+    create_chat,
+    delete_chat,
+    fetch_messages,
+    list_recent,
+    rename_chat,
+)
+from .client import AuthedClient, TransportError
+from .models import fetch_models
+
+__all__ = [
+    "AuthedClient",
+    "ChatListItem",
+    "TransportError",
+    "create_chat",
+    "delete_chat",
+    "fetch_messages",
+    "fetch_models",
+    "list_recent",
+    "rename_chat",
+]