cade-cli 0.20.6__tar.gz → 0.20.7__tar.gz

{cade_cli-0.20.6 → cade_cli-0.20.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cade-cli
-Version: 0.20.6
+Version: 0.20.7
 Summary: Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://arcadeagent.dev/docs

{cade_cli-0.20.6 → cade_cli-0.20.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.20.6"
+version = "0.20.7"
 description = "Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)"
 readme = "README.md"
 requires-python = ">=3.11"

{cade_cli-0.20.6 → cade_cli-0.20.7}/src/cadecoder/storage/threads.py

@@ -176,6 +176,16 @@ class BaseThreadHistory(ABC):
         """Retrieves all messages for a given thread."""
         raise NotImplementedError
 
+    @abstractmethod
+    def replace_messages(self, thread_id: str, messages: list[Message]) -> None:
+        """Atomically replace all of a thread's messages (used by manual compaction).
+
+        Args:
+            thread_id: Thread whose messages are replaced.
+            messages: New messages to persist in place of the existing ones.
+        """
+        raise NotImplementedError
+
     @abstractmethod
     def get_thread(self, thread_id: str) -> Thread | None:
         """Retrieves thread metadata."""
@@ -533,6 +543,47 @@ class SqliteThreadHistory(BaseThreadHistory):
             log.error(f"Failed to add message: {e}")
             raise
 
+    def replace_messages(self, thread_id: str, messages: list[Message]) -> None:
+        """Delete a thread's messages and insert ``messages`` in their place.
+
+        Used by manual compaction (``/compact``): a turn always reloads the
+        full persisted thread from storage, so compacting only the in-memory
+        request would have no lasting effect — the next turn reconstructs the
+        same bloated context. This is the write-back half of that fix.
+        """
+        if not self._conn:
+            raise StorageError("Database connection is not available.")
+        try:
+            self._conn.execute("BEGIN")
+            self._execute("DELETE FROM messages WHERE conversation_id = ?", (thread_id,))
+            for message in messages:
+                message.thread_id = thread_id
+                if not message.message_id:
+                    message.message_id = str(ulid()).lower()
+                msg_data = message.model_dump_db()
+                self._execute(
+                    """
+                    INSERT INTO messages (
+                        id, conversation_id, role, content, timestamp,
+                        tool_calls_json, tool_call_id, model_info_json,
+                        parent_message_id, conversation_turn
+                    )
+                    VALUES (
+                        :id, :conversation_id, :role, :content, :timestamp,
+                        :tool_calls_json, :tool_call_id, :model_info_json,
+                        :parent_message_id, :conversation_turn
+                    )
+                    """,
+                    msg_data,
+                )
+            self._conn.execute("COMMIT")
+        except Exception as e:
+            self._conn.execute("ROLLBACK")
+            log.error(f"Failed to replace messages for thread {thread_id}: {e}")
+            raise
+        self.update_thread_timestamp(thread_id)
+        log.info(f"Replaced thread {thread_id} history with {len(messages)} message(s)")
+
     def _ensure_thread_exists(self, thread_id: str) -> None:
         """Create a thread record if it doesn't already exist."""
         if self.get_thread(thread_id):

{cade_cli-0.20.6 → cade_cli-0.20.7}/src/cadecoder/ui/session.py

@@ -19,8 +19,14 @@ from cadecoder.core.constants import DEFAULT_AI_MODEL
 from cadecoder.core.errors import AuthError
 from cadecoder.core.git import get_current_branch_name
 from cadecoder.core.logging import log
+from cadecoder.core.runtime import get_runtime
 from cadecoder.core.text import strip_control_signals
 from cadecoder.core.types import ExecutionEventType
+from cadecoder.execution.context_window import (
+    CompactionStrategy,
+    ContextWindowManager,
+    create_context_manager,
+)
 from cadecoder.execution.orchestrator import (
     ExecutionContext,
     create_orchestrator,
@@ -241,6 +247,30 @@ class ChatSession:
             log.warning(f"Failed to save user message: {e}")
         return message
 
+    @staticmethod
+    def _tool_call_infos(tool_calls: list[dict[str, Any]] | None) -> list[ToolCallInfo]:
+        """Convert OpenAI-format ``tool_calls`` into storable ``ToolCallInfo``."""
+        tc_infos = []
+        for tc in tool_calls or []:
+            func = tc.get("function", {})
+            args_raw = func.get("arguments", "{}")
+            if isinstance(args_raw, str):
+                try:
+                    params = json.loads(args_raw)
+                except json.JSONDecodeError:
+                    params = {"raw": args_raw}
+            else:
+                params = args_raw if isinstance(args_raw, dict) else {}
+
+            tc_infos.append(
+                ToolCallInfo(
+                    call_id=tc.get("id", str(ulid()).lower()),
+                    tool_name=func.get("name", "unknown"),
+                    parameters=params,
+                )
+            )
+        return tc_infos
+
     def save_assistant_message(
         self,
         content: str | None,
@@ -248,33 +278,12 @@ class ChatSession:
         model_info: ModelInfo | None = None,
     ) -> Message:
         """Save an assistant message."""
-        tc_infos = []
-        if tool_calls:
-            for tc in tool_calls:
-                func = tc.get("function", {})
-                args_raw = func.get("arguments", "{}")
-                if isinstance(args_raw, str):
-                    try:
-                        params = json.loads(args_raw)
-                    except json.JSONDecodeError:
-                        params = {"raw": args_raw}
-                else:
-                    params = args_raw if isinstance(args_raw, dict) else {}
-
-                tc_infos.append(
-                    ToolCallInfo(
-                        call_id=tc.get("id", str(ulid()).lower()),
-                        tool_name=func.get("name", "unknown"),
-                        parameters=params,
-                    )
-                )
-
         message = Message(
             id=str(ulid()).lower(),
             thread_id=self.thread_id,
             role="assistant",
             content=content,
-            tool_calls=tc_infos,
+            tool_calls=self._tool_call_infos(tool_calls),
             model_info=model_info,
         )
         try:
@@ -601,6 +610,8 @@ class ChatSession:
             self._print_thread_info()
             self._print_context_usage()
             self._print_history()
+        elif cmd == "/compact":
+            await self._handle_compact_command()
         elif cmd == "/logs":
             display_logs()
         elif cmd == "/tools":
@@ -840,22 +851,86 @@ class ChatSession:
         else:
             console.print(f"[cyan]Thread:[/cyan] [dim]{self.thread_id}[/dim]")
 
+    def _resolve_context_manager(self) -> ContextWindowManager:
+        """Return the live orchestrator's context manager, or build an equivalent one.
+
+        Attached-to-daemon sessions (the default when a daemon is running)
+        have no local orchestrator — turns run server-side — so ``self.orchestrator``
+        is ``None`` and there's nothing to delegate to. Build a standalone
+        manager from this run's resolved model/context_window instead of
+        crashing; it computes the same status/compaction a live one would.
+        """
+        if self.orchestrator is not None:
+            return self.orchestrator.context_manager
+        return create_context_manager(
+            model=self.model, context_window_override=get_runtime().context_window
+        )
+
+    def _message_from_llm_dict(self, msg: dict[str, Any]) -> Message:
+        """Convert a compacted LLM-format message dict back into a persistable ``Message``."""
+        role = msg.get("role", "user")
+        return Message(
+            id=str(ulid()).lower(),
+            thread_id=self.thread_id,
+            role=role,
+            content=msg.get("content"),
+            tool_calls=self._tool_call_infos(msg.get("tool_calls")) if role == "assistant" else [],
+            responding_tool_call_id=msg.get("tool_call_id") if role == "tool" else None,
+        )
+
     def _print_context_usage(self) -> None:
         """Print context-window usage and tool-output summary."""
         history = self.get_conversation_history()
-        status = self.orchestrator.get_context_status(history)
+        context_manager = self._resolve_context_manager()
+        status = context_manager.check_context_status(history)
         console.print("\n[cyan]Context Window:[/cyan]")
         console.print(f"  Tokens: {status['token_count']:,} / {status['effective_limit']:,}")
         console.print(f"  Used: {status['percentage_used']}%")
         console.print(f"  Messages: {status['message_count']}")
         console.print(f"  Needs compaction: {status['needs_compaction']}")
 
-        tool_summary = self.orchestrator.get_tool_outputs_summary()
-        if tool_summary["total_outputs"] > 0:
-            console.print("\n[cyan]Tool Outputs:[/cyan]")
-            console.print(f"  Total outputs: {tool_summary['total_outputs']}")
-            console.print(f"  Unique tools: {tool_summary['unique_tools']}")
-            console.print(f"  Estimated tokens: {tool_summary['estimated_tokens']:,}")
+        if self.orchestrator is not None:
+            tool_summary = self.orchestrator.get_tool_outputs_summary()
+            if tool_summary["total_outputs"] > 0:
+                console.print("\n[cyan]Tool Outputs:[/cyan]")
+                console.print(f"  Total outputs: {tool_summary['total_outputs']}")
+                console.print(f"  Unique tools: {tool_summary['unique_tools']}")
+                console.print(f"  Estimated tokens: {tool_summary['estimated_tokens']:,}")
+
+    async def _handle_compact_command(self) -> None:
+        """Manually compact the current thread's history ahead of the auto-compaction threshold.
+
+        Unlike the automatic compaction that runs mid-turn (transient — it
+        only shrinks that one outgoing request), this persists the trimmed
+        history back to storage via ``replace_messages`` so the *next* turn
+        — which always reloads the full thread from disk — actually sees a
+        smaller context instead of reconstructing the same bloated one.
+        """
+        history = self.get_conversation_history()
+        if not history:
+            console.print("[dim]Nothing to compact — no messages yet.[/dim]")
+            return
+
+        context_manager = self._resolve_context_manager()
+        before = context_manager.check_context_status(history)
+        compacted, backup = context_manager.compact_context(
+            history, strategy=CompactionStrategy.KEEP_RECENT, thread_id=self.thread_id
+        )
+        try:
+            self.history_manager.replace_messages(
+                self.thread_id, [self._message_from_llm_dict(m) for m in compacted]
+            )
+        except Exception as e:
+            console.print(f"[red]Failed to persist compacted history: {escape(str(e))}[/red]")
+            return
+
+        after = context_manager.check_context_status(compacted)
+        console.print(
+            f"[green]Compacted:[/green] {before['token_count']:,} -> "
+            f"{after['token_count']:,} tokens "
+            f"({before['message_count']} -> {after['message_count']} messages), "
+            f"backup saved {backup.timestamp.isoformat()}"
+        )
 
     def _print_history(self) -> None:
         """Print the conversation history for the current thread."""

{cade_cli-0.20.6 → cade_cli-0.20.7}/src/cadecoder/ui/slash.py

@@ -35,6 +35,7 @@ SLASH_COMMANDS: tuple[SlashCommand, ...] = (
     SlashCommand("/thread", "", "Show thread info, context usage, and history"),
     SlashCommand("/usage", "", "Show context window status and token usage", hidden=True),
     SlashCommand("/history", "", "Show conversation history", hidden=True),
+    SlashCommand("/compact", "", "Compact the context window now, ahead of the auto threshold"),
     SlashCommand("/model", " [list|name]", "Show, list, or switch model", ("list",)),
     SlashCommand(
         "/tasks",