delos-cli 1.0.2__tar.gz → 1.0.3__tar.gz

delos_cli-1.0.3/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "disabledMcpjsonServers": [
+    "sentry",
+    "agent-analysis-localhost",
+    "agent-analysis-staging",
+    "agent-analysis-prod"
+  ]
+}

{delos_cli-1.0.2 → delos_cli-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: delos-cli
-Version: 1.0.2
+Version: 1.0.3
 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

{delos_cli-1.0.2 → delos_cli-1.0.3}/delos_cli/apps/chat/app.py

@@ -29,16 +29,20 @@ from delos_cli.tools import (
     handle_explore,
     handle_glob,
     handle_grep,
+    handle_lint_target,
     handle_read,
     handle_run_shell,
+    handle_run_tests,
     handle_todo_write,
     handle_write_content,
     render_edit_content,
     render_explore,
     render_glob,
     render_grep,
+    render_lint_target,
     render_read,
     render_run_shell,
+    render_run_tests,
     render_task,
     render_todo_write,
     render_write_content,
@@ -82,6 +86,11 @@ def default_tool_registry() -> ToolRegistry:
     # only its report — see delos_cli.tools.explore.
     reg.handlers["explore"] = handle_explore
     reg.renderers["explore"] = render_explore
+    # Verification tools — runner/linter auto-detection, see delos_cli.tools.verify.
+    reg.handlers["run_tests"] = handle_run_tests
+    reg.renderers["run_tests"] = render_run_tests
+    reg.handlers["lint_target"] = handle_lint_target
+    reg.renderers["lint_target"] = render_lint_target
     return reg
 
 

{delos_cli-1.0.2 → delos_cli-1.0.3}/delos_cli/apps/chat/commands.py

@@ -18,6 +18,7 @@ Two modes:
 from __future__ import annotations
 
 import contextlib
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from prompt_toolkit.application import get_app
@@ -25,6 +26,8 @@ from rich.text import Text
 
 from delos_cli.commands.base import CommandSpec, registry_from
 from delos_cli.commands.prompts import EXECUTE_PROMPT, INIT_PROMPT_NEW, INIT_PROMPT_UPDATE
+from delos_cli.context_report import fetch_context_report, render_report
+from delos_cli.git_context import collect_git_context
 from delos_cli.transport.chats import patch_chat_model
 from delos_cli.transport.client import TransportError
 
@@ -128,4 +131,34 @@ EXECUTE = CommandSpec(
 )
 
 
-CHAT_COMMANDS: dict[str, CommandSpec] = registry_from([MODEL, INIT, EXECUTE])
+# ---------------------------------------------------------------------------
+# /context — token breakdown of the next turn's LLM payload
+# ---------------------------------------------------------------------------
+
+
+async def _handle_context(ctx: Ctx, args: str) -> None:
+    """Fetch the backend context-report for this chat and render it."""
+    _ = args
+    sink = _sink(ctx)
+    git_ctx = await collect_git_context(Path.cwd())
+    try:
+        report = await fetch_context_report(
+            ctx.http,
+            ctx.state.conv_id,
+            custom_instructions=ctx.custom_instructions or None,
+            git_context=git_ctx,
+        )
+    except TransportError as e:
+        sink.print(Text(f"context report failed: {e}", style="red"))
+        return
+    sink.print(render_report(report))
+
+
+CONTEXT = CommandSpec(
+    name="/context",
+    summary="show what fills the agent's context window (token breakdown)",
+    handler=_handle_context,
+)
+
+
+CHAT_COMMANDS: dict[str, CommandSpec] = registry_from([MODEL, INIT, EXECUTE, CONTEXT])

{delos_cli-1.0.2 → delos_cli-1.0.3}/delos_cli/apps/chat/render.py

@@ -55,6 +55,10 @@ class V6Renderer:
         self._spinner = Spinner("dots", text=" thinking", style="dim")
         self._thinking = False
         self._anim_task: asyncio.Task[None] | None = None
+        # Inside a <think>…</think> fence — AgentV2 streams model reasoning
+        # inline between literal tag deltas. Reasoning is swallowed (the
+        # spinner keeps running) so it never lands in scrollback.
+        self._in_think = False
 
     def apply(self, event: dict[str, Any]) -> None:
         """Apply a single v6 event to the output buffer."""
@@ -76,6 +80,16 @@ class V6Renderer:
             delta = event.get("delta", "")
             if not delta:
                 return
+            # Each <think> / </think> tag arrives as its own delta
+            # (agent_v2 injects them around reasoning), so plain equality
+            # checks are enough — no tag can be split across deltas.
+            if delta == "<think>":
+                self._in_think = True
+                return
+            if self._in_think:
+                if delta.startswith("</think>"):
+                    self._in_think = False
+                return
             self._stop_thinking()
             self._assistant_text += delta
             self._output.update_live(Markdown(self._assistant_text))

{delos_cli-1.0.2 → delos_cli-1.0.3}/delos_cli/apps/replay.py

@@ -20,6 +20,7 @@ from rich.markdown import Markdown
 from rich.text import Text
 
 from delos_cli.agent import default_renderer
+from delos_cli.ui.style import user_echo
 
 if TYPE_CHECKING:
     from delos_cli.apps.base import App
@@ -49,7 +50,8 @@ def replay_messages(
         if role == "user":
             text = _extract_text(msg.get("content"))
             if text:
-                output.print(Text(f"» {text}\n", style="bold cyan"))
+                output.print(user_echo(text))
+                output.print(Text(""))
         elif role == "assistant":
             text = _extract_text(msg.get("content"))
             if text:

{delos_cli-1.0.2 → delos_cli-1.0.3}/delos_cli/commands/prompts.py

@@ -40,6 +40,8 @@ as you go. If no plan exists in this conversation, say so instead of \
 improvising one."""
 
 #: Catalogue served to frontends (``list_commands`` RPC) for autocomplete.
+#: ``/context`` is not a prompt expansion — serve intercepts it and answers
+#: locally — but it belongs in the same autocomplete list.
 PROMPT_COMMANDS: tuple[dict[str, str], ...] = (
     {
         "name": "/init",
@@ -49,6 +51,10 @@ PROMPT_COMMANDS: tuple[dict[str, str], ...] = (
         "name": "/execute",
         "summary": "execute the plan from the previous plan-mode turn (loads it into todos)",
     },
+    {
+        "name": "/context",
+        "summary": "show what fills the agent's context window (token breakdown)",
+    },
 )
 
 

delos_cli-1.0.3/delos_cli/context_report.py

@@ -0,0 +1,176 @@
+"""``/context`` — fetch and render the agent's context-window breakdown.
+
+The backend endpoint (``POST /cli/chats/{id}/context-report``) rebuilds
+exactly what the next turn would send to the LLM and returns a token
+breakdown.  This module owns the client side: the transport call and two
+renderings of the same report — Rich for the REPL, markdown for serve
+mode (displayed as a synthetic assistant message in VSCode).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from rich.text import Text
+
+if TYPE_CHECKING:
+    from delos_cli.transport.client import AuthedClient
+
+_BAR_WIDTH = 30
+
+
+async def fetch_context_report(
+    http: AuthedClient,
+    chat_id: str,
+    *,
+    custom_instructions: str | None,
+    git_context: str | None,
+) -> dict[str, Any]:
+    """POST ``/cli/chats/{chat_id}/context-report`` and return the breakdown."""
+    return await http.json_post(
+        f"/cli/chats/{chat_id}/context-report",
+        {
+            "org_uuid": http.cfg.org_uuid,
+            "custom_instructions": custom_instructions,
+            "git_context": git_context,
+        },
+    )
+
+
+# ---------------------------------------------------------------------------
+# Shared shaping
+# ---------------------------------------------------------------------------
+
+
+def _fmt(n: int) -> str:
+    """Compact token count: 1234 → ``1.2k``."""
+    if n >= 1000:  # noqa: PLR2004 — display threshold, not business logic
+        return f"{n / 1000:.1f}k"
+    return str(n)
+
+
+def _lines(report: dict[str, Any]) -> list[tuple[str, str]]:
+    """(label, value) pairs shared by both renderings."""
+    msgs = report.get("messages") or {}
+    by_role = msgs.get("by_role") or {}
+    out = [
+        ("Model", str(report.get("model", "?"))),
+        (
+            "System prompt",
+            f"{_fmt(report.get('system_prompt_tokens', 0))} tokens",
+        ),
+        (
+            "Tools",
+            (
+                f"{_fmt((report.get('tools') or {}).get('tokens', 0))} tokens "
+                f"({(report.get('tools') or {}).get('count', 0)} tools)"
+            ),
+        ),
+        (
+            "Messages",
+            f"{_fmt(msgs.get('tokens', 0))} tokens ({msgs.get('count', 0)} messages)",
+        ),
+    ]
+    for role in ("user", "assistant", "tool"):
+        stats = by_role.get(role)
+        if stats:
+            out.append(
+                (
+                    f"  {role}",
+                    f"{_fmt(stats.get('tokens', 0))} tokens ({stats.get('count', 0)})",
+                ),
+            )
+    compacted = report.get("compacted_messages", 0)
+    if compacted:
+        out.append(("Compacted away", f"{compacted} messages (summarised)"))
+    return out
+
+
+def _usage(report: dict[str, Any]) -> tuple[int, int, int, float]:
+    """(total, window, threshold, ratio) with safe fallbacks."""
+    total = int(report.get("total_tokens", 0))
+    window = int(report.get("context_window", 0)) or 1
+    threshold = int(report.get("compact_threshold", 0))
+    return total, window, threshold, min(1.0, total / window)
+
+
+# ---------------------------------------------------------------------------
+# REPL rendering (Rich)
+# ---------------------------------------------------------------------------
+
+
+def render_report(report: dict[str, Any]) -> Text:
+    """Rich rendering for the REPL output buffer."""
+    total, window, threshold, ratio = _usage(report)
+    filled = round(ratio * _BAR_WIDTH)
+    bar_style = "red" if total >= threshold else "yellow" if ratio > 0.5 else "green"  # noqa: PLR2004
+
+    text = Text()
+    text.append("Context usage\n", style="bold")
+    text.append("█" * filled, style=bar_style)
+    text.append("░" * (_BAR_WIDTH - filled), style="dim")
+    text.append(f"  {_fmt(total)} / {_fmt(window)} tokens ({ratio:.0%})\n", style="bold")
+    text.append(f"auto-compaction at {_fmt(threshold)}\n\n", style="dim")
+
+    for label, value in _lines(report):
+        text.append(f"{label:<16}", style="cyan" if not label.startswith(" ") else "dim")
+        text.append(f"{value}\n")
+
+    by_tool = (report.get("messages") or {}).get("by_tool") or []
+    if by_tool:
+        text.append("\nHeaviest tools\n", style="bold")
+        for t in by_tool:
+            text.append(f"  {t.get('name', '?'):<24}", style="magenta")
+            text.append(f"{_fmt(t.get('tokens', 0)):>8}  ({t.get('calls', 0)} calls)\n")
+
+    top = (report.get("messages") or {}).get("top") or []
+    if top:
+        text.append("\nLargest messages\n", style="bold")
+        for m in top:
+            who = m.get("tool") or m.get("role", "?")
+            text.append(f"  #{m.get('index', 0):<4} {who:<20}", style="dim")
+            text.append(f"{_fmt(m.get('tokens', 0)):>8}  ")
+            text.append(f"{m.get('preview', '')[:60]}\n", style="dim")
+    return text
+
+
+# ---------------------------------------------------------------------------
+# Serve rendering (markdown — shown as an assistant message in VSCode)
+# ---------------------------------------------------------------------------
+
+
+def format_report_markdown(report: dict[str, Any]) -> str:
+    """Markdown rendering for serve mode."""
+    total, window, threshold, ratio = _usage(report)
+    filled = round(ratio * _BAR_WIDTH)
+    lines = [
+        "**Context usage**",
+        "",
+        (
+            f"`{'█' * filled}{'░' * (_BAR_WIDTH - filled)}` "
+            f"**{_fmt(total)} / {_fmt(window)} tokens ({ratio:.0%})** "
+            f"— auto-compaction at {_fmt(threshold)}"
+        ),
+        "",
+        "| | |",
+        "|---|---|",
+    ]
+    lines.extend(f"| {label.strip()} | {value} |" for label, value in _lines(report))
+
+    by_tool = (report.get("messages") or {}).get("by_tool") or []
+    if by_tool:
+        lines += ["", "**Heaviest tools**", "", "| tool | tokens | calls |", "|---|---|---|"]
+        lines.extend(
+            f"| {t.get('name', '?')} | {_fmt(t.get('tokens', 0))} | {t.get('calls', 0)} |"
+            for t in by_tool
+        )
+
+    top = (report.get("messages") or {}).get("top") or []
+    if top:
+        lines += ["", "**Largest messages**", ""]
+        lines.extend(
+            f"- `#{m.get('index', 0)}` {m.get('tool') or m.get('role', '?')} — "
+            f"{_fmt(m.get('tokens', 0))} tokens — {m.get('preview', '')[:60]}"
+            for m in top
+        )
+    return "\n".join(lines)

{delos_cli-1.0.2 → delos_cli-1.0.3}/delos_cli/serve/server.py

@@ -20,6 +20,7 @@ from delos_cli.agent import AgentSession, AgentTransport
 from delos_cli.auth import config as cfg_mod
 from delos_cli.auth.oauth import OAuthError, run_login_flow
 from delos_cli.commands.prompts import PROMPT_COMMANDS, expand_slash_command
+from delos_cli.context_report import fetch_context_report, format_report_markdown
 from delos_cli.ctx import ConfirmOutcome, Ctx
 from delos_cli.git_context import collect_git_context
 from delos_cli.project_context import load_project_context
@@ -174,6 +175,14 @@ class StdioServer:
             self.send({"type": "error", "message": "user_message needs chatId and content"})
             return
 
+        # `/context` never reaches the agent: it's a local diagnostic that
+        # renders the backend's context-report as a synthetic assistant
+        # message (start / text-delta / finish), so it works from the
+        # VSCode input without extension changes.
+        if content.strip() == "/context":
+            await self._run_context_report(chat_id, turn_id)
+            return
+
         # One active turn per chat — a new message supersedes the old one
         # (same semantics as the extension's previous abort-then-send).
         if (existing := self.turns.get(chat_id)) and not existing.done():
@@ -278,6 +287,45 @@ class StdioServer:
                 self._log(f"turn failed for {chat_id}: {error_text}")
             self.send(done)
 
+    async def _run_context_report(self, chat_id: str, turn_id: str) -> None:
+        """Handle ``/context``: fetch the token breakdown, emit it as a turn."""
+        self.send({"type": "turn_started", "chatId": chat_id, "turnId": turn_id})
+        error_text: str | None = None
+        text: str | None = None
+        try:
+            http = self.require_http()
+            git_ctx = await collect_git_context(self.workspace)
+            report = await fetch_context_report(
+                http,
+                chat_id,
+                custom_instructions=self.custom_instructions or None,
+                git_context=git_ctx,
+            )
+            text = format_report_markdown(report)
+        except Exception as e:
+            error_text = f"context report failed: {type(e).__name__}: {e}"
+        if text is not None:
+            message_id = str(uuid.uuid4())
+            for event in (
+                {"type": "start", "messageId": message_id},
+                {"type": "text-delta", "id": message_id, "delta": text},
+                {"type": "finish"},
+            ):
+                self.send({
+                    "type": "event",
+                    "chatId": chat_id,
+                    "turnId": turn_id,
+                    "event": event,
+                })
+        done: dict[str, Any] = {
+            "type": "turn_finished",
+            "chatId": chat_id,
+            "turnId": turn_id,
+        }
+        if error_text:
+            done["error"] = error_text
+        self.send(done)
+
     async def _abort_turn(self, chat_id: str) -> None:
         if not chat_id:
             return

{delos_cli-1.0.2 → delos_cli-1.0.3}/delos_cli/tools/__init__.py

@@ -14,6 +14,12 @@ from .read import handle_read, render_read
 from .run_shell import handle_run_shell, render_run_shell
 from .task import render_task
 from .todo_write import handle_todo_write, render_todo_write
+from .verify import (
+    handle_lint_target,
+    handle_run_tests,
+    render_lint_target,
+    render_run_tests,
+)
 from .write_content import handle_write_content, render_write_content
 
 __all__ = [
@@ -21,16 +27,20 @@ __all__ = [
     "handle_explore",
     "handle_glob",
     "handle_grep",
+    "handle_lint_target",
     "handle_read",
     "handle_run_shell",
+    "handle_run_tests",
     "handle_todo_write",
     "handle_write_content",
     "render_edit_content",
     "render_explore",
     "render_glob",
     "render_grep",
+    "render_lint_target",
     "render_read",
     "render_run_shell",
+    "render_run_tests",
     "render_task",
     "render_todo_write",
     "render_write_content",

{delos_cli-1.0.2 → delos_cli-1.0.3}/delos_cli/tools/edit_content.py

@@ -36,6 +36,12 @@ if TYPE_CHECKING:
 
 _DIFF_CONTEXT_LINES = 8
 
+#: Full-line diff highlights (git/Claude-Code style): dark red / green
+#: backgrounds with the terminal's default text color on top.  256-palette
+#: colors render identically in truecolor and 256-color terminals.
+_DEL_BG = "on color(52)"
+_ADD_BG = "on color(22)"
+
 #: 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
@@ -207,17 +213,25 @@ def _diff_panel(path: Path, file_text: str, new_text: str) -> Padding:
                 )
             continue
         # Change block: pair the k-th deleted line with the k-th added one.
+        # ``Padding`` paints the background across the full cell width on
+        # every wrapped row — a styled ``Text`` would only tint the glyphs.
         dels = list(range(i1, i2))
         adds = list(range(j1, j2))
         for k in range(max(len(dels), len(adds))):
-            old_no, old_text = ("", Text(""))
-            new_no, new_text_cell = ("", Text(""))
+            old_no: str = ""
+            new_no: str = ""
+            old_text: RenderableType = Text("")
+            new_text_cell: RenderableType = Text("")
             if k < len(dels):
                 old_no = str(dels[k] + 1)
-                old_text = Text(old_lines[dels[k]], style="red")
+                old_text = Padding(
+                    Text(old_lines[dels[k]]), 0, style=_DEL_BG, expand=True,
+                )
             if k < len(adds):
                 new_no = str(adds[k] + 1)
-                new_text_cell = Text(new_lines[adds[k]], style="green")
+                new_text_cell = Padding(
+                    Text(new_lines[adds[k]]), 0, style=_ADD_BG, expand=True,
+                )
             table.add_row(old_no, old_text, new_no, new_text_cell)
 
     title = Text(f"✎ proposed edit → {path}", style="bold")

{delos_cli-1.0.2 → delos_cli-1.0.3}/delos_cli/tools/explore.py

@@ -38,7 +38,10 @@ if TYPE_CHECKING:
 
     from delos_cli.ctx import Ctx
 
-_WALL_CLOCK_BUDGET_S = 300.0  # 5 minutes, mirrors the backend `task` tool
+# Hard wall-clock cap: the parent turn (and the user) blocks on this. On
+# timeout the handler still returns the last finished message as a partial
+# report, so a lost explorer costs at most 2.5 minutes, not an open-ended wait.
+_WALL_CLOCK_BUDGET_S = 150.0
 _MAX_REPORT_CHARS = 10_000
 
 #: Reasoning blocks some models emit inline in their text — never part of
@@ -147,11 +150,13 @@ async def handle_explore(tool_input: dict[str, Any], ctx: Ctx) -> str:
         return "Error: explore requires a non-empty 'prompt'."
 
     try:
+        # No ``model=``: the backend forces a fast model for explore rows
+        # (see CliContextBuilder) — passing the parent's model here would
+        # only make the row lie about what actually ran.
         sub_chat_id = await create_chat(
             ctx.http,
             folder=str(Path.cwd()),
             name=f"explore: {description}",
-            model=ctx.state.model,
             surface="explore",
         )
     except TransportError as e:

{delos_cli-1.0.2 → delos_cli-1.0.3}/delos_cli/tools/run_shell.py

@@ -40,8 +40,27 @@ if TYPE_CHECKING:
 #: 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"})
+#: ``-delete`` and ``-exec``.  ``grep``/``rg`` are absent too — their
+#: matched-text output can smuggle metacharacters and they are better
+#: served by the dedicated ``grep`` tool.
+_SAFE_BINARIES: frozenset[str] = frozenset(
+    {"ls", "cat", "head", "tail", "wc", "file", "du", "tree", "stat", "pwd"},
+)
+
+#: Read-only ``git`` subcommands.  ``branch`` is absent (``git branch -D``
+#: deletes); history / inspection is what read-only usage actually needs.
+_SAFE_GIT_SUBCOMMANDS: frozenset[str] = frozenset({
+    "log",
+    "show",
+    "diff",
+    "blame",
+    "status",
+    "shortlog",
+    "ls-files",
+    "rev-parse",
+    "describe",
+    "grep",
+})
 
 #: Tokens that can turn a read into a write (redirection / chaining /
 #: substitution).  Their presence anywhere in the command forces a
@@ -55,14 +74,23 @@ _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.
+    Allowlist-based and fails closed: any token that could redirect /
+    chain / substitute is rejected, ``--output`` (which makes ``git
+    log``/``diff`` write a file) is rejected, git global flags (``git -c
+    core.pager=… log`` would execute the pager) are rejected, and only
+    bare read-only binaries / git subcommands pass.
     """
     if any(tok in command for tok in _UNSAFE_TOKENS):
         return False
-    parts = command.strip().split(maxsplit=1)
+    parts = command.split()
     if not parts:
         return False
+    if any(p.startswith("--output") for p in parts):
+        return False
+    if parts[0] == "git":
+        # The subcommand must come immediately after ``git`` — global
+        # flags (-c, -C, --exec-path…) are rejected wholesale.
+        return len(parts) > 1 and parts[1] in _SAFE_GIT_SUBCOMMANDS
     return parts[0] in _SAFE_BINARIES