soothe-cli 0.7.11__tar.gz → 0.7.13__tar.gz

{soothe_cli-0.7.11 → soothe_cli-0.7.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.11
+Version: 0.7.13
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io

soothe_cli-0.7.13/src/soothe_cli/__init__.py

@@ -0,0 +1,5 @@
+"""Soothe CLI client - communicates with daemon via WebSocket."""
+
+from soothe_cli.tui._version import __version__
+
+__all__ = ["__version__"]

{soothe_cli-0.7.11 → soothe_cli-0.7.13}/src/soothe_cli/cli/main.py

@@ -6,7 +6,6 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-from importlib.metadata import version  # noqa: E402
 from pathlib import Path  # noqa: E402
 from typing import Annotated  # noqa: E402
 
@@ -15,6 +14,7 @@ from soothe_sdk.client.config import SOOTHE_HOME  # noqa: E402
 
 from soothe_cli.config.cli_config import CLIConfig  # noqa: E402
 from soothe_cli.config.loader import set_runtime_config  # noqa: E402
+from soothe_cli.tui._version import __version__  # noqa: E402
 from soothe_cli.tui.markdown_theme import (  # noqa: E402
     DEFAULT_MARKDOWN_THEME,
     REGISTRY,
@@ -177,7 +177,7 @@ def main(
 
     # Handle --version flag
     if show_version:
-        typer.echo(f"soothe {version('soothe-cli')}")
+        typer.echo(f"soothe {__version__}")
         raise typer.Exit
 
     home_path = Path(soothe_home).expanduser() if soothe_home else Path(SOOTHE_HOME)

{soothe_cli-0.7.11 → soothe_cli-0.7.13}/src/soothe_cli/runtime/presentation/duration_format.py

@@ -4,13 +4,15 @@ from __future__ import annotations
 
 
 def format_duration(seconds: float) -> str:
-    """Format a duration in seconds into a human-readable string.
+    """Format a completed 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"`.
+        Formatted string like ``5s``, ``2.3s``, ``5m 12s``, or ``1h 23m 4s``.
+        For live running timers that tick in whole seconds, use
+        :func:`format_running_elapsed` instead.
     """
     rounded = round(seconds, 1)
     if rounded < 60:  # noqa: PLR2004
@@ -24,6 +26,11 @@ def format_duration(seconds: float) -> str:
     return f"{hours}h {minutes}m {secs}s"
 
 
+def format_running_elapsed(seconds: float) -> str:
+    """Format a live running timer using whole-second ticks (e.g. ``20s``, ``1m 5s``)."""
+    return format_duration(float(max(0, int(seconds))))
+
+
 def format_duration_ms(milliseconds: int) -> str:
     """Format a wall-clock duration in milliseconds for status lines and cards.
 

soothe_cli-0.7.13/src/soothe_cli/runtime/token_events_debug.py

@@ -0,0 +1,180 @@
+"""Debug tracing for loop token events in the CLI TUI.
+
+Enable with ``logging_level: DEBUG`` in CLI config (``~/.soothe/config.yml``)
+or ``SOOTHE_LOG_LEVEL=DEBUG``. Grep ``cli.log`` for ``[token-events]``.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+
+logger = logging.getLogger("soothe_cli.token_events")
+
+
+@dataclass
+class TokenEventTrace:
+    """Per-turn counters for token-related daemon/TUI events."""
+
+    stream_chunks: int = 0
+    stream_input_tokens: int = 0
+    stream_output_tokens: int = 0
+    plan_phase_events: int = 0
+    plan_phase_with_total_field: int = 0
+    plan_phase_missing_total_field: int = 0
+    step_completed_events: int = 0
+    step_completed_with_total_field: int = 0
+    authoritative_applied: int = 0
+    authoritative_unchanged: int = 0
+    display_refreshes: int = 0
+    anomalies: list[str] = field(default_factory=list)
+
+    def reset(self) -> None:
+        """Clear counters for a new turn."""
+        self.stream_chunks = 0
+        self.stream_input_tokens = 0
+        self.stream_output_tokens = 0
+        self.plan_phase_events = 0
+        self.plan_phase_with_total_field = 0
+        self.plan_phase_missing_total_field = 0
+        self.step_completed_events = 0
+        self.step_completed_with_total_field = 0
+        self.authoritative_applied = 0
+        self.authoritative_unchanged = 0
+        self.display_refreshes = 0
+        self.anomalies.clear()
+
+    def note_stream_usage(
+        self, *, input_tokens: int, output_tokens: int, total_tokens: int
+    ) -> None:
+        """Record a messages-stream chunk carrying provider usage."""
+        self.stream_chunks += 1
+        self.stream_input_tokens += max(0, input_tokens)
+        self.stream_output_tokens += max(0, output_tokens)
+        logger.debug(
+            "[token-events] stream usage chunk #%d in=%d out=%d total=%d",
+            self.stream_chunks,
+            input_tokens,
+            output_tokens,
+            total_tokens,
+        )
+
+    def note_plan_phase(
+        self, *, label: str, total_tokens_used: int | None, has_total_field: bool
+    ) -> None:
+        """Record a StrangeLoop plan-phase lifecycle event."""
+        self.plan_phase_events += 1
+        if has_total_field:
+            self.plan_phase_with_total_field += 1
+        else:
+            self.plan_phase_missing_total_field += 1
+            self.anomalies.append(f"plan_phase missing total_tokens_used ({label!r})")
+        logger.debug(
+            "[token-events] plan_phase label=%r total=%s has_total_field=%s",
+            label,
+            total_tokens_used if has_total_field else "—",
+            has_total_field,
+        )
+
+    def note_step_completed(
+        self, *, step_id: str, total_tokens_used: int | None, has_total_field: bool
+    ) -> None:
+        """Record step.completed with optional backend loop total."""
+        self.step_completed_events += 1
+        if has_total_field:
+            self.step_completed_with_total_field += 1
+        logger.debug(
+            "[token-events] step_completed step_id=%s total=%s has_total_field=%s",
+            step_id or "—",
+            total_tokens_used if has_total_field else "—",
+            has_total_field,
+        )
+
+    def note_authoritative_merge(
+        self,
+        *,
+        source: str,
+        goal_run_total: int,
+        previous_goal_run: int,
+        applied: bool,
+        display_total: int,
+    ) -> None:
+        """Record backend total merged into the TUI loop counter."""
+        if applied:
+            self.authoritative_applied += 1
+        else:
+            self.authoritative_unchanged += 1
+        logger.debug(
+            "[token-events] authoritative source=%s goal_run=%d prev_goal_run=%d applied=%s display=%d",
+            source,
+            goal_run_total,
+            previous_goal_run,
+            applied,
+            display_total,
+        )
+
+    def note_display_refresh(self, *, display_total: int, target: str) -> None:
+        """Record a push to the thinking row or status bar."""
+        self.display_refreshes += 1
+        logger.debug(
+            "[token-events] display refresh target=%s total=%d refresh#%d",
+            target,
+            display_total,
+            self.display_refreshes,
+        )
+
+    def finish_turn(
+        self,
+        *,
+        loop_id: str | None,
+        baseline: int,
+        goal_run: int,
+        display_total: int,
+        turn_input: int,
+        turn_output: int,
+        approximate: bool,
+    ) -> None:
+        """Emit one summary line per turn; flags missing events."""
+        has_stream = self.stream_chunks > 0
+        has_backend_total = (
+            self.plan_phase_with_total_field > 0 or self.step_completed_with_total_field > 0
+        )
+        has_any_usage = display_total > 0 or turn_input > 0 or turn_output > 0
+
+        if has_any_usage and not has_stream and not has_backend_total:
+            self.anomalies.append("usage visible but no stream or backend total events")
+        if self.plan_phase_events > 0 and self.plan_phase_missing_total_field > 0:
+            self.anomalies.append(
+                f"{self.plan_phase_missing_total_field}/{self.plan_phase_events} plan_phase "
+                "events lacked total_tokens_used"
+            )
+        if not has_any_usage and (self.plan_phase_events or self.step_completed_events):
+            self.anomalies.append("lifecycle events seen but display total still zero")
+
+        status = "ok"
+        if self.anomalies:
+            status = "anomaly"
+        elif not has_stream and not has_backend_total and not has_any_usage:
+            status = "no_events"
+
+        logger.debug(
+            "[token-events] turn summary loop=%s status=%s baseline=%d goal_run=%d "
+            "display=%d turn_in=%d turn_out=%d stream_chunks=%d plan_phase=%d "
+            "step_completed=%d authoritative_applied=%d approximate=%s anomalies=%s",
+            loop_id or "—",
+            status,
+            baseline,
+            goal_run,
+            display_total,
+            turn_input,
+            turn_output,
+            self.stream_chunks,
+            self.plan_phase_events,
+            self.step_completed_events,
+            self.authoritative_applied,
+            approximate,
+            "; ".join(self.anomalies) if self.anomalies else "none",
+        )
+
+
+__all__ = ["TokenEventTrace", "logger"]

soothe_cli-0.7.13/src/soothe_cli/runtime/token_usage.py

@@ -0,0 +1,113 @@
+"""Token usage extraction and estimation helpers for the TUI."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+__all__ = [
+    "extract_stream_message_token_usage",
+    "fetch_conversation_token_count",
+    "message_has_token_usage_metadata",
+]
+
+
+def _coerce_int(value: Any) -> int:
+    try:
+        return max(0, int(value or 0))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _usage_from_mapping(usage: dict[str, Any]) -> tuple[int, int, int]:
+    """Return ``(input_tokens, output_tokens, total_tokens)`` from a usage dict."""
+    input_toks = _coerce_int(usage.get("input_tokens") or usage.get("prompt_tokens"))
+    output_toks = _coerce_int(usage.get("output_tokens") or usage.get("completion_tokens"))
+    total_toks = _coerce_int(usage.get("total_tokens"))
+    if not total_toks and (input_toks or output_toks):
+        total_toks = input_toks + output_toks
+    return input_toks, output_toks, total_toks
+
+
+def extract_stream_message_token_usage(message: Any) -> tuple[int, int, int]:
+    """Extract token usage from a streamed LangChain or wire-format message.
+
+    Providers vary:
+    - LangChain ``usage_metadata`` (``input_tokens`` / ``output_tokens``)
+    - OpenAI-style ``response_metadata.token_usage`` (``prompt_tokens`` / ``completion_tokens``)
+    - Flat wire dicts with either shape
+    """
+    if message is None:
+        return 0, 0, 0
+
+    usage = getattr(message, "usage_metadata", None)
+    if isinstance(usage, dict) and usage:
+        return _usage_from_mapping(usage)
+
+    response_metadata = getattr(message, "response_metadata", None)
+    if isinstance(response_metadata, dict):
+        for key in ("token_usage", "usage"):
+            nested = response_metadata.get(key)
+            if isinstance(nested, dict) and nested:
+                return _usage_from_mapping(nested)
+
+    if isinstance(message, dict):
+        from soothe_cli.runtime.wire.message_text import wire_message_body
+
+        bodies = [message]
+        nested = wire_message_body(message)
+        if nested is not message:
+            bodies.append(nested)
+        for body in bodies:
+            if not isinstance(body, dict):
+                continue
+            direct_usage = body.get("usage_metadata")
+            if isinstance(direct_usage, dict) and direct_usage:
+                return _usage_from_mapping(direct_usage)
+            response = body.get("response_metadata")
+            if isinstance(response, dict):
+                for key in ("token_usage", "usage"):
+                    nested_usage = response.get(key)
+                    if isinstance(nested_usage, dict) and nested_usage:
+                        return _usage_from_mapping(nested_usage)
+
+    return 0, 0, 0
+
+
+def message_has_token_usage_metadata(message: Any) -> bool:
+    """Return True when a stream message carries provider token usage."""
+    input_toks, output_toks, total_toks = extract_stream_message_token_usage(message)
+    return bool(input_toks or output_toks or total_toks)
+
+
+async def fetch_conversation_token_count(daemon_session: Any, loop_id: str | None) -> int | None:
+    """Return approximate conversation-only token count from loop checkpoint messages."""
+    raw_loop_id = str(loop_id or "").strip()
+    if not raw_loop_id or daemon_session is None:
+        return None
+    try:
+        from langchain_core.messages import messages_from_dict
+        from langchain_core.messages.utils import count_tokens_approximately
+
+        snap = await daemon_session.aget_loop_state(raw_loop_id)
+        vals = getattr(snap, "values", None)
+        if not isinstance(vals, dict):
+            return None
+        raw = vals.get("messages")
+        if not isinstance(raw, list) or not raw:
+            return None
+        if isinstance(raw[0], dict):
+            messages = messages_from_dict(raw)
+        else:
+            messages = raw
+        count = count_tokens_approximately(messages)
+        return count if count > 0 else None
+    except Exception:
+        logger.debug(
+            "Failed to retrieve conversation token count for loop %s",
+            raw_loop_id,
+            exc_info=True,
+        )
+        return None

{soothe_cli-0.7.11 → soothe_cli-0.7.13}/src/soothe_cli/runtime/wire/chunk_filter.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
+from soothe_cli.runtime.token_usage import message_has_token_usage_metadata
 from soothe_cli.runtime.wire.message_text import (
     extract_plain_text_from_stream_message,
     wire_message_body,
@@ -73,6 +74,8 @@ def message_chunk_is_non_actionable(data: Any) -> bool:
 
     if isinstance(msg, ToolMessage):
         return False
+    if message_has_token_usage_metadata(msg):
+        return False
     if isinstance(msg, dict):
         body = wire_message_body(msg)
         raw = str(body.get("type") or msg.get("type") or "")

soothe_cli-0.7.13/src/soothe_cli/tui/_version.py

@@ -0,0 +1,128 @@
+"""Version information and lightweight constants for `soothe`."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from importlib.metadata import PackageNotFoundError, distribution, version
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+logger = logging.getLogger(__name__)
+
+_VERSION_PATTERN = re.compile(r"^(\d+\.\d+\.\d+)")
+
+
+def _parse_version_file_text(text: str) -> str | None:
+    """Extract the semver from a repo ``VERSION`` file."""
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        match = _VERSION_PATTERN.match(stripped)
+        if match:
+            return match.group(1)
+    return None
+
+
+def _editable_source_roots() -> list[Path]:
+    """Return resolved source roots for editable Soothe packages."""
+    roots: list[Path] = []
+    seen: set[Path] = set()
+    for dist_name in ("soothe-cli", "soothe", "Soothe"):
+        try:
+            dist = distribution(dist_name)
+        except PackageNotFoundError:
+            continue
+        try:
+            raw = dist.read_text("direct_url.json")
+        except (FileNotFoundError, OSError):
+            continue
+        if not raw:
+            continue
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError:
+            logger.debug("Invalid direct_url.json for %s", dist_name, exc_info=True)
+            continue
+        if not data.get("dir_info", {}).get("editable"):
+            continue
+        url = data.get("url", "")
+        if not url.startswith("file://"):
+            continue
+        root = Path(unquote(urlparse(url).path)).resolve()
+        if root not in seen:
+            seen.add(root)
+            roots.append(root)
+    return roots
+
+
+def _read_repo_version_from_source(root: Path) -> str | None:
+    """Read the monorepo ``VERSION`` file for an editable install root."""
+    candidates = [root.parent.parent / "VERSION", *(parent / "VERSION" for parent in root.parents)]
+    for path in candidates:
+        if not path.is_file():
+            continue
+        try:
+            parsed = _parse_version_file_text(path.read_text(encoding="utf-8"))
+        except OSError:
+            logger.debug("Failed to read VERSION file at %s", path, exc_info=True)
+            continue
+        if parsed:
+            return parsed
+    return None
+
+
+def _resolve_version() -> str:
+    """Resolve the CLI version, preferring repo ``VERSION`` for editable installs."""
+    for root in _editable_source_roots():
+        repo_version = _read_repo_version_from_source(root)
+        if repo_version:
+            return repo_version
+
+    for pkg in ("soothe-cli", "soothe"):
+        try:
+            return version(pkg)
+        except PackageNotFoundError:
+            continue
+    return "0.0.0"
+
+
+def is_editable_install() -> bool:
+    """Return whether Soothe is installed in editable mode."""
+    return bool(_editable_source_roots())
+
+
+def editable_install_display_path() -> str | None:
+    """Return a ``~``-contracted source path for editable installs."""
+    roots = _editable_source_roots()
+    if not roots:
+        return None
+
+    install_root = roots[0]
+    for root in roots:
+        if root.name == "soothe-cli":
+            install_root = root
+            break
+
+    path = str(install_root)
+    home = str(Path.home())
+    if path.startswith(home):
+        return "~" + path[len(home) :]
+    return path
+
+
+__version__ = _resolve_version()
+
+DOCS_URL = "https://github.com/mirasoth/soothe/docs"
+"""URL for Soothe documentation."""
+
+PYPI_URL = "https://pypi.org/pypi/soothe/json"
+"""PyPI JSON API endpoint for version checks."""
+
+CHANGELOG_URL = "https://github.com/mirasoth/soothe/blob/main/CHANGELOG.md"
+"""URL for the full changelog."""
+
+USER_AGENT = f"soothe/{__version__} update-check"
+"""User-Agent header sent with PyPI requests."""

{soothe_cli-0.7.11 → soothe_cli-0.7.13}/src/soothe_cli/tui/app/_app.py

@@ -253,12 +253,17 @@ class SootheApp(
         self._connect_spinner_start_mono: float | None = None
         """Monotonic anchor for startup daemon-connect elapsed time in the thinking row."""
 
-        self._context_tokens: int = 0
-        """Local cache of the last total-context token count.
+        self._loop_token_scope_id: str | None = None
+        """Loop id that ``_loop_*_tokens`` counters belong to."""
 
-        Source of truth is `_context_tokens` in graph state; this is a sync
-        copy for the status bar.
-        """
+        self._loop_baseline_tokens: int = 0
+        """Persisted loop usage total loaded from checkpoint (resume baseline)."""
+
+        self._loop_input_tokens: int = 0
+        """Input tokens for the in-flight goal/turn (stream or backend)."""
+
+        self._loop_output_tokens: int = 0
+        """Output tokens for the in-flight goal/turn (stream or backend)."""
 
         self._tokens_approximate: bool = False
         """Whether the cached token count is stale (interrupted generation)."""