soothe-cli 0.1.0__py3-none-any.whl

soothe_cli/tui/daemon_session.py

@@ -0,0 +1,233 @@
+"""Daemon-backed session helpers for the Textual TUI."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from langchain_core.messages import messages_from_dict
+from soothe_sdk.client import (
+    WebSocketClient,
+    bootstrap_thread_session,
+    connect_websocket_with_retries,
+    websocket_url_from_config,
+)
+
+if TYPE_CHECKING:
+    pass
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class DaemonStateSnapshot:
+    """Minimal `aget_state()` compatible wrapper."""
+
+    values: dict[str, Any]
+
+
+class TuiDaemonSession:
+    """Own the daemon websocket session used by the TUI."""
+
+    def __init__(self, cfg: Any) -> None:
+        self._cfg = cfg
+        self._client = WebSocketClient(url=websocket_url_from_config(cfg))
+        self._thread_id: str | None = None
+        self._read_lock = asyncio.Lock()
+        self._streaming = False
+
+    @property
+    def thread_id(self) -> str | None:
+        """Current thread ID known to the session."""
+        return self._thread_id
+
+    async def connect(self, *, resume_thread_id: str | None = None) -> dict[str, Any]:
+        """Connect and bootstrap a daemon thread session."""
+        await connect_websocket_with_retries(self._client)
+        status_event = await self._bootstrap_thread(resume_thread_id=resume_thread_id)
+        return status_event
+
+    async def _bootstrap_thread(self, *, resume_thread_id: str | None = None) -> dict[str, Any]:
+        """Create or resume a daemon thread on an already-connected websocket."""
+        status_event = await bootstrap_thread_session(
+            self._client,
+            resume_thread_id=resume_thread_id,
+            verbosity=self._cfg.logging.verbosity,
+        )
+        if status_event.get("type") == "error":
+            raise RuntimeError(str(status_event.get("message", "daemon bootstrap failed")))
+        self._thread_id = status_event.get("thread_id")
+        return status_event
+
+    async def new_thread(self) -> dict[str, Any]:
+        """Switch the session to a new daemon thread."""
+        return await self._bootstrap_thread(resume_thread_id=None)
+
+    async def switch_thread(self, thread_id: str) -> dict[str, Any]:
+        """Switch the session to a specific persisted thread."""
+        return await self._bootstrap_thread(resume_thread_id=thread_id)
+
+    async def close(self) -> None:
+        """Close the daemon websocket."""
+        await self._client.close()
+
+    async def detach(self) -> None:
+        """Detach this client from the daemon."""
+        await self._client.send_detach()
+
+    async def send_turn(
+        self,
+        text: str,
+        *,
+        autonomous: bool = False,
+        max_iterations: int | None = None,
+        subagent: str | None = None,
+        interactive: bool = True,
+        model: str | None = None,
+        model_params: dict[str, Any] | None = None,
+    ) -> None:
+        """Send a new user turn to the daemon."""
+        await self._client.send_input(
+            text,
+            autonomous=autonomous,
+            max_iterations=max_iterations,
+            subagent=subagent,
+            interactive=interactive,
+            model=model,
+            model_params=model_params,
+        )
+
+    async def cancel_remote_query(self) -> None:
+        """Ask the daemon to cancel the in-flight query (same wire path as ``/cancel``)."""
+        await self._client.send_command("/cancel")
+
+    async def resume_interrupts(self, resume_payload: dict[str, Any]) -> None:
+        """Resume a paused interactive turn."""
+        if not self._thread_id:
+            raise RuntimeError("No active daemon thread")
+        await self._client.send_resume_interrupts(self._thread_id, resume_payload)
+
+    async def iter_turn_chunks(self) -> Any:
+        """Yield `(namespace, mode, data)` chunks for the active daemon turn."""
+        query_started = False
+        self._streaming = True
+        async with self._read_lock:
+            try:
+                while True:
+                    event = await self._client.read_event()
+                    if not event:
+                        break
+
+                    event_type = event.get("type", "")
+                    if event_type == "error":
+                        raise RuntimeError(str(event.get("message", "daemon error")))
+
+                    if event_type == "status":
+                        thread_id = event.get("thread_id")
+                        if isinstance(thread_id, str) and thread_id:
+                            self._thread_id = thread_id
+                        state = event.get("state", "")
+                        if state == "running":
+                            query_started = True
+                        elif query_started and state in {"idle", "stopped"}:
+                            break
+                        continue
+
+                    if event_type != "event":
+                        continue
+
+                    data = event.get("data")
+                    if (
+                        isinstance(data, dict)
+                        and data.get("type") == "soothe.system.daemon.heartbeat"
+                    ):
+                        continue
+
+                    namespace = tuple(event.get("namespace", []) or [])
+                    mode = str(event.get("mode", ""))
+                    normalized = self._normalize_stream_data(mode, data)
+                    yield (namespace, mode, normalized)
+                    if (
+                        mode == "updates"
+                        and isinstance(normalized, dict)
+                        and "__interrupt__" in normalized
+                    ):
+                        break
+            finally:
+                self._streaming = False
+
+    def _normalize_stream_data(self, mode: str, data: Any) -> Any:
+        """Convert daemon wire payloads back to TUI-friendly objects."""
+        if mode != "messages":
+            return data
+
+        if not isinstance(data, (list, tuple)) or len(data) != 2:
+            return data
+
+        message, metadata = data
+        if isinstance(message, dict):
+            try:
+                restored = messages_from_dict([message])
+                if restored:
+                    message = restored[0]
+            except Exception:
+                logger.debug("Failed to restore message from daemon payload", exc_info=True)
+        return (message, metadata)
+
+    async def aget_state(self, config: dict[str, Any]) -> DaemonStateSnapshot:
+        """Fetch thread state values through the daemon."""
+        thread_id = str(config.get("configurable", {}).get("thread_id", "")).strip()
+        if not thread_id:
+            return DaemonStateSnapshot(values={})
+        async with self._read_lock:
+            response = await self._client.request_response(
+                {"type": "thread_state", "thread_id": thread_id},
+                response_type="thread_state_response",
+            )
+        values = response.get("values", {})
+        if not isinstance(values, dict):
+            values = {}
+        messages = values.get("messages")
+        if isinstance(messages, list) and messages and isinstance(messages[0], dict):
+            try:
+                values = dict(values)
+                values["messages"] = messages_from_dict(messages)
+            except Exception:
+                logger.debug("Failed to deserialize thread-state messages", exc_info=True)
+        return DaemonStateSnapshot(values=values)
+
+    async def aupdate_state(self, config: dict[str, Any], values: dict[str, Any]) -> None:
+        """Persist partial thread state through the daemon."""
+        thread_id = str(config.get("configurable", {}).get("thread_id", "")).strip()
+        if not thread_id:
+            return
+        async with self._read_lock:
+            await self._client.request_response(
+                {
+                    "type": "thread_update_state",
+                    "thread_id": thread_id,
+                    "values": values,
+                },
+                response_type="thread_update_state_response",
+            )
+
+    async def list_skills(self) -> list[dict[str, Any]]:
+        """Return skill rows from the daemon catalog (no filesystem paths)."""
+        async with self._read_lock:
+            response = await self._client.list_skills(timeout=15.0)
+        skills = response.get("skills", [])
+        if not isinstance(skills, list):
+            return []
+        return [s for s in skills if isinstance(s, dict)]
+
+    async def list_models(self) -> dict[str, Any]:
+        """Return daemon ``models_list_response`` (models + default_model from server config)."""
+        async with self._read_lock:
+            return await self._client.list_models(timeout=15.0)
+
+    async def invoke_skill(self, skill: str, args: str = "") -> dict[str, Any]:
+        """Resolve ``SKILL.md`` on the daemon and receive UI echo before the turn streams."""
+        async with self._read_lock:
+            return await self._client.invoke_skill(skill, args, timeout=120.0)

soothe_cli/tui/file_ops.py

@@ -0,0 +1,409 @@
+"""Helpers for tracking file operations and computing diffs for CLI display."""
+
+from __future__ import annotations
+
+import difflib
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal
+
+logger = logging.getLogger(__name__)
+
+FileOpStatus = Literal["pending", "success", "error"]
+
+
+@dataclass
+class ApprovalPreview:
+    """Data used to render HITL previews."""
+
+    title: str
+    details: list[str]
+    diff: str | None = None
+    diff_title: str | None = None
+    error: str | None = None
+
+
+def _safe_read(path: Path) -> str | None:
+    """Read file content, returning None on failure.
+
+    Returns:
+        File content as string, or None if reading fails.
+    """
+    try:
+        return path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError) as e:
+        logger.debug("Failed to read file %s: %s", path, e)
+        return None
+
+
+def _count_lines(text: str) -> int:
+    """Count lines in text, treating empty strings as zero lines.
+
+    Returns:
+        Number of lines in the text.
+    """
+    if not text:
+        return 0
+    return len(text.splitlines())
+
+
+def compute_unified_diff(
+    before: str,
+    after: str,
+    display_path: str,
+    *,
+    max_lines: int | None = 800,
+    context_lines: int = 3,
+) -> str | None:
+    """Compute a unified diff between before and after content.
+
+    Args:
+        before: Original content
+        after: New content
+        display_path: Path for display in diff headers
+        max_lines: Maximum number of diff lines (None for unlimited)
+        context_lines: Number of context lines around changes (default 3)
+
+    Returns:
+        Unified diff string or None if no changes
+    """
+    before_lines = before.splitlines()
+    after_lines = after.splitlines()
+    diff_lines = list(
+        difflib.unified_diff(
+            before_lines,
+            after_lines,
+            fromfile=f"{display_path} (before)",
+            tofile=f"{display_path} (after)",
+            lineterm="",
+            n=context_lines,
+        )
+    )
+    if not diff_lines:
+        return None
+    if max_lines is not None and len(diff_lines) > max_lines:
+        truncated = diff_lines[: max_lines - 1]
+        truncated.append("...")
+        return "\n".join(truncated)
+    return "\n".join(diff_lines)
+
+
+@dataclass
+class FileOpMetrics:
+    """Line and byte level metrics for a file operation."""
+
+    lines_read: int = 0
+    start_line: int | None = None
+    end_line: int | None = None
+    lines_written: int = 0
+    lines_added: int = 0
+    lines_removed: int = 0
+    bytes_written: int = 0
+
+
+@dataclass
+class FileOperationRecord:
+    """Track a single filesystem tool call."""
+
+    tool_name: str
+    display_path: str
+    physical_path: Path | None
+    tool_call_id: str | None
+    args: dict[str, Any] = field(default_factory=dict)
+    status: FileOpStatus = "pending"
+    error: str | None = None
+    metrics: FileOpMetrics = field(default_factory=FileOpMetrics)
+    diff: str | None = None
+    before_content: str | None = None
+    after_content: str | None = None
+    read_output: str | None = None
+    hitl_approved: bool = False
+
+
+def resolve_physical_path(path_str: str | None, assistant_id: str | None) -> Path | None:
+    """Convert a virtual/relative path to a physical filesystem path.
+
+    Returns:
+        Resolved physical Path, or None if path is empty or resolution fails.
+    """
+    if not path_str:
+        return None
+    try:
+        if assistant_id and path_str.startswith("/memories/"):
+            from soothe_cli.tui.config import settings
+
+            agent_dir = settings.get_agent_dir(assistant_id)
+            suffix = path_str.removeprefix("/memories/").lstrip("/")
+            return (agent_dir / suffix).resolve()
+        path = Path(path_str)
+        if path.is_absolute():
+            return path
+        return (Path.cwd() / path).resolve()
+    except (OSError, ValueError):
+        return None
+
+
+def format_display_path(path_str: str | None) -> str:
+    """Format a path for display.
+
+    Returns:
+        Formatted path string suitable for display.
+    """
+    if not path_str:
+        return "(unknown)"
+    try:
+        path = Path(path_str)
+        if path.is_absolute():
+            return path.name or str(path)
+        return str(path)
+    except (OSError, ValueError):
+        return str(path_str)
+
+
+def build_approval_preview(
+    tool_name: str,
+    args: dict[str, Any],
+    assistant_id: str | None,
+) -> ApprovalPreview | None:
+    """Collect summary info and diff for HITL approvals.
+
+    Returns:
+        ApprovalPreview with diff and details, or None if tool not supported.
+    """
+    path_str = str(args.get("file_path") or args.get("path") or "")
+    display_path = format_display_path(path_str)
+    physical_path = resolve_physical_path(path_str, assistant_id)
+
+    if tool_name == "write_file":
+        content = str(args.get("content", ""))
+        before = _safe_read(physical_path) if physical_path and physical_path.exists() else ""
+        after = content
+        diff = compute_unified_diff(before or "", after, display_path, max_lines=100)
+        additions = 0
+        if diff:
+            additions = sum(
+                1
+                for line in diff.splitlines()
+                if line.startswith("+") and not line.startswith("+++")
+            )
+        total_lines = _count_lines(after)
+        details = [
+            f"File: {path_str}",
+            "Action: Create new file" + (" (overwrites existing content)" if before else ""),
+            f"Lines to write: {additions or total_lines}",
+        ]
+        return ApprovalPreview(
+            title=f"Write {display_path}",
+            details=details,
+            diff=diff,
+            diff_title=f"Diff {display_path}",
+        )
+
+    if tool_name == "edit_file":
+        if physical_path is None:
+            return ApprovalPreview(
+                title=f"Update {display_path}",
+                details=[f"File: {path_str}", "Action: Replace text"],
+                error="Unable to resolve file path.",
+            )
+        before = _safe_read(physical_path)
+        if before is None:
+            return ApprovalPreview(
+                title=f"Update {display_path}",
+                details=[f"File: {path_str}", "Action: Replace text"],
+                error="Unable to read current file contents.",
+            )
+        old_string = str(args.get("old_string", ""))
+        new_string = str(args.get("new_string", ""))
+        replace_all = bool(args.get("replace_all"))
+
+        # Preview string replacement locally
+        if replace_all:
+            after = before.replace(old_string, new_string)
+        else:
+            after = before.replace(old_string, new_string, 1)
+
+        diff = compute_unified_diff(before, after, display_path, max_lines=100)
+        additions = 0
+        deletions = 0
+        if diff:
+            additions = sum(
+                1
+                for line in diff.splitlines()
+                if line.startswith("+") and not line.startswith("+++")
+            )
+            deletions = sum(
+                1
+                for line in diff.splitlines()
+                if line.startswith("-") and not line.startswith("---")
+            )
+        scope = "all occurrences" if replace_all else "first occurrence"
+        details = [
+            f"File: {path_str}",
+            f"Action: Replace text ({scope})",
+            f"+{additions} / -{deletions} lines",
+        ]
+        return ApprovalPreview(
+            title=f"Update {display_path}",
+            details=details,
+            diff=diff,
+            diff_title=f"Diff {display_path}",
+        )
+
+    return None
+
+
+class FileOpTracker:
+    """Collect file operation metrics during a CLI interaction."""
+
+    def __init__(self, *, assistant_id: str | None) -> None:
+        """Initialize the tracker."""
+        self.assistant_id = assistant_id
+        self.active: dict[str | None, FileOperationRecord] = {}
+        self.completed: list[FileOperationRecord] = []
+
+    def start_operation(
+        self, tool_name: str, args: dict[str, Any], tool_call_id: str | None
+    ) -> None:
+        """Begin tracking a file operation.
+
+        Creates a record for the operation and, for write/edit operations,
+        captures the file's content before modification.
+        """
+        if tool_name not in {"read_file", "write_file", "edit_file"}:
+            return
+        path_str = str(args.get("file_path") or args.get("path") or "")
+        display_path = format_display_path(path_str)
+        record = FileOperationRecord(
+            tool_name=tool_name,
+            display_path=display_path,
+            physical_path=resolve_physical_path(path_str, self.assistant_id),
+            tool_call_id=tool_call_id,
+            args=args,
+        )
+        if tool_name in {"write_file", "edit_file"}:
+            if record.physical_path:
+                record.before_content = _safe_read(record.physical_path) or ""
+        self.active[tool_call_id] = record
+
+    def complete_with_message(self, tool_message: Any) -> FileOperationRecord | None:  # noqa: ANN401  # Tool message type is dynamic
+        """Complete a file operation with the tool message result.
+
+        Returns:
+            The completed FileOperationRecord, or None if no matching operation.
+        """
+        tool_call_id = getattr(tool_message, "tool_call_id", None)
+        record = self.active.get(tool_call_id)
+        if record is None:
+            return None
+
+        content = tool_message.content
+        if isinstance(content, list):
+            # Some tool messages may return list segments; join them for analysis.
+            joined = []
+            for item in content:
+                if isinstance(item, str):
+                    joined.append(item)
+                else:
+                    joined.append(str(item))
+            content_text = "\n".join(joined)
+        else:
+            content_text = str(content) if content is not None else ""
+
+        if getattr(
+            tool_message, "status", "success"
+        ) != "success" or content_text.lower().startswith("error"):
+            record.status = "error"
+            record.error = content_text
+            self._finalize(record)
+            return record
+
+        record.status = "success"
+
+        if record.tool_name == "read_file":
+            record.read_output = content_text
+            lines = _count_lines(content_text)
+            record.metrics.lines_read = lines
+            offset = record.args.get("offset")
+            limit = record.args.get("limit")
+            if isinstance(offset, int):
+                if offset > lines:
+                    offset = 0
+                record.metrics.start_line = offset + 1
+                if lines:
+                    record.metrics.end_line = offset + lines
+            elif lines:
+                record.metrics.start_line = 1
+                record.metrics.end_line = lines
+            if isinstance(limit, int) and lines > limit:
+                record.metrics.end_line = (record.metrics.start_line or 1) + limit - 1
+        else:
+            # For write/edit operations, read back from local filesystem
+            self._populate_after_content(record)
+            if record.after_content is None:
+                record.status = "error"
+                record.error = "Could not read updated file content."
+                self._finalize(record)
+                return record
+            record.metrics.lines_written = _count_lines(record.after_content)
+            before_lines = _count_lines(record.before_content or "")
+            diff = compute_unified_diff(
+                record.before_content or "",
+                record.after_content,
+                record.display_path,
+                max_lines=100,
+            )
+            record.diff = diff
+            if diff:
+                additions = sum(
+                    1
+                    for line in diff.splitlines()
+                    if line.startswith("+") and not line.startswith("+++")
+                )
+                deletions = sum(
+                    1
+                    for line in diff.splitlines()
+                    if line.startswith("-") and not line.startswith("---")
+                )
+                record.metrics.lines_added = additions
+                record.metrics.lines_removed = deletions
+            elif record.tool_name == "write_file" and not (record.before_content or ""):
+                record.metrics.lines_added = record.metrics.lines_written
+            record.metrics.bytes_written = len(record.after_content.encode("utf-8"))
+            if record.diff is None and (record.before_content or "") != record.after_content:
+                record.diff = compute_unified_diff(
+                    record.before_content or "",
+                    record.after_content,
+                    record.display_path,
+                    max_lines=100,
+                )
+            if record.diff is None and before_lines != record.metrics.lines_written:
+                record.metrics.lines_added = max(record.metrics.lines_written - before_lines, 0)
+
+        self._finalize(record)
+        return record
+
+    def mark_hitl_approved(self, tool_name: str, args: dict[str, Any]) -> None:
+        """Mark operations matching tool_name and file_path as HIL-approved."""
+        file_path = args.get("file_path") or args.get("path")
+        if not file_path:
+            return
+
+        # Mark all active records that match
+        for record in self.active.values():
+            if record.tool_name == tool_name:
+                record_path = record.args.get("file_path") or record.args.get("path")
+                if record_path == file_path:
+                    record.hitl_approved = True
+
+    def _populate_after_content(self, record: FileOperationRecord) -> None:
+        """Read the file content after the operation for diff computation."""
+        if record.physical_path is None:
+            record.after_content = None
+            return
+        record.after_content = _safe_read(record.physical_path)
+
+    def _finalize(self, record: FileOperationRecord) -> None:
+        self.completed.append(record)
+        self.active.pop(record.tool_call_id, None)

soothe_cli/tui/formatting.py

@@ -0,0 +1,28 @@
+"""Lightweight text-formatting helpers.
+
+Keep this module free of heavy dependencies so it can be imported anywhere
+in the CLI without pulling in large frameworks.
+"""
+
+from __future__ import annotations
+
+
+def format_duration(seconds: float) -> str:
+    """Format a duration in seconds into a human-readable string.
+
+    Args:
+        seconds: Duration in seconds.
+
+    Returns:
+        Formatted string like `"5s"`, `"2.3s"`, `"5m 12s"`, or `"1h 23m 4s"`.
+    """
+    rounded = round(seconds, 1)
+    if rounded < 60:  # noqa: PLR2004
+        if rounded % 1 == 0:
+            return f"{int(rounded)}s"
+        return f"{rounded:.1f}s"
+    minutes, secs = divmod(int(rounded), 60)
+    if minutes < 60:  # noqa: PLR2004
+        return f"{minutes}m {secs}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h {minutes}m {secs}s"

soothe_cli/tui/hooks.py

@@ -0,0 +1,23 @@
+"""Hook system for TUI events (stub implementation from deepagents-cli migration).
+
+This module provides hook dispatch functionality for TUI events.
+Full implementation should integrate with Soothe's event system.
+"""
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+async def dispatch_hook(hook_name: str, payload: dict[str, Any]) -> None:
+    """Dispatch a hook event asynchronously.
+
+    Stub implementation - no hooks are currently registered.
+    Full implementation should integrate with Soothe's event system.
+
+    Args:
+        hook_name: Name of the hook event (e.g., "user.prompt", "session.end").
+        payload: Event payload data.
+    """
+    logger.debug("Hook dispatch (stub): %s with payload %s", hook_name, payload)