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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.11
+Version: 0.7.12
 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.12/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.12}/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.12}/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.12/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.12}/src/soothe_cli/tui/app/_execution.py

@@ -533,36 +533,9 @@ class _ExecutionMixin:
             await self._open_url_command(command, cmd)
         elif cmd == "/version":
             await self._mount_message(UserMessage(command))
-            # Show CLI and SDK package versions
-            try:
-                from soothe_cli.tui._version import (
-                    __version__ as cli_version,
-                )
-
-                cli_line = f"Soothe version: {cli_version}"
-            except ImportError:
-                logger.debug("soothe._version module not found")
-                cli_line = "Soothe version: unknown"
-            except Exception:
-                logger.warning("Unexpected error looking up CLI version", exc_info=True)
-                cli_line = "Soothe version: unknown"
-            try:
-                from importlib.metadata import (
-                    PackageNotFoundError,
-                )
-                from importlib.metadata import (
-                    version as _pkg_version,
-                )
+            from soothe_cli.tui._version import __version__ as cli_version
 
-                sdk_version = _pkg_version("Soothe")
-                sdk_line = f"Soothe (SDK) version: {sdk_version}"
-            except PackageNotFoundError:
-                logger.debug("Soothe SDK package not found in environment")
-                sdk_line = "Soothe (SDK) version: unknown"
-            except Exception:
-                logger.warning("Unexpected error looking up SDK version", exc_info=True)
-                sdk_line = "Soothe (SDK) version: unknown"
-            await self._mount_message(AppMessage(f"{cli_line}\n{sdk_line}"))
+            await self._mount_message(AppMessage(f"Soothe version: {cli_version}"))
         elif cmd == "/clear":
             self._pending_messages.clear()
             self._queued_widgets.clear()

{soothe_cli-0.7.11 → soothe_cli-0.7.12}/src/soothe_cli/tui/app/_startup.py

@@ -119,6 +119,9 @@ class _StartupMixin:
         gc.freeze()
 
         chat = self.query_one("#chat", VerticalScroll)
+        # Transcript scrolling is mouse-driven; keeping the region unfocusable
+        # prevents clicks in the message area from stealing the chat prompt caret.
+        chat.can_focus = False
         chat.anchor()
 
         self._status_bar = self.query_one("#status-bar", StatusBar)

{soothe_cli-0.7.11 → soothe_cli-0.7.12}/src/soothe_cli/tui/config.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import importlib
-import json
 import logging
 import os
 import re
@@ -11,14 +10,19 @@ import sys
 import threading
 from dataclasses import dataclass
 from enum import StrEnum
-from importlib.metadata import PackageNotFoundError, distribution
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
-from urllib.parse import unquote, urlparse
 
 from soothe_sdk.client.config import SOOTHE_HOME
 
-from soothe_cli.tui._version import __version__
+from soothe_cli.tui._version import (
+    __version__,
+)
+from soothe_cli.tui._version import (
+    is_editable_install as _is_editable_install,
+)
+
+__all__ = ["_is_editable_install"]
 
 logger = logging.getLogger(__name__)
 
@@ -330,67 +334,6 @@ ASCII_GLYPHS = Glyphs(
 _glyphs_cache: Glyphs | None = None
 """Module-level cache for detected glyphs."""
 
-_editable_cache: tuple[bool, str | None] | None = None
-"""Module-level cache for editable install info: (is_editable, source_path)."""
-
-
-def _resolve_editable_info() -> tuple[bool, str | None]:
-    """Parse PEP 610 `direct_url.json` once and cache both results.
-
-    Returns:
-        Tuple of (is_editable, contracted_source_path). The path is
-        `~`-contracted when it falls under the user's home directory, or
-        `None` when the install is non-editable or the path is unavailable.
-    """
-    global _editable_cache  # noqa: PLW0603  # Module-level cache requires global statement
-    if _editable_cache is not None:
-        return _editable_cache
-
-    editable = False
-    path: str | None = None
-
-    try:
-        dist = distribution("Soothe")
-        raw = dist.read_text("direct_url.json")
-        if raw:
-            data = json.loads(raw)
-            editable = data.get("dir_info", {}).get("editable", False)
-            if editable:
-                url = data.get("url", "")
-                if url.startswith("file://"):
-                    path = unquote(urlparse(url).path)
-                    home = str(Path.home())
-                    if path.startswith(home):
-                        path = "~" + path[len(home) :]
-    except (PackageNotFoundError, FileNotFoundError, json.JSONDecodeError, TypeError):
-        logger.debug(
-            "Failed to read editable install info from PEP 610 metadata",
-            exc_info=True,
-        )
-
-    _editable_cache = (editable, path)
-    return _editable_cache
-
-
-def _is_editable_install() -> bool:
-    """Check if Soothe is installed in editable mode.
-
-    Uses PEP 610 `direct_url.json` metadata to detect editable installs.
-
-    Returns:
-        `True` if installed in editable mode, `False` otherwise.
-    """
-    return _resolve_editable_info()[0]
-
-
-def _get_editable_install_path() -> str | None:
-    """Return the `~`-contracted source directory for an editable install.
-
-    Returns `None` for non-editable installs or when the path cannot be
-    determined.
-    """
-    return _resolve_editable_info()[1]
-
 
 def _detect_charset_mode() -> CharsetMode:
     """Auto-detect terminal charset capabilities.
@@ -544,19 +487,10 @@ def build_stream_config(
 ) -> RunnableConfig:
     """Build the LangGraph stream config dict.
 
-    Injects CLI and SDK versions into `metadata["versions"]` so runs can be
-    correlated with specific releases.
-
-    Why the CLI sets *both* versions:
-
-    * `create_deep_agent` bakes `versions: {"Soothe": "X.Y.Z"}` into the
-        compiled graph via `with_config`. At stream time, LangGraph merges
-        the graph config with the runtime config passed here. Because the
-        metadata merge is shallow (effectively `{**graph_meta, **runtime_meta}`
-        for top-level keys), both configs containing a `versions` key means
-        the runtime dict **replaces** the graph dict entirely — the SDK
-        version would be lost.
-    * Including the SDK version here ensures it survives the merge.
+    Injects the resolved Soothe version into ``metadata["versions"]`` so runs
+    can be correlated with specific releases. The runtime config replaces the
+    graph config's ``versions`` key at stream time, so this must carry the
+    canonical release string.
 
     Args:
         loop_id: Active StrangeLoop id (stored under LangGraph ``configurable.thread_id``).
@@ -571,8 +505,6 @@ def build_stream_config(
     Returns:
         Config dict with `configurable` and `metadata` keys.
     """
-    import contextlib
-    import importlib.metadata as importlib_metadata
     from datetime import UTC, datetime
 
     try:
@@ -581,13 +513,8 @@ def build_stream_config(
         logger.warning("Could not determine working directory", exc_info=True)
         cwd = ""
 
-    # Include SDK version alongside CLI version — see docstring for why.
-    versions: dict[str, str] = {"Soothe": __version__}
-    with contextlib.suppress(importlib_metadata.PackageNotFoundError):
-        versions["Soothe"] = importlib_metadata.version("Soothe")
-
     metadata: dict[str, Any] = {
-        "versions": versions,
+        "versions": {"Soothe": __version__},
     }
     from soothe_cli.tui._env_vars import USER_ID
 

{soothe_cli-0.7.11 → soothe_cli-0.7.12}/src/soothe_cli/tui/widgets/loading.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING
 from textual.content import Content
 from textual.widgets import Static
 
-from soothe_cli.runtime.presentation.duration_format import format_duration
+from soothe_cli.runtime.presentation.duration_format import format_running_elapsed
 from soothe_cli.tui import theme
 from soothe_cli.tui.config import get_glyphs
 
@@ -101,7 +101,7 @@ class LoadingWidget(Static):
         return f" {status}... "
 
     def _format_hint_line(self, elapsed_secs: float, *, include_interrupt: bool = False) -> str:
-        duration = format_duration(elapsed_secs)
+        duration = format_running_elapsed(elapsed_secs)
         segments: list[str] = []
         if self._hint_extra:
             segments.append(self._hint_extra)
@@ -121,7 +121,7 @@ class LoadingWidget(Static):
         status_part = Content.styled(self._format_status_line(self._status), colors.primary)
         if self._paused:
             spinner_part = Content.styled(get_glyphs().pause, "dim")
-            paused_duration = format_duration(float(self._paused_total_elapsed))
+            paused_duration = format_running_elapsed(float(self._paused_total_elapsed))
             if self._show_interrupt_hint:
                 paused_hint = f" (paused at {paused_duration} · esc to interrupt)"
             else:

{soothe_cli-0.7.11 → soothe_cli-0.7.12}/src/soothe_cli/tui/widgets/messages/cognition_goal_tree.py

@@ -11,7 +11,7 @@ from textual.containers import Vertical
 from textual.content import Content
 from textual.widgets import Static
 
-from soothe_cli.runtime.presentation.duration_format import format_duration
+from soothe_cli.runtime.presentation.duration_format import format_duration, format_running_elapsed
 from soothe_cli.tui import theme
 from soothe_cli.tui.config import get_glyphs
 from soothe_cli.tui.preview_limits import PLAN_QUICK_VIEW_STEP_LINE_MAX_CHARS
@@ -253,8 +253,7 @@ class CognitionGoalTreeMessage(Vertical):
         if st.phase == "running":
             parts: list[str] = []
             if st.started_at is not None:
-                elapsed_s = max(0.001, time() - st.started_at)
-                parts.append(format_duration(elapsed_s))
+                parts.append(format_running_elapsed(time() - st.started_at))
             if st.tool_call_count > 0:
                 parts.append(f"{st.tool_call_count} tools")
             if not parts:

{soothe_cli-0.7.11 → soothe_cli-0.7.12}/src/soothe_cli/tui/widgets/messages/cognition_step_activity.py

@@ -19,7 +19,7 @@ from soothe_sdk.ux.task_namespace import (
 )
 from textual.content import Content
 
-from soothe_cli.runtime.presentation.duration_format import format_duration
+from soothe_cli.runtime.presentation.duration_format import format_running_elapsed
 from soothe_cli.tui import theme
 from soothe_cli.tui.commands.subagent_routing import get_subagent_display_name
 from soothe_cli.tui.preview_limits import STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT
@@ -433,7 +433,7 @@ class StepCardStatusLine:
         """Step card footer while executing."""
         elapsed = ""
         if elapsed_secs is not None:
-            elapsed = f" ({format_duration(float(elapsed_secs))})"
+            elapsed = f" ({format_running_elapsed(float(elapsed_secs))})"
         head = f"{gutter}{spinner_frame} Running{retry_suffix}...{elapsed}"
         tail = f"{stats_suffix}{token_suffix}"
         parts: list[object] = [Content.styled(head, colors.warning)]

{soothe_cli-0.7.11 → soothe_cli-0.7.12}/src/soothe_cli/tui/widgets/plan_quick_view_overlay.py

@@ -108,6 +108,7 @@ class PlanQuickViewOverlay(Vertical):
 
     def on_mount(self) -> None:
         self._content = self.query_one("#plan-quick-view-content", Static)
+        self.query_one("#plan-quick-view-body", VerticalScroll).can_focus = False
         self.display = False
 
     @property

soothe_cli-0.7.11/src/soothe_cli/__init__.py

@@ -1,10 +0,0 @@
-"""Soothe CLI client - communicates with daemon via WebSocket."""
-
-import importlib.metadata
-
-try:
-    __version__ = importlib.metadata.version("soothe-cli")
-except importlib.metadata.PackageNotFoundError:
-    __version__ = "0.0.0"
-
-__all__ = []

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

@@ -1,21 +0,0 @@
-"""Version information and lightweight constants for `soothe`."""
-
-from importlib.metadata import PackageNotFoundError, version
-
-try:
-    __version__ = version("soothe")
-except PackageNotFoundError:
-    # Fallback for development/editable installs
-    __version__ = "0.0.0"
-
-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."""